[IMP] devtools: update the devtools documentation

This commit updates the devtools documentation to match with its latest content and updates screenshots to odoo v17.
2025-10-06 19:59:41 +07:00 · 2023-11-13 12:24:04 +01:00
79 changed files with 5941 additions and 9213 deletions
@@ -14,7 +14,7 @@ jobs:

    strategy:
      matrix:
-        node-version: [20.x, 22.x]
+        node-version: [12.x, 14.x, 16.x]

    steps:
    - uses: actions/checkout@v2
@@ -47,4 +47,3 @@ Utility/helpers:
 - [`status`](reference/component.md#status-helper): utility function to get the status of a component (new, mounted or destroyed)
 - [`validate`](reference/utils.md#validate): validates if an object satisfies a specified schema
 - [`whenReady`](reference/utils.md#whenready): utility function to execute code when DOM is ready
- [`batched`](reference/utils.md#batched): utility function to batch function calls
@@ -6,7 +6,6 @@
 - [API](#api)
 - [Configuration](#configuration)
 - [`mount` helper](#mount-helper)
- [Roots](#roots)
 - [Loading templates](#loading-templates)

 ## Overview
@@ -62,13 +61,8 @@ The `config` object is an object with some of the following keys:
  templates (see [translations](translations.md))
 - **`templates (string | xml document)`**: all the templates that will be used by
  the components created by the application.
- **`getTemplate ((s: string) => Element | Function | string | void)`**: a function that will be called by owl when it
-  needs a template. If undefined is returned, owl looks into the app templates.
 - **`warnIfNoStaticProps (boolean, default=false)`**: if true, Owl will log a warning
  whenever it encounters a component that does not provide a [static props description](props.md#props-validation).
- **`customDirectives (object)`**: if given, the corresponding function on the object will be called
-  on the template custom directives: `t-custom-*` (see [Custom Directives](templates.md#custom-directives)).
- **`globalValues (object)`**: Global object of elements available at compilations.

 ## `mount` helper

@@ -96,33 +90,6 @@ Most of the time, the `mount` helper is more convenient, but whenever one needs
 a reference to the actual Owl App, then using the `App` class directly is
 possible.

-## Roots
-
-An application can have multiple roots. It is sometimes useful to instantiate
-sub components in places that are not managed by Owl, such as an html editor
-with dynamic content (the Knowledge application in Odoo).
-
-To create a root, one can use the `createRoot` method, which takes two arguments:
-
- **`Component`**: a component class (Root component of the app)
- **`config (optional)`**: a config object that may contain a `props` object or a
-  `env` object.
-
-The `createRoot` method returns an object with a `mount` method (same API as
-the `App.mount` method), and a `destroy` method.
-
-```js
-const root = app.createRoot(MyComponent, { props: { someProps: true } });
-await root.mount(targetElement);
-
-// later
-root.destroy();
-```
-
-Note that, like with owl `App`, it is the responsibility of the code that created
-the root to properly destroy it (before it has been removed from the DOM!). Owl
-has no way of doing it itself.
-
 ## Loading templates

 Most applications will need to load templates whenever they start. Here is
@@ -140,28 +140,6 @@ class SomeComponent extends Component {
 The `.bind` suffix also implies `.alike`, so these props will not cause additional
 renderings.

-## Translatable props
-
-When you need to pass a user-facing string to a subcomponent, you likely want it
-to be translated. Unfortunately, because props are arbitrary expressions, it wouldn't
-be practical for Owl to find out which parts of the expression are strings and translate
-them, and it also makes it difficult for tooling to extract these strings to generate
-terms to translate. While you can work around this issue by doing the translation in
-JavaScript, or by using `t-set` with a body (the body of `t-set` is translated),
-and passing the variable as a prop, this is a sufficiently common use case that Owl
-provides a suffix for this purpose: `.translate`.
-
-```xml
-<t t-name="ParentComponent">
-    <Child someProp.translate="some message"/>
-</t>
-```
-
-Note that the content of this attribute is _NOT_ treated as a JavaScript expression:
-it is treated as a string, as if it was an attribute on an HTML element, and translated
-before being passed to the component. If you need to interpolate some data into the
-string, you will still have to do this in JavaScript.
-
 ## Dynamic Props

 The `t-props` directive can be used to specify totally dynamic props:
@@ -260,7 +238,7 @@ class ComponentB extends owl.Component {
    count: {type: Number},
    messages: {
      type: Array,
-      element: {type: Object, shape: {id: Boolean, text: String }}
+      element: {type: Object, shape: {id: Boolean, text: String }
    },
   date: Date,
   combinedVal: [Number, Boolean],
@@ -298,8 +276,7 @@ class ComponentB extends owl.Component {
        id: Number,
        name: {type: String, optional: true},
        url: String
-      }
-    },  // object, with keys id (number), name (string, optional) and url (string)
+      ]},    // object, with keys id (number), name (string, optional) and url (string)
    someObj3: {
      type: Object,
      values: { type: Array, element: String },
@@ -152,7 +152,7 @@ This may seem counter-intuitive, but it makes perfect sense in the context of co
 ```js
 class DoubleCounter extends Component {
  static template = xml`
-    <t t-esc="'selected: ' + state.selected + ', value: ' + state[state.selected]"/>
+    <t t-esc="state.selected + ': ' + state[state.selected].value"/>
    <button t-on-click="() => this.state.count1++">increment count 1</button>
    <button t-on-click="() => this.state.count2++">increment count 2</button>
    <button t-on-click="changeCounter">Switch counter</button>
@@ -193,7 +193,7 @@ to be able to opt out of creating them in the first place. This is the purpose o
 ### `markRaw`

 Marks an object so that it is ignored by the reactivity system, meaning that if this object is ever
-part of a reactive object, it will be returned as is, and no keys in that object will be
+part of a of a reactive object, it will be returned as is, and no keys in that object will be
 observed.

 ```js
@@ -133,7 +133,7 @@ Slots can define a default content, in case the parent did not define them:
 ## Dynamic Slots

 The `t-slot` directive is actually able to use any expressions, using string
-interpolation:
+interplolation:

 ```xml
 <t t-slot="{{current}}" />
@@ -201,17 +201,16 @@ use this `Notebook` component:

 ```xml
 <Notebook>
-  <t t-set-slot="page1" title.translate="Page 1">
+  <t t-set-slot="page1" title="'Page 1'">
    <div>this is in the page 1</div>
  </t>
-  <t t-set-slot="page2" title.translate="Page 2" hidden="somevalue">
+  <t t-set-slot="page2" title="'Page 2'" hidden="somevalue">
    <div>this is in the page 2</div>
  </t>
 </Notebook>
 ```

-Slot params works like normal props, so one can use suffixes like `.translate`
-when a prop is a user facing string and should be translated, or `.bind` to
+Slot params works like normal props, so one can use the `.bind` suffix to
 bind a function if needed.

 ## Slot scopes
@@ -18,7 +18,6 @@
  - [Sub Templates](#sub-templates)
  - [Dynamic Sub Templates](#dynamic-sub-templates)
  - [Debugging](#debugging)
-  - [Custom Directives](#custom-directives)
 - [Fragments](#fragments)
 - [Inline templates](#inline-templates)
 - [Rendering svg](#rendering-svg)
@@ -81,7 +80,6 @@ needs. Here is a list of all Owl specific directives:
 | `t-slot`, `t-set-slot`, `t-slot-scope` | [Rendering a slot](slots.md)                                    |
 | `t-model`                              | [Form input bindings](input_bindings.md)                        |
 | `t-tag`                                | [Rendering nodes with dynamic tag name](#dynamic-tag-names)     |
-| `t-custom-*`                           | [Rendering nodes with custom directives](#custom-directives)    |

 ## QWeb Template Reference

@@ -590,35 +588,6 @@ will stop execution if the browser dev tools are open.

 will print 42 to the console.

-### Custom Directives
-
-Owl 2 supports the declaration of custom directives. To use them, an Object of functions needs to be configured on the owl APP:
-
-```js
- new App(..., {
-    customDirectives: {
-     test_directive: function (el, value) {
-            el.setAttribute("t-on-click", value);
-       }
-   }
-  });
-```
-
-The functions will be called when a custom directive with the name of the
-function is found. The original element will be replaced with the one
-modified by the function.
-This :
-
-```xml
-<div t-custom-test_directive="click" />
-```
-
-will be replaced by :
-
-```xml
-<div t-on-click="value"/>
-```
-
 ## Fragments

 Owl 2 supports templates with an arbitrary number of root elements, or even just
@@ -9,7 +9,6 @@ functions are all available in the `owl.utils` namespace.
 - [`loadFile`](#loadfile): loading a file (useful for templates)
 - [`EventBus`](#eventbus): a simple EventBus
 - [`validate`](#validate): a validation function
- [`batched`](#batched): batch function calls

 ## `whenReady`

@@ -79,22 +78,3 @@ validate(
 //    - 'id' is missing (should be a number),
 //    - 'url' is missing (should be a boolean or list of numbers),
 ```
-
-## `batched`
-
-The `batched` function creates a batched version of a callback so that multiple calls to it within the same microtick will only result in a single invocation of the original callback.
-
-```js
-function hello() {
-  console.log("hello");
-}
-
-const batchedHello = batched(hello);
-batchedHello();
-// Nothing is logged
-batchedHello();
-// Still not logged
-
-await Promise.resolve(); // Await the next microtick
-// "hello" is logged only once
-```
@@ -41,7 +41,7 @@ one. There can also be multiple apps loaded in the page like in website:

 There is a convenient search bar at the top of the components tree which will help finding
 the components tou want in the tree and also, an element picker can be used to directly select
-the component you want to focus on in the page which is especially useful when 1trying to find
+the component you want to focus on in the page which is especially useful when trying to find
 what you want. Just click on the elements picker icon and click on the element you want to focus
 on in the page and it will be selected in the devtools accordingly. Hovering any element in the
 page in this mode will highlight it and the same happens anytime in the components tree.
@@ -1625,13 +1625,6 @@ function makeRootFiber(node) {
            fibersInError.delete(current);
            fibersInError.delete(root);
            current.appliedToDom = false;
-            if (current instanceof RootFiber) {
-                // it is possible that this fiber is a fiber that crashed while being
-                // mounted, so the mounted list is possibly corrupted. We restore it to
-                // its normal initial state (which is empty list or a list with a mount
-                // fiber.
-                current.mounted = current instanceof MountFiber ? [current] : [];
-            }
        }
        return current;
    }
@@ -1748,7 +1741,6 @@ class RootFiber extends Fiber {
        const node = this.node;
        this.locked = true;
        let current = undefined;
-        let mountedFibers = this.mounted;
        try {
            // Step 1: calling all willPatch lifecycle hooks
            for (current of this.willPatch) {
@@ -1768,6 +1760,7 @@ class RootFiber extends Fiber {
            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) {
@@ -1788,15 +1781,6 @@ class RootFiber extends Fiber {
            }
        }
        catch (e) {
-            // if mountedFibers is not empty, this means that a crash occured while
-            // calling the mounted hooks of some component. So, there may still be
-            // some component that have been mounted, but for which the mounted hooks
-            // have not been called. Here, we remove the willUnmount hooks for these
-            // specific component to prevent a worse situation (willUnmount being
-            // called even though mounted has not been called)
-            for (let fiber of mountedFibers) {
-                fiber.node.willUnmount = [];
-            }
            this.locked = false;
            node.app.handleError({ fiber: current || this, error: e });
        }
@@ -1866,9 +1850,8 @@ const NO_CALLBACK = () => {
 };
 const objectToString = Object.prototype.toString;
 const objectHasOwnProperty = Object.prototype.hasOwnProperty;
-// Use arrays because Array.includes is faster than Set.has for small arrays
-const SUPPORTED_RAW_TYPES = ["Object", "Array", "Set", "Map", "WeakMap"];
-const COLLECTION_RAW_TYPES = ["Set", "Map", "WeakMap"];
+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])
@@ -1891,7 +1874,7 @@ function canBeMadeReactive(value) {
    if (typeof value !== "object") {
        return false;
    }
-    return SUPPORTED_RAW_TYPES.includes(rawType(value));
+    return SUPPORTED_RAW_TYPES.has(rawType(value));
 }
 /**
 * Creates a reactive from the given object/callback if possible and returns it,
@@ -2061,7 +2044,7 @@ function reactive(target, callback = NO_CALLBACK) {
    const reactivesForTarget = reactiveCache.get(target);
    if (!reactivesForTarget.has(callback)) {
        const targetRawType = rawType(target);
-        const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
+        const handler = COLLECTION_RAWTYPES.has(targetRawType)
            ? collectionsProxyHandler(target, callback, targetRawType)
            : basicProxyHandler(callback);
        const proxy = new Proxy(target, handler);
@@ -2090,7 +2073,7 @@ function basicProxyHandler(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, toRaw(value), receiver);
+            const ret = Reflect.set(target, key, value, receiver);
            if (!hadKey && objectHasOwnProperty.call(target, key)) {
                notifyReactives(target, KEYCHANGES);
            }
@@ -2286,12 +2269,6 @@ function collectionsProxyHandler(target, callback, targetRawType) {
 }

 let currentNode = null;
-function saveCurrent() {
-    let n = currentNode;
-    return () => {
-        currentNode = n;
-    };
-}
 function getCurrent() {
    if (!currentNode) {
        throw new OwlError("No active component (a hook function should only be called in 'setup')");
@@ -2620,47 +2597,42 @@ class ComponentNode {
 }

 const TIMEOUT = Symbol("timeout");
-const HOOK_TIMEOUT = {
-    onWillStart: 3000,
-    onWillUpdateProps: 3000,
-};
 function wrapError(fn, hookName) {
-    const error = new OwlError();
-    const timeoutError = new OwlError();
+    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;
-            error.message =
-                cause instanceof Error
-                    ? `The following error occurred in ${hookName}: "${cause.message}"`
-                    : `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+            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;
        };
-        let result;
        try {
-            result = fn(...args);
+            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);
        }
-        if (!(result instanceof Promise)) {
-            return result;
-        }
-        const timeout = HOOK_TIMEOUT[hookName];
-        if (timeout) {
-            const fiber = node.fiber;
-            Promise.race([
-                result.catch(() => { }),
-                new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), timeout)),
-            ]).then((res) => {
-                if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
-                    timeoutError.message = `${hookName}'s promise hasn't resolved after ${timeout / 1000} seconds`;
-                    console.log(timeoutError);
-                }
-            });
-        }
-        return result.catch(onError);
    };
 }
 // -----------------------------------------------------------------------------
@@ -3187,14 +3159,8 @@ const helpers = {
    makeRefWrapper,
 };

-/**
- * 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 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) {
@@ -3221,9 +3187,7 @@ function parseXML(xml) {
        throw new OwlError(msg);
    }
    return doc;
-}
-
-const bdom = { text, createBlock, list, multi, html, toggler, comment };
+}
 class TemplateSet {
    constructor(config = {}) {
        this.rawTemplates = Object.create(globalTemplates);
@@ -3233,19 +3197,8 @@ class TemplateSet {
        this.translateFn = config.translateFn;
        this.translatableAttributes = config.translatableAttributes;
        if (config.templates) {
-            if (config.templates instanceof Document || typeof config.templates === "string") {
-                this.addTemplates(config.templates);
-            }
-            else {
-                for (const name in config.templates) {
-                    this.addTemplate(name, config.templates[name]);
-                }
-            }
+            this.addTemplates(config.templates);
        }
-        this.getRawTemplate = config.getTemplate;
-        this.customDirectives = config.customDirectives || {};
-        this.runtimeUtils = { ...helpers, __globals__: config.globalValues || {} };
-        this.hasGlobalValues = Boolean(config.globalValues && Object.keys(config.globalValues).length);
    }
    static registerTemplate(name, fn) {
        globalTemplates[name] = fn;
@@ -3275,16 +3228,15 @@ class TemplateSet {
            // empty string
            return;
        }
-        xml = xml instanceof Document ? xml : parseXML(xml);
+        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) {
-        var _a;
        if (!(name in this.templates)) {
-            const rawTemplate = ((_a = this.getRawTemplate) === null || _a === void 0 ? void 0 : _a.call(this, name)) || this.rawTemplates[name];
+            const rawTemplate = this.rawTemplates[name];
            if (rawTemplate === undefined) {
                let extraInfo = "";
                try {
@@ -3302,7 +3254,7 @@ class TemplateSet {
            this.templates[name] = function (context, parent) {
                return templates[name].call(this, context, parent);
            };
-            const template = templateFn(this, bdom, this.runtimeUtils);
+            const template = templateFn(this, bdom, helpers);
            this.templates[name] = template;
        }
        return this.templates[name];
@@ -3353,7 +3305,7 @@ TemplateSet.registerTemplate("__portal__", portalTemplate);
 //------------------------------------------------------------------------------
 // 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,__globals__".split(",");
+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: "||",
@@ -3542,7 +3494,7 @@ function compileExprToArray(expr) {
    const localVars = new Set();
    const tokens = tokenize(expr);
    let i = 0;
-    let stack = []; // to track last opening (, [ or {
+    let stack = []; // to track last opening [ or {
    while (i < tokens.length) {
        let token = tokens[i];
        let prevToken = tokens[i - 1];
@@ -3551,12 +3503,10 @@ function compileExprToArray(expr) {
        switch (token.type) {
            case "LEFT_BRACE":
            case "LEFT_BRACKET":
-            case "LEFT_PAREN":
                stack.push(token.type);
                break;
            case "RIGHT_BRACE":
            case "RIGHT_BRACKET":
-            case "RIGHT_PAREN":
                stack.pop();
        }
        let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
@@ -3668,13 +3618,6 @@ function isProp(tag, key) {
    }
    return false;
 }
-/**
- * Returns a template literal that evaluates to str. You can add interpolation
- * sigils into the string if required
- */
-function toStringExpression(str) {
-    return `\`${str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/, "\\${")}\``;
-}
 // -----------------------------------------------------------------------------
 // BlockDescription
 // -----------------------------------------------------------------------------
@@ -3825,9 +3768,6 @@ class CodeGenerator {
        this.dev = options.dev || false;
        this.ast = ast;
        this.templateName = options.name;
-        if (options.hasGlobalValues) {
-            this.helpers.add("__globals__");
-        }
    }
    generateCode() {
        const ast = this.ast;
@@ -3858,14 +3798,15 @@ class CodeGenerator {
            mainCode.push(``);
            for (let block of this.blocks) {
                if (block.dom) {
-                    let xmlString = toStringExpression(block.asXmlString());
+                    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});`);
+                        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});`);
+                        mainCode.push(`let ${block.blockName} = createBlock(\`${xmlString}\`);`);
                    }
                }
            }
@@ -4043,7 +3984,7 @@ class CodeGenerator {
        const isNewBlock = !block || forceNewBlock;
        if (isNewBlock) {
            block = this.createBlock(block, "comment", ctx);
-            this.insertBlock(`comment(${toStringExpression(ast.value)})`, block, {
+            this.insertBlock(`comment(\`${ast.value}\`)`, block, {
                ...ctx,
                forceNewBlock: forceNewBlock && !block,
            });
@@ -4065,7 +4006,7 @@ class CodeGenerator {
        }
        if (!block || forceNewBlock) {
            block = this.createBlock(block, "text", ctx);
-            this.insertBlock(`text(${toStringExpression(value)})`, block, {
+            this.insertBlock(`text(\`${value}\`)`, block, {
                ...ctx,
                forceNewBlock: forceNewBlock && !block,
            });
@@ -4286,8 +4227,7 @@ class CodeGenerator {
            expr = compileExpr(ast.expr);
            if (ast.defaultValue) {
                this.helpers.add("withDefault");
-                // FIXME: defaultValue is not translated
-                expr = `withDefault(${expr}, ${toStringExpression(ast.defaultValue)})`;
+                expr = `withDefault(${expr}, \`${ast.defaultValue}\`)`;
            }
        }
        if (!block || forceNewBlock) {
@@ -4540,7 +4480,7 @@ class CodeGenerator {
                this.addLine(`${ctxVar}[zero] = ${bl};`);
            }
        }
-        const key = this.generateComponentKey();
+        const key = `key + \`${this.generateComponentKey()}\``;
        if (isDynamic) {
            const templateVar = generateId("template");
            if (!this.staticDefs.find((d) => d.id === "call")) {
@@ -4592,12 +4532,12 @@ class CodeGenerator {
        else {
            let value;
            if (ast.defaultValue) {
-                const defaultValue = toStringExpression(ctx.translate ? this.translate(ast.defaultValue) : ast.defaultValue);
+                const defaultValue = ctx.translate ? this.translate(ast.defaultValue) : ast.defaultValue;
                if (ast.value) {
-                    value = `withDefault(${expr}, ${defaultValue})`;
+                    value = `withDefault(${expr}, \`${defaultValue}\`)`;
                }
                else {
-                    value = defaultValue;
+                    value = `\`${defaultValue}\``;
                }
            }
            else {
@@ -4608,12 +4548,12 @@ class CodeGenerator {
        }
        return null;
    }
-    generateComponentKey(currentKey = "key") {
+    generateComponentKey() {
        const parts = [generateId("__")];
        for (let i = 0; i < this.target.loopLevel; i++) {
            parts.push(`\${key${i + 1}}`);
        }
-        return `${currentKey} + \`${parts.join("__")}\``;
+        return parts.join("__");
    }
    /**
     * Formats a prop name and value into a string suitable to be inserted in the
@@ -4627,12 +4567,7 @@ class CodeGenerator {
     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
     */
    formatProp(name, value) {
-        if (name.endsWith(".translate")) {
-            value = toStringExpression(this.translateFn(value));
-        }
-        else {
-            value = this.captureExpression(value);
-        }
+        value = this.captureExpression(value);
        if (name.includes(".")) {
            let [_name, suffix] = name.split(".");
            name = _name;
@@ -4641,7 +4576,6 @@ class CodeGenerator {
                    value = `(${value}).bind(this)`;
                    break;
                case "alike":
-                case "translate":
                    break;
                default:
                    throw new OwlError("Invalid prop suffix");
@@ -4710,6 +4644,7 @@ class CodeGenerator {
            this.addLine(`${propVar}.slots = markRaw(Object.assign(${slotDef}, ${propVar}.slots))`);
        }
        // cmap key
+        const key = this.generateComponentKey();
        let expr;
        if (ast.isDynamic) {
            expr = generateId("Comp");
@@ -4725,7 +4660,7 @@ class CodeGenerator {
            // todo: check the forcenewblock condition
            this.insertAnchor(block);
        }
-        let keyArg = this.generateComponentKey();
+        let keyArg = `key + \`${key}\``;
        if (ctx.tKeyExpr) {
            keyArg = `${ctx.tKeyExpr} + ${keyArg}`;
        }
@@ -4798,7 +4733,7 @@ class CodeGenerator {
        }
        let key = this.target.loopLevel ? `key${this.target.loopLevel}` : "key";
        if (isMultiple) {
-            key = this.generateComponentKey(key);
+            key = `${key} + \`${this.generateComponentKey()}\``;
        }
        const props = ast.attrs ? this.formatPropObject(ast.attrs) : [];
        const scope = this.getPropString(props, dynProps);
@@ -4839,6 +4774,7 @@ class CodeGenerator {
        }
        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");
@@ -4851,8 +4787,7 @@ class CodeGenerator {
            expr: `app.createComponent(null, false, true, false, false)`,
        });
        const target = compileExpr(ast.target);
-        const key = this.generateComponentKey();
-        const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, ${key}, node, ctx, Portal)`;
+        const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, key + \`${key}\`, node, ctx, Portal)`;
        if (block) {
            this.insertAnchor(block);
        }
@@ -4866,33 +4801,29 @@ class CodeGenerator {
 // Parser
 // -----------------------------------------------------------------------------
 const cache = new WeakMap();
-function parse(xml, customDir) {
-    const ctx = {
-        inPreTag: false,
-        customDirectives: customDir,
-    };
+function parse(xml) {
    if (typeof xml === "string") {
        const elem = parseXML(`<t>${xml}</t>`).firstChild;
-        return _parse(elem, ctx);
+        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), ctx);
+        ast = _parse(xml.cloneNode(true));
        cache.set(xml, ast);
    }
    return ast;
 }
-function _parse(xml, ctx) {
+function _parse(xml) {
    normalizeXML(xml);
+    const ctx = { inPreTag: false };
    return parseNode(xml, ctx) || { type: 0 /* Text */, value: "" };
 }
 function parseNode(node, ctx) {
    if (!(node instanceof Element)) {
        return parseTextCommentNode(node, ctx);
    }
-    return (parseTCustom(node, ctx) ||
-        parseTDebugLog(node, ctx) ||
+    return (parseTDebugLog(node, ctx) ||
        parseTForEach(node, ctx) ||
        parseTIf(node, ctx) ||
        parseTPortal(node, ctx) ||
@@ -4934,35 +4865,6 @@ function parseTextCommentNode(node, ctx) {
    }
    return null;
 }
-function parseTCustom(node, ctx) {
-    if (!ctx.customDirectives) {
-        return null;
-    }
-    const nodeAttrsNames = node.getAttributeNames();
-    for (let attr of nodeAttrsNames) {
-        if (attr === "t-custom" || attr === "t-custom-") {
-            throw new OwlError("Missing custom directive name with t-custom directive");
-        }
-        if (attr.startsWith("t-custom-")) {
-            const directiveName = attr.split(".")[0].slice(9);
-            const customDirective = ctx.customDirectives[directiveName];
-            if (!customDirective) {
-                throw new OwlError(`Custom directive "${directiveName}" is not defined`);
-            }
-            const value = node.getAttribute(attr);
-            const modifiers = attr.split(".").slice(1);
-            node.removeAttribute(attr);
-            try {
-                customDirective(node, value, modifiers);
-            }
-            catch (error) {
-                throw new OwlError(`Custom directive "${directiveName}" throw the following error: ${error}`);
-            }
-            return parseNode(node, ctx);
-        }
-    }
-    return null;
-}
 // -----------------------------------------------------------------------------
 // debugging
 // -----------------------------------------------------------------------------
@@ -5044,9 +4946,9 @@ function parseDOMNode(node, ctx) {
            const isSelect = tagName === "select";
            const isCheckboxInput = isInput && typeAttr === "checkbox";
            const isRadioInput = isInput && typeAttr === "radio";
-            const hasTrimMod = attr.includes(".trim");
-            const hasLazyMod = hasTrimMod || attr.includes(".lazy");
+            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,
@@ -5377,14 +5279,14 @@ function parseComponent(node, ctx) {
            // be ignored)
            let el = slotNode.parentElement;
            let isInSubComponent = false;
-            while (el && el !== clone) {
+            while (el !== clone) {
                if (el.hasAttribute("t-component") || el.tagName[0] === el.tagName[0].toUpperCase()) {
                    isInSubComponent = true;
                    break;
                }
                el = el.parentElement;
            }
-            if (isInSubComponent || !el) {
+            if (isInSubComponent) {
                continue;
            }
            slotNode.removeAttribute("t-set-slot");
@@ -5592,13 +5494,46 @@ function normalizeTEscTOut(el) {
 function normalizeXML(el) {
    normalizeTIf(el);
    normalizeTEscTOut(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 = {
-    hasGlobalValues: false,
-}) {
+function compile(template, options = {}) {
    // parsing
-    const ast = parse(template, options.customDirectives);
+    const ast = parse(template);
    // some work
    const hasSafeContext = template instanceof Node
        ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
@@ -5620,7 +5555,7 @@ function compile(template, options = {
 }

 // do not modify manually. This file is generated by the release script.
-const version = "2.5.2";
+const version = "2.2.6";

 // -----------------------------------------------------------------------------
 //  Scheduler
@@ -5631,7 +5566,6 @@ class Scheduler {
        this.frame = 0;
        this.delayedRenders = [];
        this.cancelledNodes = new Set();
-        this.processing = false;
        this.requestAnimationFrame = Scheduler.requestAnimationFrame;
    }
    addFiber(fiber) {
@@ -5662,10 +5596,6 @@ class Scheduler {
        }
    }
    processTasks() {
-        if (this.processing) {
-            return;
-        }
-        this.processing = true;
        this.frame = 0;
        for (let node of this.cancelledNodes) {
            node._destroy();
@@ -5679,7 +5609,6 @@ class Scheduler {
                this.tasks.delete(task);
            }
        }
-        this.processing = false;
    }
    processFiber(fiber) {
        if (fiber.root !== fiber) {
@@ -5699,14 +5628,7 @@ class Scheduler {
            if (!hasError) {
                fiber.complete();
            }
-            // at this point, the fiber should have been applied to the DOM, so we can
-            // remove it from the task list. If it is not the case, it means that there
-            // was an error and an error handler triggered a new rendering that recycled
-            // the fiber, so in that case, we actually want to keep the fiber around,
-            // otherwise it will just be ignored.
-            if (fiber.appliedToDom) {
-                this.tasks.delete(fiber);
-            }
+            this.tasks.delete(fiber);
        }
    }
 }
@@ -5728,7 +5650,6 @@ class App extends TemplateSet {
    constructor(Root, config = {}) {
        super(config);
        this.scheduler = new Scheduler();
-        this.subRoots = new Set();
        this.root = null;
        this.name = config.name || "";
        this.Root = Root;
@@ -5747,44 +5668,14 @@ class App extends TemplateSet {
        this.props = config.props || {};
    }
    mount(target, options) {
-        const root = this.createRoot(this.Root, { props: this.props });
-        this.root = root.node;
-        this.subRoots.delete(root.node);
-        return root.mount(target, options);
-    }
-    createRoot(Root, config = {}) {
-        const props = config.props || {};
-        // hack to make sure the sub root get the sub env if necessary. for owl 3,
-        // would be nice to rethink the initialization process to make sure that
-        // we can create a ComponentNode and give it explicitely the env, instead
-        // of looking it up in the app
-        const env = this.env;
-        if (config.env) {
-            this.env = config.env;
+        App.validateTarget(target);
+        if (this.dev) {
+            validateProps(this.Root, this.props, { __owl__: { app: this } });
        }
-        const restore = saveCurrent();
-        const node = this.makeNode(Root, props);
-        restore();
-        if (config.env) {
-            this.env = env;
-        }
-        this.subRoots.add(node);
-        return {
-            node,
-            mount: (target, options) => {
-                App.validateTarget(target);
-                if (this.dev) {
-                    validateProps(Root, props, { __owl__: { app: this } });
-                }
-                const prom = this.mountNode(node, target, options);
-                return prom;
-            },
-            destroy: () => {
-                this.subRoots.delete(node);
-                node.destroy();
-                this.scheduler.processTasks();
-            },
-        };
+        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);
@@ -5816,9 +5707,6 @@ class App extends TemplateSet {
    }
    destroy() {
        if (this.root) {
-            for (let subroot of this.subRoots) {
-                subroot.destroy();
-            }
            this.root.destroy();
            this.scheduler.processTasks();
        }
@@ -6014,7 +5902,7 @@ function useChildSubEnv(envExtension) {
 *
 * @template T
 * @param {Effect<T>} effect the effect to run on component mount and/or patch
- * @param {()=>[...T]} [computeDependencies=()=>[NaN]] a callback to compute
+ * @param {()=>T} [computeDependencies=()=>[NaN]] a callback to compute
 *      dependencies that will decide if the effect needs to be cleaned up and
 *      run again. If the dependencies did not change, the effect will not run
 *      again. The default value returns an array containing only NaN because
@@ -6090,14 +5978,12 @@ TemplateSet.prototype._compileTemplate = function _compileTemplate(name, templat
        dev: this.dev,
        translateFn: this.translateFn,
        translatableAttributes: this.translatableAttributes,
-        customDirectives: this.customDirectives,
-        hasGlobalValues: this.hasGlobalValues,
    });
 };

-export { App, Component, EventBus, OwlError, __info__, batched, blockDom, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, validateType, whenReady, xml };
+export { App, Component, EventBus, OwlError, __info__, blockDom, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, validateType, whenReady, xml };


-__info__.date = '2024-12-02T15:51:07.157Z';
-__info__.hash = '1c5b6f2';
+__info__.date = '2023-09-25T11:48:01.531Z';
+__info__.hash = '752160f';
 __info__.url = 'https://github.com/odoo/owl';
@@ -41,6 +41,9 @@ const loadFile = (path) => {
 * Make an iframe, with all the js, css and xml properly injected.
 */
 function makeCodeIframe(js, css, xml) {
+  // escape backticks in the xml so they don't close the template string
+  const escapedXml = xml.replace(/`/g, '\\\`');
+
  const iframe = document.createElement("iframe");
  iframe.onload = () => {
    const doc = iframe.contentDocument;
@@ -52,8 +55,6 @@ function makeCodeIframe(js, css, xml) {

    const script = doc.createElement("script");
    script.type = "module";
-    // escape characters with special meaning in template literals
-    const escapedXml = xml.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/, "\\${");
    script.textContent = `const TEMPLATES = \`${escapedXml}\`\n${js}`;
    doc.body.appendChild(script);

@@ -1,6 +1,6 @@
 {
  "name": "@odoo/owl",
-  "version": "2.5.2",
+  "version": "2.2.6",
  "lockfileVersion": 1,
  "requires": true,
  "dependencies": {
@@ -1,6 +1,6 @@
 {
  "name": "@odoo/owl",
-  "version": "2.5.2",
+  "version": "2.2.6",
  "description": "Odoo Web Library (OWL)",
  "main": "dist/owl.cjs.js",
  "module": "dist/owl.es.js",
@@ -9,7 +9,7 @@
    "dist"
  ],
  "engines": {
-    "node": ">=20.0.0"
+    "node": ">=12.18.3"
  },
  "scripts": {
    "build:bundle": "rollup -c --failAfterWarnings",
@@ -1,4 +0,0 @@
-export type customDirectives = Record<
-  string,
-  (node: Element, value: string, modifier: string[]) => void
->;
@@ -1,38 +0,0 @@
-import { OwlError } from "./owl_error";
-
-/**
- * Parses an XML string into an XML document, throwing errors on parser errors
- * instead of returning an XML document containing the parseerror.
- *
- * @param xml the string to parse
- * @returns an XML document corresponding to the content of the string
- */
-export function parseXML(xml: string): XMLDocument {
-  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;
-}
@@ -43,7 +43,6 @@ export interface Config {
 export interface CodeGenOptions extends Config {
  hasSafeContext?: boolean;
  name?: string;
-  hasGlobalValues: boolean;
 }

 // using a non-html document so that <inner/outer>HTML serializes as XML instead
@@ -83,14 +82,6 @@ function isProp(tag: string, key: string): boolean {
  return false;
 }

-/**
- * Returns a template literal that evaluates to str. You can add interpolation
- * sigils into the string if required
- */
-function toStringExpression(str: string) {
-  return `\`${str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/, "\\${")}\``;
-}
-
 // -----------------------------------------------------------------------------
 // BlockDescription
 // -----------------------------------------------------------------------------
@@ -287,9 +278,6 @@ export class CodeGenerator {
    this.dev = options.dev || false;
    this.ast = ast;
    this.templateName = options.name;
-    if (options.hasGlobalValues) {
-      this.helpers.add("__globals__");
-    }
  }

  generateCode(): string {
@@ -323,13 +311,14 @@ export class CodeGenerator {
      mainCode.push(``);
      for (let block of this.blocks) {
        if (block.dom) {
-          let xmlString = toStringExpression(block.asXmlString());
+          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});`);
+            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});`);
+            mainCode.push(`let ${block.blockName} = createBlock(\`${xmlString}\`);`);
          }
        }
      }
@@ -526,7 +515,7 @@ export class CodeGenerator {
    const isNewBlock = !block || forceNewBlock;
    if (isNewBlock) {
      block = this.createBlock(block, "comment", ctx);
-      this.insertBlock(`comment(${toStringExpression(ast.value)})`, block, {
+      this.insertBlock(`comment(\`${ast.value}\`)`, block, {
        ...ctx,
        forceNewBlock: forceNewBlock && !block,
      });
@@ -550,7 +539,7 @@ export class CodeGenerator {

    if (!block || forceNewBlock) {
      block = this.createBlock(block, "text", ctx);
-      this.insertBlock(`text(${toStringExpression(value)})`, block, {
+      this.insertBlock(`text(\`${value}\`)`, block, {
        ...ctx,
        forceNewBlock: forceNewBlock && !block,
      });
@@ -785,8 +774,7 @@ export class CodeGenerator {
      expr = compileExpr(ast.expr);
      if (ast.defaultValue) {
        this.helpers.add("withDefault");
-        // FIXME: defaultValue is not translated
-        expr = `withDefault(${expr}, ${toStringExpression(ast.defaultValue)})`;
+        expr = `withDefault(${expr}, \`${ast.defaultValue}\`)`;
      }
    }
    if (!block || forceNewBlock) {
@@ -1051,7 +1039,7 @@ export class CodeGenerator {
      }
    }

-    const key = this.generateComponentKey();
+    const key = `key + \`${this.generateComponentKey()}\``;
    if (isDynamic) {
      const templateVar = generateId("template");
      if (!this.staticDefs.find((d) => d.id === "call")) {
@@ -1103,13 +1091,11 @@ export class CodeGenerator {
    } else {
      let value: string;
      if (ast.defaultValue) {
-        const defaultValue = toStringExpression(
-          ctx.translate ? this.translate(ast.defaultValue) : ast.defaultValue
-        );
+        const defaultValue = ctx.translate ? this.translate(ast.defaultValue) : ast.defaultValue;
        if (ast.value) {
-          value = `withDefault(${expr}, ${defaultValue})`;
+          value = `withDefault(${expr}, \`${defaultValue}\`)`;
        } else {
-          value = defaultValue;
+          value = `\`${defaultValue}\``;
        }
      } else {
        value = expr;
@@ -1120,12 +1106,12 @@ export class CodeGenerator {
    return null;
  }

-  generateComponentKey(currentKey: string = "key") {
+  generateComponentKey() {
    const parts = [generateId("__")];
    for (let i = 0; i < this.target.loopLevel; i++) {
      parts.push(`\${key${i + 1}}`);
    }
-    return `${currentKey} + \`${parts.join("__")}\``;
+    return parts.join("__");
  }

  /**
@@ -1140,11 +1126,7 @@ export class CodeGenerator {
   * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
   */
  formatProp(name: string, value: string): string {
-    if (name.endsWith(".translate")) {
-      value = toStringExpression(this.translateFn(value));
-    } else {
-      value = this.captureExpression(value);
-    }
+    value = this.captureExpression(value);
    if (name.includes(".")) {
      let [_name, suffix] = name.split(".");
      name = _name;
@@ -1153,7 +1135,6 @@ export class CodeGenerator {
          value = `(${value}).bind(this)`;
          break;
        case "alike":
-        case "translate":
          break;
        default:
          throw new OwlError("Invalid prop suffix");
@@ -1233,6 +1214,7 @@ export class CodeGenerator {
    }

    // cmap key
+    const key = this.generateComponentKey();
    let expr: string;
    if (ast.isDynamic) {
      expr = generateId("Comp");
@@ -1250,7 +1232,7 @@ export class CodeGenerator {
      this.insertAnchor(block);
    }

-    let keyArg = this.generateComponentKey();
+    let keyArg = `key + \`${key}\``;
    if (ctx.tKeyExpr) {
      keyArg = `${ctx.tKeyExpr} + ${keyArg}`;
    }
@@ -1329,7 +1311,7 @@ export class CodeGenerator {
    }
    let key = this.target.loopLevel ? `key${this.target.loopLevel}` : "key";
    if (isMultiple) {
-      key = this.generateComponentKey(key);
+      key = `${key} + \`${this.generateComponentKey()}\``;
    }

    const props = ast.attrs ? this.formatPropObject(ast.attrs) : [];
@@ -1372,6 +1354,7 @@ export class CodeGenerator {

    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");
@@ -1385,8 +1368,7 @@ export class CodeGenerator {
    });

    const target = compileExpr(ast.target);
-    const key = this.generateComponentKey();
-    const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, ${key}, node, ctx, Portal)`;
+    const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, key + \`${key}\`, node, ctx, Portal)`;
    if (block) {
      this.insertAnchor(block);
    }
@@ -1,4 +1,3 @@
-import type { customDirectives } from "../common/types";
 import type { TemplateSet } from "../runtime/template_set";
 import type { BDom } from "../runtime/blockdom";
 import { CodeGenerator, Config } from "./code_generator";
@@ -11,17 +10,13 @@ export type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Te

 interface CompileOptions extends Config {
  name?: string;
-  customDirectives?: customDirectives;
-  hasGlobalValues: boolean;
 }
 export function compile(
  template: string | Element,
-  options: CompileOptions = {
-    hasGlobalValues: false,
-  }
+  options: CompileOptions = {}
 ): TemplateFunction {
  // parsing
-  const ast = parse(template, options.customDirectives);
+  const ast = parse(template);

  // some work
  const hasSafeContext =
@@ -28,7 +28,7 @@ import { OwlError } from "../common/owl_error";
 //------------------------------------------------------------------------------

 const RESERVED_WORDS =
-  "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date,__globals__".split(
+  "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date".split(
    ","
  );

@@ -268,7 +268,7 @@ export function compileExprToArray(expr: string): Token[] {
  const localVars = new Set<string>();
  const tokens = tokenize(expr);
  let i = 0;
-  let stack = []; // to track last opening (, [ or {
+  let stack = []; // to track last opening [ or {

  while (i < tokens.length) {
    let token = tokens[i];
@@ -279,12 +279,10 @@ export function compileExprToArray(expr: string): Token[] {
    switch (token.type) {
      case "LEFT_BRACE":
      case "LEFT_BRACKET":
-      case "LEFT_PAREN":
        stack.push(token.type);
        break;
      case "RIGHT_BRACE":
      case "RIGHT_BRACKET":
-      case "RIGHT_PAREN":
        stack.pop();
    }

@@ -1,6 +1,4 @@
 import { OwlError } from "../common/owl_error";
-import type { customDirectives } from "../common/types";
-import { parseXML } from "../common/utils";

 // -----------------------------------------------------------------------------
 // AST Type definition
@@ -199,26 +197,23 @@ export type AST =
 // -----------------------------------------------------------------------------
 const cache: WeakMap<Element, AST> = new WeakMap();

-export function parse(xml: string | Element, customDir?: customDirectives): AST {
-  const ctx = {
-    inPreTag: false,
-    customDirectives: customDir,
-  };
+export function parse(xml: string | Element): AST {
  if (typeof xml === "string") {
    const elem = parseXML(`<t>${xml}</t>`).firstChild as Element;
-    return _parse(elem, ctx);
+    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) as Element, ctx);
+    ast = _parse(xml.cloneNode(true) as Element);
    cache.set(xml, ast);
  }
  return ast;
 }

-function _parse(xml: Element, ctx: ParsingContext): AST {
+function _parse(xml: Element): AST {
  normalizeXML(xml);
+  const ctx = { inPreTag: false };
  return parseNode(xml, ctx) || { type: ASTType.Text, value: "" };
 }

@@ -226,7 +221,6 @@ interface ParsingContext {
  tModelInfo?: TModelInfo | null;
  nameSpace?: string;
  inPreTag: boolean;
-  customDirectives?: customDirectives;
 }

 function parseNode(node: Node, ctx: ParsingContext): AST | null {
@@ -234,7 +228,6 @@ function parseNode(node: Node, ctx: ParsingContext): AST | null {
    return parseTextCommentNode(node, ctx);
  }
  return (
-    parseTCustom(node, ctx) ||
    parseTDebugLog(node, ctx) ||
    parseTForEach(node, ctx) ||
    parseTIf(node, ctx) ||
@@ -283,37 +276,6 @@ function parseTextCommentNode(node: Node, ctx: ParsingContext): AST | null {
  return null;
 }

-function parseTCustom(node: Element, ctx: ParsingContext): AST | null {
-  if (!ctx.customDirectives) {
-    return null;
-  }
-  const nodeAttrsNames = node.getAttributeNames();
-  for (let attr of nodeAttrsNames) {
-    if (attr === "t-custom" || attr === "t-custom-") {
-      throw new OwlError("Missing custom directive name with t-custom directive");
-    }
-    if (attr.startsWith("t-custom-")) {
-      const directiveName = attr.split(".")[0].slice(9);
-      const customDirective = ctx.customDirectives[directiveName];
-      if (!customDirective) {
-        throw new OwlError(`Custom directive "${directiveName}" is not defined`);
-      }
-      const value = node.getAttribute(attr)!;
-      const modifiers = attr.split(".").slice(1);
-      node.removeAttribute(attr);
-      try {
-        customDirective(node, value, modifiers);
-      } catch (error) {
-        throw new OwlError(
-          `Custom directive "${directiveName}" throw the following error: ${error}`
-        );
-      }
-      return parseNode(node, ctx);
-    }
-  }
-  return null;
-}
-
 // -----------------------------------------------------------------------------
 // debugging
 // -----------------------------------------------------------------------------
@@ -404,9 +366,9 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
      const isSelect = tagName === "select";
      const isCheckboxInput = isInput && typeAttr === "checkbox";
      const isRadioInput = isInput && typeAttr === "radio";
-      const hasTrimMod = attr.includes(".trim");
-      const hasLazyMod = hasTrimMod || attr.includes(".lazy");
+      const hasLazyMod = attr.includes(".lazy");
      const hasNumberMod = attr.includes(".number");
+      const hasTrimMod = attr.includes(".trim");
      const eventType = isRadioInput ? "click" : isSelect || hasLazyMod ? "change" : "input";

      model = {
@@ -778,14 +740,14 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
      // be ignored)
      let el = slotNode.parentElement!;
      let isInSubComponent = false;
-      while (el && el !== clone) {
+      while (el !== clone) {
        if (el!.hasAttribute("t-component") || el!.tagName[0] === el!.tagName[0].toUpperCase()) {
          isInSubComponent = true;
          break;
        }
        el = el.parentElement!;
      }
-      if (isInSubComponent || !el) {
+      if (isInSubComponent) {
        continue;
      }

@@ -1010,3 +972,40 @@ function normalizeXML(el: Element) {
  normalizeTIf(el);
  normalizeTEscTOut(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: string): XMLDocument {
+  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;
+}
@@ -12,7 +12,5 @@ TemplateSet.prototype._compileTemplate = function _compileTemplate(
    dev: this.dev,
    translateFn: this.translateFn,
    translatableAttributes: this.translatableAttributes,
-    customDirectives: this.customDirectives,
-    hasGlobalValues: this.hasGlobalValues,
  });
 };
@@ -1,6 +1,6 @@
 import { version } from "../version";
 import { Component, ComponentConstructor, Props } from "./component";
-import { ComponentNode, saveCurrent } from "./component_node";
+import { ComponentNode } from "./component_node";
 import { nodeErrorHandlers, handleError } from "./error_handling";
 import { OwlError } from "../common/owl_error";
 import { Fiber, RootFiber, MountOptions } from "./fibers";
@@ -16,13 +16,10 @@ export interface Env {
  [key: string]: any;
 }

-export interface RootConfig<P, E> {
+export interface AppConfig<P, E> extends TemplateSetConfig {
+  name?: string;
  props?: P;
  env?: E;
-}
-
-export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
-  name?: string;
  test?: boolean;
  warnIfNoStaticProps?: boolean;
 }
@@ -52,12 +49,6 @@ declare global {
  }
 }

-interface Root<P extends Props, E> {
-  node: ComponentNode<P, E>;
-  mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
-  destroy(): void;
-}
-
 window.__OWL_DEVTOOLS__ ||= { apps, Fiber, RootFiber, toRaw, reactive };

 export class App<
@@ -74,7 +65,6 @@ export class App<
  props: P;
  env: E;
  scheduler = new Scheduler();
-  subRoots: Set<ComponentNode> = new Set();
  root: ComponentNode<P, E> | null = null;
  warnIfNoStaticProps: boolean;

@@ -101,49 +91,14 @@ export class App<
    target: HTMLElement | ShadowRoot,
    options?: MountOptions
  ): Promise<Component<P, E> & InstanceType<T>> {
-    const root = this.createRoot(this.Root, { props: this.props });
-    this.root = root.node;
-    this.subRoots.delete(root.node);
-    return root.mount(target, options) as any;
-  }
-
-  createRoot<Props extends object, SubEnv = any>(
-    Root: ComponentConstructor<Props, E>,
-    config: RootConfig<Props, SubEnv> = {}
-  ): Root<Props, SubEnv> {
-    const props = config.props || ({} as Props);
-    // hack to make sure the sub root get the sub env if necessary. for owl 3,
-    // would be nice to rethink the initialization process to make sure that
-    // we can create a ComponentNode and give it explicitely the env, instead
-    // of looking it up in the app
-    const env = this.env;
-    if (config.env) {
-      this.env = config.env as any;
+    App.validateTarget(target);
+    if (this.dev) {
+      validateProps(this.Root, this.props, { __owl__: { app: this } });
    }
-
-    const restore = saveCurrent();
-    const node = this.makeNode(Root, props);
-    restore();
-    if (config.env) {
-      this.env = env;
-    }
-    this.subRoots.add(node);
-    return {
-      node,
-      mount: (target: HTMLElement | ShadowRoot, options?: MountOptions) => {
-        App.validateTarget(target);
-        if (this.dev) {
-          validateProps(Root, props, { __owl__: { app: this } });
-        }
-        const prom = this.mountNode(node, target, options);
-        return prom;
-      },
-      destroy: () => {
-        this.subRoots.delete(node);
-        node.destroy();
-        this.scheduler.processTasks();
-      },
-    };
+    const node = this.makeNode(this.Root, this.props);
+    const prom = this.mountNode(node, target, options);
+    this.root = node;
+    return prom;
  }

  makeNode(Component: ComponentConstructor, props: any): ComponentNode {
@@ -179,9 +134,6 @@ export class App<

  destroy() {
    if (this.root) {
-      for (let subroot of this.subRoots) {
-        subroot.destroy();
-      }
      this.root.destroy();
      this.scheduler.processTasks();
    }
@@ -23,7 +23,7 @@ export type ComponentConstructor<P extends Props = any, E = any> = (new (

 export class Component<Props = any, Env = any> {
  static template: string = "";
-  static props?: Schema;
+  static props?: any;
  static defaultProps?: any;

  props: Props;
@@ -10,13 +10,6 @@ import { batched, Callback } from "./utils";

 let currentNode: ComponentNode | null = null;

-export function saveCurrent() {
-  let n = currentNode;
-  return () => {
-    currentNode = n;
-  };
-}
-
 export function getCurrent(): ComponentNode {
  if (!currentNode) {
    throw new OwlError("No active component (a hook function should only be called in 'setup')");
@@ -30,13 +30,6 @@ export function makeRootFiber(node: ComponentNode): Fiber {
      fibersInError.delete(current);
      fibersInError.delete(root);
      current.appliedToDom = false;
-      if (current instanceof RootFiber) {
-        // it is possible that this fiber is a fiber that crashed while being
-        // mounted, so the mounted list is possibly corrupted. We restore it to
-        // its normal initial state (which is empty list or a list with a mount
-        // fiber.
-        current.mounted = current instanceof MountFiber ? [current] : [];
-      }
    }
    return current;
  }
@@ -159,7 +152,6 @@ export class RootFiber extends Fiber {
    const node = this.node;
    this.locked = true;
    let current: Fiber | undefined = undefined;
-    let mountedFibers = this.mounted;
    try {
      // Step 1: calling all willPatch lifecycle hooks
      for (current of this.willPatch) {
@@ -181,6 +173,7 @@ export class RootFiber extends Fiber {
      this.locked = false;

      // Step 4: calling all mounted lifecycle hooks
+      let mountedFibers = this.mounted;
      while ((current = mountedFibers.pop())) {
        current = current;
        if (current.appliedToDom) {
@@ -201,15 +194,6 @@ export class RootFiber extends Fiber {
        }
      }
    } catch (e) {
-      // if mountedFibers is not empty, this means that a crash occured while
-      // calling the mounted hooks of some component. So, there may still be
-      // some component that have been mounted, but for which the mounted hooks
-      // have not been called. Here, we remove the willUnmount hooks for these
-      // specific component to prevent a worse situation (willUnmount being
-      // called even though mounted has not been called)
-      for (let fiber of mountedFibers) {
-        fiber.node.willUnmount = [];
-      }
      this.locked = false;
      node.app.handleError({ fiber: current || this, error: e });
    }
@@ -41,7 +41,7 @@ export { useComponent, useState } from "./component_node";
 export { status } from "./status";
 export { reactive, markRaw, toRaw } from "./reactivity";
 export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
-export { batched, EventBus, whenReady, loadFile, markup } from "./utils";
+export { EventBus, whenReady, loadFile, markup } from "./utils";
 export {
  onWillStart,
  onMounted,
@@ -3,50 +3,42 @@ import { nodeErrorHandlers } from "./error_handling";
 import { OwlError } from "../common/owl_error";

 const TIMEOUT = Symbol("timeout");
-const HOOK_TIMEOUT: { [key: string]: number } = {
-  onWillStart: 3000,
-  onWillUpdateProps: 3000,
-};
 function wrapError(fn: (...args: any[]) => any, hookName: string) {
-  const error = new OwlError() as Error & {
+  const error = new OwlError(`The following error occurred in ${hookName}: `) as Error & {
    cause: any;
  };
-  const timeoutError = new OwlError();
+  const timeoutError = new OwlError(`${hookName}'s promise hasn't resolved after 3 seconds`);
  const node = getCurrent();
  return (...args: any[]) => {
    const onError = (cause: any) => {
      error.cause = cause;
-      error.message =
-        cause instanceof Error
-          ? `The following error occurred in ${hookName}: "${cause.message}"`
-          : `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+      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;
    };
-    let result;
    try {
-      result = fn(...args);
+      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);
    }
-    if (!(result instanceof Promise)) {
-      return result;
-    }
-    const timeout = HOOK_TIMEOUT[hookName];
-    if (timeout) {
-      const fiber = node.fiber;
-      Promise.race([
-        result.catch(() => {}),
-        new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), timeout)),
-      ]).then((res) => {
-        if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
-          timeoutError.message = `${hookName}'s promise hasn't resolved after ${
-            timeout / 1000
-          } seconds`;
-          console.log(timeoutError);
-        }
-      });
-    }
-    return result.catch(onError);
  };
 }

@@ -65,7 +65,7 @@ export class Portal extends Component {
      type: String,
    },
    slots: true,
-  } as const;
+  };

  setup() {
    const node: any = this.__owl__;
@@ -20,9 +20,8 @@ type CollectionRawType = "Set" | "Map" | "WeakMap";
 const objectToString = Object.prototype.toString;
 const objectHasOwnProperty = Object.prototype.hasOwnProperty;

-// Use arrays because Array.includes is faster than Set.has for small arrays
-const SUPPORTED_RAW_TYPES = ["Object", "Array", "Set", "Map", "WeakMap"];
-const COLLECTION_RAW_TYPES = ["Set", "Map", "WeakMap"];
+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
@@ -46,7 +45,7 @@ function canBeMadeReactive(value: any): boolean {
  if (typeof value !== "object") {
    return false;
  }
-  return SUPPORTED_RAW_TYPES.includes(rawType(value));
+  return SUPPORTED_RAW_TYPES.has(rawType(value));
 }
 /**
 * Creates a reactive from the given object/callback if possible and returns it,
@@ -221,7 +220,7 @@ export function reactive<T extends Target>(target: T, callback: Callback = NO_CA
  const reactivesForTarget = reactiveCache.get(target)!;
  if (!reactivesForTarget.has(callback)) {
    const targetRawType = rawType(target);
-    const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
+    const handler = COLLECTION_RAWTYPES.has(targetRawType)
      ? collectionsProxyHandler(target as Collection, callback, targetRawType as CollectionRawType)
      : basicProxyHandler<T>(callback);
    const proxy = new Proxy(target, handler as ProxyHandler<T>) as Reactive<T>;
@@ -16,7 +16,6 @@ export class Scheduler {
  frame: number = 0;
  delayedRenders: Fiber[] = [];
  cancelledNodes: Set<ComponentNode> = new Set();
-  processing = false;

  constructor() {
    this.requestAnimationFrame = Scheduler.requestAnimationFrame;
@@ -54,10 +53,6 @@ export class Scheduler {
  }

  processTasks() {
-    if (this.processing) {
-      return;
-    }
-    this.processing = true;
    this.frame = 0;
    for (let node of this.cancelledNodes) {
      node._destroy();
@@ -71,7 +66,6 @@ export class Scheduler {
        this.tasks.delete(task);
      }
    }
-    this.processing = false;
  }

  processFiber(fiber: RootFiber) {
@@ -93,14 +87,7 @@ export class Scheduler {
      if (!hasError) {
        fiber.complete();
      }
-      // at this point, the fiber should have been applied to the DOM, so we can
-      // remove it from the task list. If it is not the case, it means that there
-      // was an error and an error handler triggered a new rendering that recycled
-      // the fiber, so in that case, we actually want to keep the fiber around,
-      // otherwise it will just be ignored.
-      if (fiber.appliedToDom) {
-        this.tasks.delete(fiber);
-      }
+      this.tasks.delete(fiber);
    }
  }
 }
@@ -4,19 +4,44 @@ import { getCurrent } from "./component_node";
 import { Portal, portalTemplate } from "./portal";
 import { helpers } from "./template_helpers";
 import { OwlError } from "../common/owl_error";
-import { parseXML } from "../common/utils";
-import type { customDirectives } from "../common/types";

 const bdom = { text, createBlock, list, multi, html, toggler, comment };

+function parseXML(xml: string): Document {
+  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;
+}
+
 export interface TemplateSetConfig {
  dev?: boolean;
  translatableAttributes?: string[];
  translateFn?: (s: string) => string;
-  templates?: string | Document | Record<string, string>;
-  getTemplate?: (s: string) => Element | Function | string | void;
-  customDirectives?: customDirectives;
-  globalValues?: object;
+  templates?: string | Document;
 }

 export class TemplateSet {
@@ -26,31 +51,17 @@ export class TemplateSet {
  dev: boolean;
  rawTemplates: typeof globalTemplates = Object.create(globalTemplates);
  templates: { [name: string]: Template } = {};
-  getRawTemplate?: (s: string) => Element | Function | string | void;
  translateFn?: (s: string) => string;
  translatableAttributes?: string[];
  Portal = Portal;
-  customDirectives: customDirectives;
-  runtimeUtils: object;
-  hasGlobalValues: boolean;

  constructor(config: TemplateSetConfig = {}) {
    this.dev = config.dev || false;
    this.translateFn = config.translateFn;
    this.translatableAttributes = config.translatableAttributes;
    if (config.templates) {
-      if (config.templates instanceof Document || typeof config.templates === "string") {
-        this.addTemplates(config.templates);
-      } else {
-        for (const name in config.templates) {
-          this.addTemplate(name, config.templates[name]);
-        }
-      }
+      this.addTemplates(config.templates);
    }
-    this.getRawTemplate = config.getTemplate;
-    this.customDirectives = config.customDirectives || {};
-    this.runtimeUtils = { ...helpers, __globals__: config.globalValues || {} };
-    this.hasGlobalValues = Boolean(config.globalValues && Object.keys(config.globalValues).length);
  }

  addTemplate(name: string, template: string | Element) {
@@ -89,7 +100,7 @@ export class TemplateSet {

  getTemplate(name: string): Template {
    if (!(name in this.templates)) {
-      const rawTemplate = this.getRawTemplate?.(name) || this.rawTemplates[name];
+      const rawTemplate = this.rawTemplates[name];
      if (rawTemplate === undefined) {
        let extraInfo = "";
        try {
@@ -106,7 +117,7 @@ export class TemplateSet {
      this.templates[name] = function (context, parent) {
        return templates[name].call(this, context, parent);
      };
-      const template = templateFn(this, bdom, this.runtimeUtils);
+      const template = templateFn(this, bdom, helpers);
      this.templates[name] = template;
    }
    return this.templates[name];
@@ -1,7 +1,15 @@
 import { OwlError } from "../common/owl_error";
 import { toRaw } from "./reactivity";

-type BaseType = { new (...args: any[]): any } | true | "*";
+type BaseType =
+  | typeof String
+  | typeof Boolean
+  | typeof Number
+  | typeof Date
+  | typeof Object
+  | typeof Array
+  | true
+  | "*";

 interface TypeInfo {
  type?: TypeDescription;
@@ -1,2 +1,2 @@
 // do not modify manually. This file is generated by the release script.
-export const version = "2.5.2";
+export const version = "2.2.6";
@@ -43,48 +43,6 @@ exports[`app app: clear scheduler tasks and destroy cancelled nodes immediately
 }"
 `;

-exports[`app can add functions to the bdom 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { __globals__ } = helpers;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [()=>__globals__.plop('click'), ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
-
-exports[`app can call processTask twice in a row without crashing 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`parent\`);
-    const b3 = comp1({}, key + \`__1\`, node, this, null);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`app can call processTask twice in a row without crashing 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`app can configure an app with props 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -99,19 +57,6 @@ exports[`app can configure an app with props 1`] = `
 }"
 `;

-exports[`app can load templates from an object name-string 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div class=\\"hello\\">hello</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`app can mount app in an iframe 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1,210 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`destroy a subroot while another component is mounted in main app 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`ChildB\`, true, false, false, []);
-  const comp2 = app.createComponent(\`ChildA\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2, b3;
-    if (ctx['state'].flag) {
-      b2 = comp1({}, key + \`__1\`, node, this, null);
-    } else {
-      b3 = comp2({}, key + \`__2\`, node, this, null);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block3 = createBlock(\`<div block-ref=\\"0\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`a\`);
-    let ref1 = (el) => this.__owl__.setRef((\`elem\`), el);
-    const b3 = block3([ref1]);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`c\`);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`b\`);
-  }
-}"
-`;
-
-exports[`subroot by default, env is the same in sub root 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot by default, env is the same in sub root 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can create a root in a setup function, then use a hook 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`a\`);
-  }
-}"
-`;
-
-exports[`subroot can create a root in a setup function, then use a hook 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`c\`);
-  }
-}"
-`;
-
-exports[`subroot can mount subroot 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot inside own dom 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot inside own dom 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot env can be specified for sub roots 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot env can be specified for sub roots 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot subcomponents can be destroyed, and it properly cleanup the subroots 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot subcomponents can be destroyed, and it properly cleanup the subroots 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
@@ -1,4 +1,4 @@
-import { App, Component, mount, onWillPatch, onWillStart, useState, xml } from "../../src";
+import { App, Component, mount, onWillStart, useState, xml } from "../../src";
 import { status } from "../../src/runtime/status";
 import {
  makeTestFixture,
@@ -167,56 +167,4 @@ describe("app", () => {
      ]
    `);
  });
-
-  test("can load templates from an object name-string", async () => {
-    const templates = {
-      hello: `<div class="hello">hello</div>`,
-      world: `<div>world</div>`,
-    };
-    class SomeComponent extends Component {
-      static template = "hello";
-    }
-
-    const app = new App(SomeComponent, { templates });
-    await app.mount(fixture);
-    expect(fixture.querySelector(".hello")).toBeDefined();
-    // Only the "hello" template is used, so the "world" template is not yet loaded
-    expect(Object.keys(app.templates)).toEqual(["hello"]);
-    expect(Object.keys(app.rawTemplates)).toEqual(["hello", "world"]);
-  });
-
-  test("can call processTask twice in a row without crashing", async () => {
-    class Child extends Component {
-      static template = xml`<div/>`;
-      setup() {
-        onWillPatch(() => app.scheduler.processTasks());
-      }
-    }
-    class SomeComponent extends Component {
-      static template = xml`parent<Child/>`;
-      static components = { Child };
-    }
-
-    const app = new App(SomeComponent);
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("parent<div></div>");
-  });
-
-  test("can add functions to the bdom", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-on-click="() => __globals__.plop('click')" class="my-div"/>`;
-    }
-    const app = new App(SomeComponent, {
-      globalValues: {
-        plop: (string: any) => {
-          steps.push(string);
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["click"]);
-  });
 });
@@ -1,176 +0,0 @@
-import { App, Component, onMounted, onWillDestroy, useRef, useState, xml } from "../../src";
-import { status } from "../../src/runtime/status";
-import { makeTestFixture, nextTick, snapshotEverything } from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-class SomeComponent extends Component {
-  static template = xml`<div>main app</div>`;
-}
-
-class SubComponent extends Component {
-  static template = xml`<div>sub root</div>`;
-}
-
-describe("subroot", () => {
-  test("can mount subroot", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const subRoot = app.createRoot(SubComponent);
-    const subcomp = await subRoot.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div><div>sub root</div>");
-
-    app.destroy();
-    expect(fixture.innerHTML).toBe("");
-    expect(status(comp)).toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("can mount subroot inside own dom", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const subRoot = app.createRoot(SubComponent);
-    const subcomp = await subRoot.mount(fixture.querySelector("div")!);
-    expect(fixture.innerHTML).toBe("<div>main app<div>sub root</div></div>");
-
-    app.destroy();
-    expect(fixture.innerHTML).toBe("");
-    expect(status(comp)).toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("by default, env is the same in sub root", async () => {
-    let env, subenv;
-    class SC extends SomeComponent {
-      setup() {
-        env = this.env;
-      }
-    }
-    class Sub extends SubComponent {
-      setup() {
-        subenv = this.env;
-      }
-    }
-
-    const app = new App(SC);
-    await app.mount(fixture);
-    const subRoot = app.createRoot(Sub);
-    await subRoot.mount(fixture);
-
-    expect(env).toBeDefined();
-    expect(subenv).toBeDefined();
-    expect(env).toBe(subenv);
-  });
-
-  test("env can be specified for sub roots", async () => {
-    const env1 = { env1: true };
-    const env2 = {};
-    let someComponentEnv: any, subComponentEnv: any;
-    class SC extends SomeComponent {
-      setup() {
-        someComponentEnv = this.env;
-      }
-    }
-    class Sub extends SubComponent {
-      setup() {
-        subComponentEnv = this.env;
-      }
-    }
-
-    const app = new App(SC, { env: env1 });
-    await app.mount(fixture);
-    const subRoot = app.createRoot(Sub, { env: env2 });
-    await subRoot.mount(fixture);
-
-    // because env is different in app => it is given a sub object, frozen and all
-    // not sure it is a good idea, but it's the way owl 2 works. maybe we should
-    // avoid doing anything with the main env and let user code do it if they
-    // want. in that case, we can change the test here to assert that they are equal
-    expect(someComponentEnv).not.toBe(env1);
-    expect(someComponentEnv!.env1).toBe(true);
-    expect(subComponentEnv).toBe(env2);
-  });
-
-  test("subcomponents can be destroyed, and it properly cleanup the subroots", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const root = app.createRoot(SubComponent);
-    const subcomp = await root.mount(fixture.querySelector("div")!);
-    expect(fixture.innerHTML).toBe("<div>main app<div>sub root</div></div>");
-
-    root.destroy();
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    expect(status(comp)).not.toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("can create a root in a setup function, then use a hook", async () => {
-    class C extends Component {
-      static template = xml`c`;
-    }
-
-    class A extends Component {
-      static template = xml`a`;
-      state: any;
-      setup() {
-        app.createRoot(C);
-        this.state = useState({ value: 1 });
-      }
-    }
-
-    const app = new App(A);
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("a");
-  });
-});
-
-test("destroy a subroot while another component is mounted in main app", async () => {
-  class C extends Component {
-    static template = xml`c`;
-  }
-
-  class ChildA extends Component {
-    static template = xml`a<div t-ref="elem"></div>`;
-    ref: any;
-    setup() {
-      this.ref = useRef("elem");
-      let root = app.createRoot(C);
-      onMounted(() => {
-        root.mount(this.ref.el);
-      });
-      onWillDestroy(() => {
-        root.destroy();
-      });
-    }
-  }
-  class ChildB extends Component {
-    static template = xml`b`;
-  }
-
-  class SomeComponent extends Component {
-    static template = xml`
-        <t t-if="state.flag"><ChildB/></t>
-        <t t-else=""><ChildA/></t>
-        `;
-    static components = { ChildA, ChildB };
-    state = useState({ flag: false });
-  }
-
-  const app = new App(SomeComponent);
-  const comp = await app.mount(fixture);
-  expect(fixture.innerHTML).toBe("a<div></div>");
-  await nextTick();
-  expect(fixture.innerHTML).toBe("a<div>c</div>");
-  comp.state.flag = true;
-  await nextTick();
-  expect(fixture.innerHTML).toBe("b");
-});
@@ -1,38 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`comments comment node with backslash at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return comment(\` \\\\\\\\ \`);
-  }
-}"
-`;
-
-exports[`comments comment node with backtick at top-level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return comment(\` \\\\\` \`);
-  }
-}"
-`;
-
-exports[`comments comment node with interpolation sigil at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return comment(\` \\\\\${very cool} \`);
-  }
-}"
-`;
-
 exports[`comments only a comment 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -341,39 +341,6 @@ exports[`simple templates, mostly static template with t tag with multiple conte
 }"
 `;

-exports[`simple templates, mostly static text node with backslash at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`\\\\\\\\\`);
-  }
-}"
-`;
-
-exports[`simple templates, mostly static text node with backtick at top-level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`\\\\\`\`);
-  }
-}"
-`;
-
-exports[`simple templates, mostly static text node with interpolation sigil at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`\\\\\${very cool}\`);
-  }
-}"
-`;
-
 exports[`simple templates, mostly static two t-escs next to each other 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1,29 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`t-custom can use t-custom directive on a node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['click'], ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
-
-exports[`t-custom can use t-custom directive with modifiers on a node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['click'], ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
@@ -1,41 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`t-esc default with backslash at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { withDefault } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(withDefault(undefined, \`\\\\\\\\\`));
-  }
-}"
-`;
-
-exports[`t-esc default with backtick at top-level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { withDefault } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(withDefault(undefined, \`\\\\\`\`));
-  }
-}"
-`;
-
-exports[`t-esc default with interpolation sigil at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { withDefault } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(withDefault(undefined, \`\\\\\${very cool}\`));
-  }
-}"
-`;
-
 exports[`t-esc div with falsy values 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1,50 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`t-set body with backslash at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1
-    setContextValue(ctx, \\"value\\", \`\\\\\\\\\`);
-    return text(ctx['value']);
-  }
-}"
-`;
-
-exports[`t-set body with backtick at top-level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1
-    setContextValue(ctx, \\"value\\", \`\\\\\`\`);
-    return text(ctx['value']);
-  }
-}"
-`;
-
-exports[`t-set body with interpolation sigil at top level 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1
-    setContextValue(ctx, \\"value\\", \`\\\\\${very cool}\`);
-    return text(ctx['value']);
-  }
-}"
-`;
-
 exports[`t-set evaluate value expression 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -101,55 +101,3 @@ exports[`loading templates can load a few templates from an XMLDocument 2`] = `
  }
 }"
 `;
-
-exports[`loading templates getTemplate: element returned (2) 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Hello World!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`loading templates getTemplate: element returned 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Hello World!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`loading templates getTemplate: template string returned 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Hello World!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`loading templates getTemplate: undefined returned 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Hello World!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
@@ -26,19 +26,4 @@ describe("comments", () => {
        </div>`;
    expect(renderToString(template)).toBe("<div><span>true</span></div>");
  });
-
-  test("comment node with backslash at top level", () => {
-    const template = "<!-- \\ -->";
-    expect(renderToString(template)).toBe("<!-- \\ -->");
-  });
-
-  test("comment node with backtick at top-level", () => {
-    const template = "<!-- ` -->";
-    expect(renderToString(template)).toBe("<!-- ` -->");
-  });
-
-  test("comment node with interpolation sigil at top level", () => {
-    const template = "<!-- ${very cool} -->";
-    expect(renderToString(template)).toBe("<!-- ${very cool} -->");
-  });
 });
@@ -174,9 +174,6 @@ describe("expression evaluation", () => {
    expect(compileExpr("list.data.map((data) => data)")).toBe(
      "ctx['list'].data.map((_data)=>_data)"
    );
-    expect(compileExpr("(ev) => { myFunc(v1, v2, ev.target.value); }")).toBe(
-      "(_ev)=>{ctx['myFunc'](ctx['v1'],ctx['v2'],_ev.target.value);}"
-    );
  });
  test.skip("arrow functions: not yet supported", () => {
    // e is added to localvars in inline_expression but not removed after the arrow func body
@@ -154,19 +154,4 @@ describe("simple templates, mostly static", () => {
      </div>`;
    expect(renderToString(template, { a: "a", b: "b", c: "c" })).toBe("<div>abLoadingc</div>");
  });
-
-  test("text node with backslash at top level", () => {
-    const template = "\\";
-    expect(renderToString(template)).toBe("\\");
-  });
-
-  test("text node with backtick at top-level", () => {
-    const template = "`";
-    expect(renderToString(template)).toBe("`");
-  });
-
-  test("text node with interpolation sigil at top level", () => {
-    const template = "${very cool}";
-    expect(renderToString(template)).toBe("${very cool}");
-  });
 });
@@ -1,57 +0,0 @@
-import { App, Component, xml } from "../../src";
-import { makeTestFixture, snapshotEverything } from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-describe("t-custom", () => {
-  test("can use t-custom directive on a node", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-custom-plop="click" class="my-div"/>`;
-      click() {
-        steps.push("clicked");
-      }
-    }
-    const app = new App(SomeComponent, {
-      customDirectives: {
-        plop: (node, value) => {
-          node.setAttribute("t-on-click", value);
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["clicked"]);
-  });
-
-  test("can use t-custom directive with modifiers on a node", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-custom-plop.mouse.stop="click" class="my-div"/>`;
-      click() {
-        steps.push("clicked");
-      }
-    }
-    const app = new App(SomeComponent, {
-      customDirectives: {
-        plop: (node, value, modifiers) => {
-          node.setAttribute("t-on-click", value);
-          for (let mod of modifiers) {
-            steps.push(mod);
-          }
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["mouse", "stop", "clicked"]);
-  });
-});
@@ -121,19 +121,4 @@ describe("t-esc", () => {
    mount(bdom, fixture);
    expect(fixture.querySelector("span")!.textContent).toBe("<p>escaped</p>");
  });
-
-  test("default with backslash at top level", () => {
-    const template = '<t t-esc="undefined">\\</t>';
-    expect(renderToString(template)).toBe("\\");
-  });
-
-  test("default with backtick at top-level", () => {
-    const template = '<t t-esc="undefined">`</t>';
-    expect(renderToString(template)).toBe("`");
-  });
-
-  test("default with interpolation sigil at top level", () => {
-    const template = '<t t-esc="undefined">${very cool}</t>';
-    expect(renderToString(template)).toBe("${very cool}");
-  });
 });
@@ -54,21 +54,6 @@ describe("t-set", () => {
    expect(renderToString(template)).toBe("ok");
  });

-  test("body with backslash at top level", () => {
-    const template = '<t t-set="value">\\</t><t t-esc="value"/>';
-    expect(renderToString(template)).toBe("\\");
-  });
-
-  test("body with backtick at top-level", () => {
-    const template = '<t t-set="value">`</t><t t-esc="value"/>';
-    expect(renderToString(template)).toBe("`");
-  });
-
-  test("body with interpolation sigil at top level", () => {
-    const template = '<t t-set="value">${very cool}</t><t t-esc="value"/>';
-    expect(renderToString(template)).toBe("${very cool}");
-  });
-
  test("set from body literal (with t-if/t-else", () => {
    const template = `
      <t>
@@ -78,62 +78,4 @@ describe("loading templates", () => {
    context.addTemplates(xml);
    expect(Object.keys(context.rawTemplates)).toEqual([]);
  });
-
-  test("getTemplate: element returned", () => {
-    const context = new TestContext({
-      getTemplate: (name) => {
-        if (name === "main") {
-          const data = `<div>Hello World!</div>`;
-          const xml = new DOMParser().parseFromString(data, "text/xml");
-          return xml.firstChild as Element;
-        }
-        return;
-      },
-    });
-    const result = context.renderToString("main");
-    expect(result).toBe("<div>Hello World!</div>");
-  });
-
-  test("getTemplate: element returned (2)", () => {
-    const context = new TestContext({
-      getTemplate: (name) => {
-        if (name === "main") {
-          const doc = new Document();
-          const div = doc.createElement("div");
-          div.append(doc.createTextNode("Hello World!"));
-          return div;
-        }
-        return;
-      },
-    });
-    const result = context.renderToString("main");
-    expect(result).toBe("<div>Hello World!</div>");
-  });
-
-  test("getTemplate: template string returned", () => {
-    const context = new TestContext({
-      getTemplate: (name) => {
-        if (name === "main") {
-          return `<div>Hello World!</div>`;
-        }
-        return;
-      },
-    });
-    const result = context.renderToString("main");
-    expect(result).toBe("<div>Hello World!</div>");
-  });
-
-  test("getTemplate: undefined returned", () => {
-    const context = new TestContext({
-      getTemplate: () => {},
-    });
-    const data = `<?xml version="1.0" encoding="UTF-8"?>
-    <templates id="template" xml:space="preserve">
-      <div t-name="main">Hello World!</div>
-    </templates>`;
-    const xml = new DOMParser().parseFromString(data, "text/xml");
-    context.addTemplates(xml);
-    const result = context.renderToString("main");
-    expect(result).toBe("<div>Hello World!</div>");
-  });
 });
@@ -48,7 +48,7 @@ describe("basic validation", () => {
  test("compilation error", () => {
    const template = `<div t-att-class="a b">test</div>`;
    expect(() => renderToString(template))
-      .toThrow(`Failed to compile anonymous template: Unexpected identifier 'ctx'
+      .toThrow(`Failed to compile anonymous template: Unexpected identifier

 generated code:
 function(app, bdom, helpers) {
@@ -97,19 +97,6 @@ exports[`basics a component cannot be mounted in a detached node (even if node i
 }"
 `;

-exports[`basics a component cannot be mounted in a detached node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics a component inside a component 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -274,19 +261,6 @@ exports[`basics can mount a simple component with props 1`] = `
 }"
 `;

-exports[`basics cannot mount on a documentFragment 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>content</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics child can be updated 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1028,19 +1002,6 @@ exports[`basics three level of components with collapsing root nodes 3`] = `
 }"
 `;

-exports[`basics throws if mounting on target=null 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<span>simple vnode</span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics two child components 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -320,50 +320,6 @@ exports[`can catch errors can catch an error in a component render function 3`]
 }"
 `;

-exports[`can catch errors can catch an error in onmounted 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(null, false, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2, b3;
-    b2 = text(\`Main\`);
-    if (ctx['state'].ok) {
-      const Comp1 = ctx['component'];
-      b3 = toggler(Comp1, comp1({}, (Comp1).name + key + \`__1\`, node, this, Comp1));
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`can catch errors can catch an error in onmounted 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Error!!!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`can catch errors can catch an error in onmounted 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>perfect</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`can catch errors can catch an error in the constructor call of a component render function 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1191,135 +1147,6 @@ exports[`can catch errors error in mounted on a component with a sibling (proper
 }"
 `;

-exports[`can catch errors error in onMounted, graceful recovery 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(null, false, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['component'];
-    return toggler(Comp1, comp1({}, (Comp1).name + key + \`__1\`, node, this, Comp1));
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  const comp2 = app.createComponent(\`Boom\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`parent\`);
-    const b3 = comp1({}, key + \`__1\`, node, this, null);
-    const b4 = comp2({}, key + \`__2\`, node, this, null);
-    return multi([b2, b3, b4]);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`abc\`);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`boom\`);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery 5`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`def\`);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery, variation 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(null, false, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2, b3;
-    b2 = text(\`R\`);
-    if (ctx['state'].gogogo) {
-      const Comp1 = ctx['component'];
-      b3 = toggler(Comp1, comp1({}, (Comp1).name + key + \`__1\`, node, this, Comp1));
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery, variation 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  const comp2 = app.createComponent(\`Boom\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`parent\`);
-    const b3 = comp1({}, key + \`__1\`, node, this, null);
-    const b4 = comp2({}, key + \`__2\`, node, this, null);
-    return multi([b2, b3, b4]);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery, variation 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`abc\`);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery, variation 5`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`boom\`);
-  }
-}"
-`;
-
-exports[`can catch errors error in onMounted, graceful recovery, variation 6`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`def\`);
-  }
-}"
-`;
-
 exports[`can catch errors onError in class inheritance is called if rethrown 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -683,7 +683,7 @@ exports[`lifecycle hooks sub widget (inside sub node): hooks are correctly calle
 }"
 `;

-exports[`lifecycle hooks timeout in onWillStart doesn't emit a console log if app is destroyed 1`] = `
+exports[`lifecycle hooks timeout in onWillStart emits a warning 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -696,20 +696,7 @@ exports[`lifecycle hooks timeout in onWillStart doesn't emit a console log if ap
 }"
 `;

-exports[`lifecycle hooks timeout in onWillStart emits a console log 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<span/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 1`] = `
+exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -723,7 +710,7 @@ exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 1`] =
 }"
 `;

-exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 2`] = `
+exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 2`] = `
 "function anonymous(app, bdom, helpers
 ) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -66,29 +66,6 @@ exports[`.alike suffix in a simple case 2`] = `
 }"
 `;

-exports[`.translate props are translated 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return comp1({message: \`translated message\`}, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`.translate props are translated 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].message);
-  }
-}"
-`;
-
 exports[`basics accept ES6-like syntax for props (with getters) 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -435,29 +412,6 @@ exports[`can bind function prop with bind suffix 2`] = `
 }"
 `;

-exports[`can use .translate suffix 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return comp1({message: \`some message\`}, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`can use .translate suffix 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].message);
-  }
-}"
-`;
-
 exports[`do not crash when binding anonymous function prop with bind suffix 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -167,45 +167,6 @@ exports[`props validation can specify that additional props are allowed (object)
 }"
 `;

-exports[`props validation can use custom class as type 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, [\\"customObj\\"]);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const props1 = {customObj: ctx['customObj']};
-    helpers.validateProps(\`Child\`, props1, this);
-    return comp1(props1, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`props validation can use custom class as type 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].customObj.val);
-  }
-}"
-`;
-
-exports[`props validation can use custom class as type: validation failure 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, [\\"customObj\\"]);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const props1 = {customObj: ctx['customObj']};
-    helpers.validateProps(\`Child\`, props1, this);
-    return comp1(props1, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
 exports[`props validation can validate a prop with multiple types 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -924,20 +885,6 @@ exports[`props validation props: list of strings 1`] = `
 }"
 `;

-exports[`props validation validate props for root component 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-text-0/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['message'];
-    return block1([txt1]);
-  }
-}"
-`;
-
 exports[`props validation validate simple types 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1,30 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`slots .translate slot props are translated 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { capture, markRaw } = helpers;
-  const comp1 = app.createComponent(\`Child\`, true, true, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const ctx1 = capture(ctx);
-    return comp1({slots: markRaw({'default': {message: \`translated message\`}})}, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`slots .translate slot props are translated 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].slots.default.message);
-  }
-}"
-`;
-
 exports[`slots can define a default content 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -226,31 +201,6 @@ exports[`slots can render only empty slot 1`] = `
 }"
 `;

-exports[`slots can use .translate suffix on slot props 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { capture, markRaw } = helpers;
-  const comp1 = app.createComponent(\`Child\`, true, true, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const ctx1 = capture(ctx);
-    return comp1({slots: markRaw({'default': {message: \`some message\`}})}, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`slots can use .translate suffix on slot props 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].slots.default.message);
-  }
-}"
-`;
-
 exports[`slots can use component in default-content of t-slot 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1116,45 +1066,6 @@ exports[`slots multiple slots containing components 3`] = `
 }"
 `;

-exports[`slots named slot inside named slot in t-component 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { capture, markRaw } = helpers;
-  const comp1 = app.createComponent(null, false, true, false, []);
-  const comp2 = app.createComponent(\`Child\`, true, true, false, []);
-  
-  function slot1(ctx, node, key = \\"\\") {
-    const b2 = text(\` outer \`);
-    const ctx2 = capture(ctx);
-    const Comp1 = ctx['Child'];
-    const b4 = toggler(Comp1, comp1({slots: markRaw({'brol': {__render: slot2.bind(this), __ctx: ctx2}})}, (Comp1).name + key + \`__1\`, node, this, Comp1));
-    return multi([b2, b4]);
-  }
-  
-  function slot2(ctx, node, key = \\"\\") {
-    return text(ctx['value']);
-  }
-  
-  return function template(ctx, node, key = \\"\\") {
-    const ctx1 = capture(ctx);
-    return comp2({slots: markRaw({'brol': {__render: slot1.bind(this), __ctx: ctx1}})}, key + \`__2\`, node, this, null);
-  }
-}"
-`;
-
-exports[`slots named slot inside named slot in t-component 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { callSlot } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'brol', false, {});
-  }
-}"
-`;
-
 exports[`slots named slot inside slot 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -44,26 +44,7 @@ exports[`t-model directive .trim modifier 1`] = `
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
-  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"change\\"/><span><block-text-2/></span></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const bExpr1 = ctx['state'];
-    const expr1 = 'text';
-    let prop1 = bExpr1[expr1];
-    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value.trim(); }];
-    let txt1 = ctx['state'].text;
-    return block1([prop1, hdlr1, txt1]);
-  }
-}"
-`;
-
-exports[`t-model directive .trim modifier implies .lazy modifier 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { toNumber } = helpers;
-  
-  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"change\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
@@ -157,7 +157,7 @@ describe("basics", () => {
    } catch (e) {
      error = e as Error;
    }
-    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier 'ctx'
+    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier

 generated code:
 function(app, bdom, helpers) {
@@ -182,7 +182,7 @@ function(app, bdom, helpers) {
      static components = { Child };
      static template = xml`<Child/>`;
    }
-    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier 'ctx'
+    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier

 generated code:
 function(app, bdom, helpers) {
@@ -564,82 +564,6 @@ describe("can catch errors", () => {
    expect(mockConsoleWarn).toBeCalledTimes(0);
  });

-  test("can catch an error in onmounted", async () => {
-    class ErrorComponent extends Component {
-      static template = xml`<div>Error!!!</div>`;
-      setup() {
-        useLogLifecycle();
-        onMounted(() => {
-          throw new Error("error");
-        });
-      }
-    }
-    class PerfectComponent extends Component {
-      static template = xml`<div>perfect</div>`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-    class Main extends Component {
-      static template = xml`Main<t t-if="state.ok" t-component="component"/>`;
-      component: any;
-      state: any;
-      setup() {
-        this.state = useState({ ok: false });
-        useLogLifecycle();
-        this.component = ErrorComponent;
-        onError(() => {
-          this.component = PerfectComponent;
-          this.render();
-        });
-      }
-    }
-
-    const app = await mount(Main, fixture);
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Main:setup",
-        "Main:willStart",
-        "Main:willRender",
-        "Main:rendered",
-        "Main:mounted",
-      ]
-    `);
-    expect(fixture.innerHTML).toBe("Main");
-    (app as any).state.ok = true;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("Main<div>Error!!!</div>");
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Main:willRender",
-        "ErrorComponent:setup",
-        "ErrorComponent:willStart",
-        "Main:rendered",
-        "ErrorComponent:willRender",
-        "ErrorComponent:rendered",
-        "Main:willPatch",
-        "ErrorComponent:mounted",
-        "Main:willRender",
-        "PerfectComponent:setup",
-        "PerfectComponent:willStart",
-        "Main:rendered",
-      ]
-    `);
-    await nextTick();
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "PerfectComponent:willRender",
-        "PerfectComponent:rendered",
-        "Main:willPatch",
-        "ErrorComponent:willUnmount",
-        "ErrorComponent:willDestroy",
-        "PerfectComponent:mounted",
-        "Main:patched",
-      ]
-    `);
-    expect(fixture.innerHTML).toBe("Main<div>perfect</div>");
-  });
-
  test("calling a hook outside setup should crash", async () => {
    class Root extends Component {
      static template = xml`<t t-esc="state.value"/>`;
@@ -1678,198 +1602,4 @@ describe("can catch errors", () => {
    `);
    expect(fixture.innerHTML).toBe("2");
  });
-
-  test("error in onMounted, graceful recovery", async () => {
-    class Child extends Component {
-      static template = xml`abc`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class OtherChild extends Component {
-      static template = xml`def`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Boom extends Component {
-      static template = xml`boom`;
-      setup() {
-        useLogLifecycle();
-        onMounted(() => {
-          throw new Error("boom");
-        });
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`parent<Child/><Boom/>`;
-      static components = { Child, Boom };
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Root extends Component {
-      static template = xml`<t t-component="component"/>`;
-
-      component: any = Parent;
-      setup() {
-        useLogLifecycle();
-        onError(() => {
-          logStep("error");
-          this.component = OtherChild;
-          this.render();
-        });
-      }
-    }
-
-    await mount(Root, fixture);
-    expect(fixture.innerHTML).toBe("def");
-
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Root:setup",
-        "Root:willStart",
-        "Root:willRender",
-        "Parent:setup",
-        "Parent:willStart",
-        "Root:rendered",
-        "Parent:willRender",
-        "Child:setup",
-        "Child:willStart",
-        "Boom:setup",
-        "Boom:willStart",
-        "Parent:rendered",
-        "Child:willRender",
-        "Child:rendered",
-        "Boom:willRender",
-        "Boom:rendered",
-        "Boom:mounted",
-        "error",
-        "Root:willRender",
-        "OtherChild:setup",
-        "OtherChild:willStart",
-        "Root:rendered",
-        "OtherChild:willRender",
-        "OtherChild:rendered",
-        "OtherChild:mounted",
-        "Root:mounted",
-      ]
-    `);
-  });
-
-  test("error in onMounted, graceful recovery, variation", async () => {
-    class Child extends Component {
-      static template = xml`abc`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class OtherChild extends Component {
-      static template = xml`def`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Boom extends Component {
-      static template = xml`boom`;
-      setup() {
-        useLogLifecycle();
-        onMounted(() => {
-          throw new Error("boom");
-        });
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`parent<Child/><Boom/>`;
-      static components = { Child, Boom };
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Root extends Component {
-      static template = xml`R<t t-if="state.gogogo" t-component="component"/>`;
-
-      component: any = Parent;
-      state = useState({ gogogo: false });
-
-      setup() {
-        useLogLifecycle();
-        onError(() => {
-          logStep("error");
-          this.component = OtherChild;
-          this.render();
-        });
-      }
-    }
-
-    const root = await mount(Root, fixture);
-    expect(fixture.innerHTML).toBe("R");
-
-    // standard mounting process
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Root:setup",
-        "Root:willStart",
-        "Root:willRender",
-        "Root:rendered",
-        "Root:mounted",
-      ]
-    `);
-
-    root.state.gogogo = true;
-    await nextTick();
-
-    expect(fixture.innerHTML).toBe("Rparentabcboom");
-    // rerender, root creates sub components, it crashes, tries to recover
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Root:willRender",
-        "Parent:setup",
-        "Parent:willStart",
-        "Root:rendered",
-        "Parent:willRender",
-        "Child:setup",
-        "Child:willStart",
-        "Boom:setup",
-        "Boom:willStart",
-        "Parent:rendered",
-        "Child:willRender",
-        "Child:rendered",
-        "Boom:willRender",
-        "Boom:rendered",
-        "Root:willPatch",
-        "Boom:mounted",
-        "error",
-        "Root:willRender",
-        "OtherChild:setup",
-        "OtherChild:willStart",
-        "Root:rendered",
-      ]
-    `);
-
-    await nextTick();
-    expect(fixture.innerHTML).toBe("Rdef");
-
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "OtherChild:willRender",
-        "OtherChild:rendered",
-        "Root:willPatch",
-        "Child:willDestroy",
-        "Boom:willUnmount",
-        "Boom:willDestroy",
-        "Parent:willDestroy",
-        "OtherChild:mounted",
-        "Root:patched",
-      ]
-    `);
-  });
 });
@@ -1,9 +1,5 @@
+import { App, Component, mount, onMounted, onWillStart, useState, xml } from "../../src";
 import {
-  App,
-  Component,
-  mount,
-  useState,
-  xml,
  onWillPatch,
  onWillUnmount,
  onPatched,
@@ -11,9 +7,7 @@ import {
  onWillRender,
  onWillDestroy,
  onRendered,
-  onMounted,
-  onWillStart,
-} from "../../src";
+} from "../../src/runtime/lifecycle_hooks";
 import { status } from "../../src/runtime/status";
 import {
  elem,
@@ -112,10 +106,10 @@ describe("lifecycle hooks", () => {
    await mount(Test, fixture);
  });

-  test("timeout in onWillStart emits a console log", async () => {
-    const { log } = console;
-    let logArgs: any[];
-    console.log = jest.fn((...args) => (logArgs = args));
+  test("timeout in onWillStart emits a warning", async () => {
+    const { warn } = console;
+    let warnArgs: any[];
+    console.warn = jest.fn((...args) => (warnArgs = args));
    const { setTimeout } = window;
    let timeoutCbs: any = {};
    let timeoutId = 0;
@@ -123,63 +117,27 @@ describe("lifecycle hooks", () => {
      timeoutCbs[++timeoutId] = cb;
      return timeoutId;
    }) as any;
-    try {
-      class Test extends Component {
-        static template = xml`<span/>`;
-        setup() {
-          onWillStart(() => new Promise(() => {}));
-        }
+    class Test extends Component {
+      static template = xml`<span/>`;
+      setup() {
+        onWillStart(() => new Promise(() => {}));
      }
-      mount(Test, fixture, { test: true });
-      nextTick();
-      for (const id in timeoutCbs) {
-        timeoutCbs[id]();
-        delete timeoutCbs[id];
-      }
-      await nextMicroTick();
-      await nextMicroTick();
-      expect(console.log).toHaveBeenCalledTimes(1);
-      expect(logArgs![0]!.message).toBe("onWillStart's promise hasn't resolved after 3 seconds");
-    } finally {
-      console.log = log;
-      window.setTimeout = setTimeout;
    }
+    mount(Test, fixture, { test: true });
+    nextTick();
+    for (const id in timeoutCbs) {
+      timeoutCbs[id]();
+      delete timeoutCbs[id];
+    }
+    await nextMicroTick();
+    await nextMicroTick();
+    expect(console.warn).toHaveBeenCalledTimes(1);
+    expect(warnArgs![0]!.message).toBe("onWillStart's promise hasn't resolved after 3 seconds");
+    console.warn = warn;
+    window.setTimeout = setTimeout;
  });

-  test("timeout in onWillStart doesn't emit a console log if app is destroyed", async () => {
-    const { log } = console;
-    console.log = jest.fn();
-    const { setTimeout } = window;
-    let timeoutCbs: any = {};
-    let timeoutId = 0;
-    window.setTimeout = ((cb: any) => {
-      timeoutCbs[++timeoutId] = cb;
-      return timeoutId;
-    }) as any;
-    try {
-      class Test extends Component {
-        static template = xml`<span/>`;
-        setup() {
-          onWillStart(() => new Promise(() => {}));
-        }
-      }
-      const app = new App(Test, { test: true });
-      app.mount(fixture);
-      app.destroy();
-      for (const id in timeoutCbs) {
-        timeoutCbs[id]();
-        delete timeoutCbs[id];
-      }
-      await nextMicroTick();
-      await nextMicroTick();
-      expect(console.log).toHaveBeenCalledTimes(0);
-    } finally {
-      console.log = log;
-      window.setTimeout = setTimeout;
-    }
-  });
-
-  test("timeout in onWillUpdateProps emits a console log", async () => {
+  test("timeout in onWillUpdateProps emits a warning", async () => {
    class Child extends Component {
      static template = xml``;
      setup() {
@@ -193,9 +151,9 @@ describe("lifecycle hooks", () => {
    }
    const parent = await mount(Parent, fixture, { test: true });

-    const { log } = console;
-    let logArgs: any[];
-    console.log = jest.fn((...args) => (logArgs = args));
+    const { warn } = console;
+    let warnArgs: any[];
+    console.warn = jest.fn((...args) => (warnArgs = args));
    const { setTimeout } = window;
    let timeoutCbs: any = {};
    let timeoutId = 0;
@@ -204,28 +162,25 @@ describe("lifecycle hooks", () => {
      return timeoutId;
    }) as any;

-    try {
-      parent.state.prop = 2;
-      let tick = nextTick();
-      for (const id in timeoutCbs) {
-        timeoutCbs[id]();
-        delete timeoutCbs[id];
-      }
-      await tick;
-      tick = nextTick();
-      for (const id in timeoutCbs) {
-        timeoutCbs[id]();
-        delete timeoutCbs[id];
-      }
-      await tick;
-      expect(console.log).toHaveBeenCalledTimes(1);
-      expect(logArgs![0]!.message).toBe(
-        "onWillUpdateProps's promise hasn't resolved after 3 seconds"
-      );
-    } finally {
-      console.log = log;
-      window.setTimeout = setTimeout;
+    parent.state.prop = 2;
+    let tick = nextTick();
+    for (const id in timeoutCbs) {
+      timeoutCbs[id]();
+      delete timeoutCbs[id];
    }
+    await tick;
+    tick = nextTick();
+    for (const id in timeoutCbs) {
+      timeoutCbs[id]();
+      delete timeoutCbs[id];
+    }
+    await tick;
+    expect(console.warn).toHaveBeenCalledTimes(1);
+    expect(warnArgs![0]!.message).toBe(
+      "onWillUpdateProps's promise hasn't resolved after 3 seconds"
+    );
+    console.warn = warn;
+    window.setTimeout = setTimeout;
  });

  test("mounted hook is called if mounted in DOM", async () => {
@@ -299,34 +299,6 @@ test("bound functions are considered 'alike'", async () => {
  expect(fixture.innerHTML).toBe("3child");
 });

-test("can use .translate suffix", async () => {
-  class Child extends Component {
-    static template = xml`<t t-esc="props.message"/>`;
-  }
-
-  class Parent extends Component {
-    static template = xml`<Child message.translate="some message"/>`;
-    static components = { Child };
-  }
-
-  await mount(Parent, fixture);
-  expect(fixture.innerHTML).toBe("some message");
-});
-
-test(".translate props are translated", async () => {
-  class Child extends Component {
-    static template = xml`<t t-esc="props.message"/>`;
-  }
-
-  class Parent extends Component {
-    static template = xml`<Child message.translate="some message"/>`;
-    static components = { Child };
-  }
-
-  await mount(Parent, fixture, { translateFn: () => "translated message" });
-  expect(fixture.innerHTML).toBe("translated message");
-});
-
 test("throw if prop uses an unknown suffix", async () => {
  class Child extends Component {
    static template = xml`<t t-esc="props.val"/>`;
@@ -594,7 +594,7 @@ describe("props validation", () => {

  test("props: can be defined with a boolean", async () => {
    class SubComp extends Component {
-      static props = { message: true } as const;
+      static props = { message: true };
    }
    expect(() => {
      validateProps(SubComp as any, {});
@@ -636,7 +636,7 @@ describe("props validation", () => {

  test("props: extra props cause an error, part 2", async () => {
    class SubComp extends Component {
-      static props = { message: true } as const;
+      static props = { message: true };
    }
    expect(() => {
      validateProps(SubComp as any, { message: 1, flag: true });
@@ -829,52 +829,6 @@ describe("props validation", () => {
    expect(error!).toBeDefined();
    expect(error!.message).toBe("Invalid props for component 'Child': 'message' is missing");
  });
-
-  test("can use custom class as type", async () => {
-    class CustomClass {
-      val = "hey";
-    }
-    class Child extends Component {
-      static props = { customObj: CustomClass };
-      static template = xml`<t t-esc="props.customObj.val"/>`;
-    }
-
-    class Parent extends Component {
-      static components = { Child };
-      static template = xml`<Child customObj="customObj" />`;
-      customObj = new CustomClass();
-    }
-
-    const app = new App(Parent, { test: true });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("hey");
-  });
-
-  test("can use custom class as type: validation failure", async () => {
-    class CustomClass {}
-    class Child extends Component {
-      static props = { customObj: CustomClass };
-      static template = xml`<div>hey</div>`;
-    }
-
-    class Parent extends Component {
-      static components = { Child };
-      static template = xml`<Child customObj="customObj" />`;
-      customObj = {};
-    }
-
-    const app = new App(Parent, { test: true });
-    let error: OwlError | undefined;
-    const mountProm = app.mount(fixture).catch((e: Error) => (error = e));
-    await expect(nextAppError(app)).resolves.toThrow(
-      "Invalid props for component 'Child': 'customObj' is not a customclass"
-    );
-    await mountProm;
-    expect(error!).toBeDefined();
-    expect(error!.message).toBe(
-      "Invalid props for component 'Child': 'customObj' is not a customclass"
-    );
-  });
 });

 //------------------------------------------------------------------------------
@@ -179,34 +179,6 @@ describe("slots", () => {
    expect(fixture.innerHTML).toBe("<span>default empty</span>");
  });

-  test("can use .translate suffix on slot props", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="props.slots.default.message"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`<Child><t t-set-slot="default" message.translate="some message"/></Child>`;
-      static components = { Child };
-    }
-
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("some message");
-  });
-
-  test(".translate slot props are translated", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="props.slots.default.message"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`<Child><t t-set-slot="default" message.translate="some message"/></Child>`;
-      static components = { Child };
-    }
-
-    await mount(Parent, fixture, { translateFn: () => "translated message" });
-    expect(fixture.innerHTML).toBe("translated message");
-  });
-
  test("default slot with slot scope: shorthand syntax", async () => {
    let child: any;
    class Child extends Component {
@@ -1701,31 +1673,6 @@ describe("slots", () => {
    expect(fixture.innerHTML).toBe("<div><div><p>Ablip</p><div><p>Bblip</p></div></div></div>");
  });

-  test("named slot inside named slot in t-component", async () => {
-    class Child extends Component {
-      static template = xml`<t t-slot="brol"/>`;
-    }
-    class Parent extends Component {
-      static template = xml`
-        <Child>
-          <t t-set-slot="brol">
-            outer
-            <t t-component="Child">
-              <t t-set-slot="brol">
-                <t t-esc="value"/>
-              </t>
-            </t>
-          </t>
-        </Child>`;
-      static components = { Child };
-      Child = Child;
-      value = "inner";
-    }
-    await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe(" outer inner");
-  });
-
  test("can render only empty slot", async () => {
    class Parent extends Component {
      static template = xml`<t t-slot="default"/>`;
@@ -331,32 +331,6 @@ describe("t-model directive", () => {
    expect(fixture.innerHTML).toBe("<div><input><span>test</span></div>");
  });

-  test(".trim modifier implies .lazy modifier", async () => {
-    class SomeComponent extends Component {
-      static template = xml`
-        <div>
-            <input t-model.trim="state.text"/>
-            <span><t t-esc="state.text"/></span>
-        </div>
-      `;
-      state = useState({ text: "" });
-    }
-    const comp = await mount(SomeComponent, fixture);
-
-    expect(fixture.innerHTML).toBe("<div><input><span></span></div>");
-
-    const input = fixture.querySelector("input")!;
-    input.value = "test ";
-    input.dispatchEvent(new Event("input"));
-    await nextTick();
-    expect(comp.state.text).toBe("");
-    expect(fixture.innerHTML).toBe("<div><input><span></span></div>");
-    input.dispatchEvent(new Event("change"));
-    await nextTick();
-    expect(comp.state.text).toBe("test");
-    expect(fixture.innerHTML).toBe("<div><input><span>test</span></div>");
-  });
-
  test(".number modifier", async () => {
    class SomeComponent extends Component {
      static template = xml`
@@ -14,7 +14,7 @@
    "default_popup": "popup_app/popup.html"
  },
  "permissions": ["scripting", "storage"],
-  "host_permissions": ["http://*/*", "https://*/*", "file://*"],
+  "host_permissions": ["http://*/*", "https://*/*"],
  "content_security_policy": {
    "script-src": "self",
    "object-src": "self"
@@ -109,34 +109,23 @@
        object(obj) {
          const result = [];
          let length = 0;
-          if (obj instanceof String) {
-            result[0] = `'${obj.toString()}'`;
-          } else if (obj instanceof Array) {
-            return `${obj.constructor.name} ${this.array([...obj])}`;
-          } else if (obj instanceof Number) {
-            result[0] = obj.toString();
-          } else {
-            for (const [key, value] of Object.entries(obj)) {
-              if (length > 25) {
-                result.push("...");
-                break;
-              }
-              const element = key + ": " + this.serializeItem(value);
-              length += element.length;
-              result.push(element);
-            }
-            for (const key of Object.getOwnPropertySymbols(obj)) {
-              if (length > 25) {
-                result.push("...");
-                break;
-              }
-              const element = key.toString() + ": " + this.serializeItem(obj[key]);
-              length += element.length;
-              result.push(element);
+          for (const [key, value] of Object.entries(obj)) {
+            if (length > 25) {
+              result.push("...");
+              break;
            }
+            const element = key + ": " + this.serializeItem(value);
+            length += element.length;
+            result.push(element);
          }
-          if (obj.constructor.name !== "Object") {
-            return obj.constructor.name + " {" + result.join(", ") + "}";
+          for (const key of Object.getOwnPropertySymbols(obj)) {
+            if (length > 25) {
+              result.push("...");
+              break;
+            }
+            const element = key.toString() + ": " + this.serializeItem(obj[key]);
+            length += element.length;
+            result.push(element);
          }
          return "{" + result.join(", ") + "}";
        },
@@ -834,7 +823,7 @@
              child.contentType = "set";
              child.hasChildren = true;
              break;
-            case obj.constructor.name === "Array":
+            case obj instanceof Array:
              child.contentType = "array";
              child.hasChildren = obj.length > 0;
              break;
@@ -845,9 +834,7 @@
            case obj instanceof Object:
              child.contentType = "object";
              child.hasChildren =
-                Object.keys(obj).length ||
-                Object.getOwnPropertySymbols(obj).length ||
-                obj.constructor.name !== "Object";
+                Object.keys(obj).length || Object.getOwnPropertySymbols(obj).length;
              break;
            default:
              child.contentType = typeof obj;
@@ -4,28 +4,6 @@ All notable changes to the "owl-vision" extension will be documented in this fil

 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),

-## [0.1.0] - 2024-11-06
-
-### Added
-
- Basic autocomplete in xml files. This includes autocompletion for elements, components,
-  props, attributes, and javascript expressions.
-
-  The current implementation, while relatively simple, has a couple of drawbacks:
-  - Javascript imports are not resolved by the xml autocomplete, this means that it does not
-  understand the types of imported functions or objects. That said, I've added custom support
-  for frequently used Owl imports, namely `useState` and `useRef`. You can add more in
-  the settings if needed.
-  - The autocomplete is limited to templates directly linked to components, sub-templates
-  used via t-call will not get autocompletion as no component/context can be bound to them.
-
- "Go To Definition" support for props and javascript expressions in xml
- Support for the following directives: t-att, t-model, t-tag, t-debug, t-log
-
-### Fixed
-
- Changed t-else syntax highlight from dynamic to static attribute
-
 ## [0.0.2] - 2023-2-11

 ### Added
@@ -4,7 +4,7 @@
    "description": "Owl framework extension that highlights templates and ease navigation between components and templates.",
    "publisher": "Odoo",
    "license": "LGPL-3.0-only",
-    "version": "0.1.0",
+    "version": "0.0.2",
    "repository": {
        "type": "git",
        "url": "https://github.com/odoo/owl/tree/master/tools/owl-vision"
@@ -63,13 +63,6 @@
                    "type": "string",
                    "default": "**/node_modules/**,**/lib/**,**/tests/**",
                    "description": "Files to exclude in search"
-                },
-                "owl-vision.autocomplete-mocks": {
-                    "order": 2,
-                    "type": "string",
-                    "editPresentation": "multilineText",
-                    "default": "/**\n* @template T\n* @param {T} obj\n* @returns {T}\n*/\nfunction useState(obj) {}\n\n/**\n* @typedef {Object} Ref\n* @property {HTMLElement} el\n*/\n/**\n* @returns {Ref}\n*/\nfunction useRef(name) {}",
-                    "description": "Mocks for functions or object that are imported but not resolved by the autcomplete. Add docstring comments for them to work properly."
                }
            }
        },
@@ -135,7 +128,6 @@
    "devDependencies": {
        "@types/node": "20.2.5",
        "@types/vscode": "^1.73.0",
-        "@types/xmldoc": "^1.1.9",
        "@typescript-eslint/eslint-plugin": "^5.59.8",
        "@typescript-eslint/parser": "^5.59.8",
        "@vscode/test-electron": "^2.3.2",
@@ -143,8 +135,5 @@
        "esbuild": "^0.19.5",
        "eslint": "^8.41.0",
        "typescript": "^5.1.3"
-    },
-    "dependencies": {
-        "xmldoc": "^1.3.0"
    }
-}
+}
@@ -62,6 +62,7 @@ export const propsAttributes = createAttributePatterns("props-attributes", {
 export const owlAttributesDynamic = createAttributePatterns("owl-attributes-dynamic", {
    match: [
        "t-if",
+        "t-else",
        "t-elif",
        "t-foreach",
        "t-as",
@@ -74,10 +75,6 @@ export const owlAttributesDynamic = createAttributePatterns("owl-attributes-dyna
        "t-value",
        "t-portal",
        "t-slot-scope",
-        "t-att",
-        "t-tag",
-        "t-log",
-        "t-model",
        "t-att-[a-z_:.-]+",
        "t-on-[a-z_:.-]+"
    ].join("|"),
@@ -89,13 +86,12 @@ export const owlAttributesDynamic = createAttributePatterns("owl-attributes-dyna
 export const owlAttributesStatic = createAttributePatterns("owl-attributes-static", {
    match: [
        "t-name",
-        "t-else",
        "t-ref",
        "t-set-slot",
+        "t-model",
        "t-inherit",
        "t-inherit-mode",
-        "t-translation",
-        "t-debug",
+        "t-translation"
    ].join("|"),
    attributeName: "owl.attribute owl.attribute.static",
 });
@@ -1,43 +1,18 @@
 {
-    "Basic OWL Component": {
+    "Basic owl component": {
        "prefix": "owlcomponent",
-        "scope": "javascript,typescript",
        "body": [
-            "import { Component } from \"@odoo/owl\";",
-            "",
-            "class ${1:${TM_FILENAME_BASE/(.*)/${1:/pascalcase}/g}} extends ${2:Component} {",
-            "",
-            "    static template = \"${3:${RELATIVE_FILEPATH/(.*[\\|\\/])??([a-zA-Z_]+)([\\|\\/]static[\\|\\/].*)/${2}/g}}.${4:${TM_FILENAME_BASE/(.*)/${1:/pascalcase}/g}}\";",
+            "export class ${1:component-name} extends Component {",
+            "    static template = \"${2:template-name}\";",
            "    static components = {};",
            "    static props = {};",
            "",
            "    setup() {",
-            "        ${5:super.setup();}",
-            "    }",
            "",
-            "    ${6:// Do Something}",
+            "    }",
            "}",
            ""
-
        ],
        "description": "The starting base for an owl component"
-    },
-
-    "Basic OWL Template": {
-        "prefix": "owltemplate",
-        "scope": "xml",
-        "body": [
-            "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",
-            "",
-            "<templates xml:space=\"preserve\">",
-            "",
-            "    <t t-name=\"${2:${RELATIVE_FILEPATH/(.*[\\|\\/])??([a-zA-Z_]+)([\\|\\/]static[\\|\\/].*)/${2}/g}}.${3:${TM_FILENAME_BASE/(.*)/${1:/pascalcase}/g}}\">",
-            "        ${3:<h1>Hello World</h1>}",
-            "    </t>",
-            "",
-            "</templates>",
-            ""
-        ],
-        "description": "Generate a basic OWL template XML file"
    }
 }
@@ -0,0 +1,29 @@
+import * as vscode from 'vscode';
+import { getSelectedText, showStatusMessage, hideStatusMessage } from './utils';
+import { Search } from './search';
+
+export class ComponentDefinitionProvider implements vscode.DefinitionProvider {
+
+    search: Search;
+
+    constructor(search: Search) {
+        this.search = search;
+    }
+
+    /**
+     * Interface implementation to provide definition when ctrl+click on Component
+     * tag in template.
+     */
+    async provideDefinition(document: vscode.TextDocument, position: vscode.Position) {
+        const currentWord = getSelectedText(/<\/?[A-Z][a-zA-Z]+/, document, position);
+        if (!currentWord) {
+            return;
+        }
+        const componentName = currentWord.replace(/[\/<]/g, "").trim();
+
+        showStatusMessage(`Searching for component "${componentName}"`);
+        const result = await this.search.findComponent(componentName);
+        hideStatusMessage();
+        return result;
+    }
+}
@@ -1,19 +1,20 @@
 import * as vscode from 'vscode';
 import { Search } from './search';
+import { ComponentDefinitionProvider } from './definiton_providers';
 import { OpenDirection } from './utils';
-import { OwlLanguageFeaturesProvider } from './language_features/language_features_provider';

 export async function activate(context: vscode.ExtensionContext) {
    const search = new Search();
+
    context.subscriptions.push(vscode.commands.registerCommand('owl-vision.switch', () => search.switch()));
    context.subscriptions.push(vscode.commands.registerCommand('owl-vision.switch-besides', () => search.switch(OpenDirection.Besides)));
    context.subscriptions.push(vscode.commands.registerCommand('owl-vision.switch-below', () => search.switch(OpenDirection.Below)));
    context.subscriptions.push(vscode.commands.registerCommand('owl-vision.find-component', () => search.findComponentCommand()));
    context.subscriptions.push(vscode.commands.registerCommand('owl-vision.find-template', () => search.findTemplateCommand()));

-    const languageFeaturesProvider = new OwlLanguageFeaturesProvider(search);
-	context.subscriptions.push(vscode.languages.registerCompletionItemProvider({ language: 'xml', scheme: 'file' }, languageFeaturesProvider, '.', '<'));
-    context.subscriptions.push(vscode.languages.registerDefinitionProvider({ language: 'xml', scheme: 'file' }, languageFeaturesProvider));
+    const componentDefProvider = new ComponentDefinitionProvider(search);
+    context.subscriptions.push(vscode.languages.registerDefinitionProvider({ language: 'xml' }, componentDefProvider));
+    context.subscriptions.push(vscode.languages.registerDefinitionProvider({ language: 'javascript' }, componentDefProvider));
 }

 export function deactivate() { }
@@ -1,395 +0,0 @@
-import { CompletionItemKind } from "vscode"
-
-export const owlComponentAttributes = [
-    "t-if",
-    "t-else",
-    "t-elif",
-    "t-foreach",
-    "t-as",
-    "t-key",
-    "t-esc",
-    "t-out",
-    "t-props",
-    "t-set",
-    "t-value",
-    "t-portal",
-    "t-slot-scope",
-    "t-log",
-].map(label => ({
-    label: label,
-    insertText: label + '=""',
-    kind: CompletionItemKind.Property,
-}));
-
-export const owlElementAttributes = [
-    "t-component",
-    "t-att",
-    "t-tag",
-    "t-model",
-].map(label => ({
-    label: label,
-    insertText: label + '=""',
-    kind: CompletionItemKind.Property,
-}));
-
-owlElementAttributes.push(...owlComponentAttributes);
-
-/**
-To generate this list, run the following snippet on https://developer.mozilla.org/fr/docs/Web/Events
-
-(function () {
-  const events = [...document.querySelectorAll(".section-content li a")]
-    .map(e => e.childNodes[0])
-    .filter(n => n.nodeType === 3 && n.textContent.toLowerCase() == n.textContent)
-    .map(n => "t-on-" + n.textContent.trim());
-  return JSON.stringify([...new Set(events)], null, 2);
-}())
-*/
-export const events = [
-    "t-on-abort",
-    "t-on-ended",
-    "t-on-addtrack",
-    "t-on-change",
-    "t-on-removetrack",
-    "t-on-messageerror",
-    "t-on-message",
-    "t-on-animationcancel",
-    "t-on-animationend",
-    "t-on-animationiteration",
-    "t-on-animationstart",
-    "t-on-copy",
-    "t-on-cut",
-    "t-on-dragend",
-    "t-on-dragenter",
-    "t-on-dragleave",
-    "t-on-dragover",
-    "t-on-dragstart",
-    "t-on-drag",
-    "t-on-drop",
-    "t-on-fullscreenchange",
-    "t-on-fullscreenerror",
-    "t-on-gotpointercapture",
-    "t-on-keydown",
-    "t-on-keypress",
-    "t-on-keyup",
-    "t-on-lostpointercapture",
-    "t-on-paste",
-    "t-on-pointercancel",
-    "t-on-pointerdown",
-    "t-on-pointerenter",
-    "t-on-pointerleave",
-    "t-on-pointerlockchange",
-    "t-on-pointerlockerror",
-    "t-on-pointermove",
-    "t-on-pointerout",
-    "t-on-pointerover",
-    "t-on-pointerup",
-    "t-on-readystatechange",
-    "t-on-scroll",
-    "t-on-selectionchange",
-    "t-on-selectstart",
-    "t-on-touchcancel",
-    "t-on-touchend",
-    "t-on-touchmove",
-    "t-on-touchstart",
-    "t-on-transitioncancel",
-    "t-on-transitionend",
-    "t-on-transitionrun",
-    "t-on-transitionstart",
-    "t-on-visibilitychange",
-    "t-on-wheel",
-    "t-on-afterscriptexecute",
-    "t-on-auxclick",
-    "t-on-beforescriptexecute",
-    "t-on-blur",
-    "t-on-click",
-    "t-on-compositionend",
-    "t-on-compositionstart",
-    "t-on-compositionupdate",
-    "t-on-contextmenu",
-    "t-on-dblclick",
-    "t-on-error",
-    "t-on-focusin",
-    "t-on-focusout",
-    "t-on-focus",
-    "t-on-gesturechange",
-    "t-on-gestureend",
-    "t-on-gesturestart",
-    "t-on-mousedown",
-    "t-on-mouseenter",
-    "t-on-mouseleave",
-    "t-on-mousemove",
-    "t-on-mouseout",
-    "t-on-mouseover",
-    "t-on-mouseup",
-    "t-on-mousewheel",
-    "t-on-overflow",
-    "t-on-select",
-    "t-on-show",
-    "t-on-underflow",
-    "t-on-webkitmouseforcechanged",
-    "t-on-webkitmouseforcedown",
-    "t-on-webkitmouseforceup",
-    "t-on-webkitmouseforcewillbegin",
-    "t-on-open",
-    "t-on-loadend",
-    "t-on-loadstart",
-    "t-on-load",
-    "t-on-progress",
-    "t-on-webglcontextcreationerror",
-    "t-on-webglcontextlost",
-    "t-on-webglcontextrestored",
-    "t-on-toggle",
-    "t-on-cancel",
-    "t-on-close",
-    "t-on-beforeinput",
-    "t-on-input",
-    "t-on-formdata",
-    "t-on-reset",
-    "t-on-submit",
-    "t-on-invalid",
-    "t-on-search",
-    "t-on-canplaythrough",
-    "t-on-canplay",
-    "t-on-durationchange",
-    "t-on-emptied",
-    "t-on-loadeddata",
-    "t-on-loadedmetadata",
-    "t-on-pause",
-    "t-on-playing",
-    "t-on-play",
-    "t-on-ratechange",
-    "t-on-seeked",
-    "t-on-seeking",
-    "t-on-stalled",
-    "t-on-suspend",
-    "t-on-timeupdate",
-    "t-on-volumechange",
-    "t-on-waiting",
-    "t-on-slotchange",
-    "t-on-cuechange",
-    "t-on-enterpictureinpicture",
-    "t-on-leavepictureinpicture",
-    "t-on-versionchange",
-    "t-on-blocked",
-    "t-on-upgradeneeded",
-    "t-on-success",
-    "t-on-complete",
-    "t-on-devicechange",
-    "t-on-mute",
-    "t-on-unmute",
-    "t-on-merchantvalidation",
-    "t-on-paymentmethodchange",
-    "t-on-shippingaddresschange",
-    "t-on-shippingoptionchange",
-    "t-on-payerdetailchange",
-    "t-on-resourcetimingbufferfull",
-    "t-on-resize",
-    "t-on-bufferedamountlow",
-    "t-on-closing",
-    "t-on-tonechange",
-    "t-on-gatheringstatechange",
-    "t-on-selectedcandidatepairchange",
-    "t-on-statechange",
-    "t-on-addstream",
-    "t-on-connectionstatechange",
-    "t-on-datachannel",
-    "t-on-icecandidateerror",
-    "t-on-icecandidate",
-    "t-on-iceconnectionstatechange",
-    "t-on-icegatheringstatechange",
-    "t-on-negotiationneeded",
-    "t-on-removestream",
-    "t-on-signalingstatechange",
-    "t-on-track",
-    "t-on-audioprocess",
-    "t-on-activate",
-    "t-on-contentdelete",
-    "t-on-install",
-    "t-on-notificationclick",
-    "t-on-pushsubscriptionchange",
-    "t-on-push",
-    "t-on-connect",
-    "t-on-audioend",
-    "t-on-audiostart",
-    "t-on-end",
-    "t-on-nomatch",
-    "t-on-result",
-    "t-on-soundend",
-    "t-on-soundstart",
-    "t-on-speechend",
-    "t-on-speechstart",
-    "t-on-start",
-    "t-on-voiceschanged",
-    "t-on-boundary",
-    "t-on-mark",
-    "t-on-resume",
-    "t-on-unload",
-    "t-on-afterprint",
-    "t-on-appinstalled",
-    "t-on-beforeprint",
-    "t-on-beforeunload",
-    "t-on-devicemotion",
-    "t-on-deviceorientation",
-    "t-on-gamepadconnected",
-    "t-on-gamepaddisconnected",
-    "t-on-hashchange",
-    "t-on-languagechange",
-    "t-on-offline",
-    "t-on-online",
-    "t-on-orientationchange",
-    "t-on-pagehide",
-    "t-on-pageshow",
-    "t-on-popstate",
-    "t-on-rejectionhandled",
-    "t-on-storage",
-    "t-on-unhandledrejection",
-    "t-on-vrdisplayactivate",
-    "t-on-vrdisplayblur",
-    "t-on-vrdisplayconnect",
-    "t-on-vrdisplaydeactivate",
-    "t-on-vrdisplaydisconnect",
-    "t-on-vrdisplayfocus",
-    "t-on-vrdisplaypointerrestricted",
-    "t-on-vrdisplaypointerunrestricted",
-    "t-on-vrdisplaypresentchange",
-    "t-on-timeout",
-    "t-on-inputsourceschange",
-    "t-on-selectend",
-    "t-on-squeezeend",
-    "t-on-squeezestart",
-    "t-on-squeeze"
-].map(label => ({
-    label: label,
-    insertText: label + '=""',
-    kind: CompletionItemKind.Property,
-}))
-
-
-/**
-To generate the elements list, run the following snippet on https://developer.mozilla.org/en-US/docs/Web/HTML/Element
-
-(function () {
-  const names = [...document.querySelectorAll("section:not([aria-labelledby='obsolete_and_deprecated_elements']) td:nth-child(1)")]
-  .flatMap(n => n.innerText.split(","))
-  .map(n => n.trim().replace("<", "").replace(">", ""))
-  return JSON.stringify([...new Set(names)], null, 2);
-})()
-*/
-export const elements = [
-    "t",
-    "link",
-    "meta",
-    "style",
-    "title",
-    "body",
-    "address",
-    "article",
-    "aside",
-    "footer",
-    "header",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "hgroup",
-    "main",
-    "nav",
-    "section",
-    "search",
-    "blockquote",
-    "dd",
-    "div",
-    "dl",
-    "dt",
-    "figcaption",
-    "figure",
-    "hr",
-    "li",
-    "menu",
-    "ol",
-    "p",
-    "pre",
-    "ul",
-    "a",
-    "abbr",
-    "b",
-    "bdi",
-    "bdo",
-    "br",
-    "cite",
-    "code",
-    "data",
-    "dfn",
-    "em",
-    "i",
-    "kbd",
-    "mark",
-    "q",
-    "rp",
-    "rt",
-    "ruby",
-    "s",
-    "samp",
-    "small",
-    "span",
-    "strong",
-    "sub",
-    "sup",
-    "time",
-    "u",
-    "var",
-    "wbr",
-    "area",
-    "audio",
-    "img",
-    "map",
-    "track",
-    "video",
-    "embed",
-    "iframe",
-    "object",
-    "picture",
-    "portal",
-    "source",
-    "svg",
-    "math",
-    "canvas",
-    "noscript",
-    "script",
-    "del",
-    "ins",
-    "caption",
-    "col",
-    "colgroup",
-    "table",
-    "tbody",
-    "td",
-    "tfoot",
-    "th",
-    "thead",
-    "tr",
-    "button",
-    "datalist",
-    "fieldset",
-    "form",
-    "input",
-    "label",
-    "legend",
-    "meter",
-    "optgroup",
-    "option",
-    "output",
-    "progress",
-    "select",
-    "textarea",
-    "details",
-    "dialog",
-    "summary",
-].map(label => ({
-    label: label,
-    insertText: label,
-    kind: CompletionItemKind.Property,
-}));
@@ -1,422 +0,0 @@
-import { CancellationToken, CompletionContext, CompletionItem, CompletionItemKind, CompletionItemProvider, CompletionList, DefinitionProvider, Location, Position, Range, TextDocument, TextDocumentContentProvider, Uri, commands, workspace } from "vscode";
-import { Search } from "../search";
-import { getSelectedText, hash, readFile } from "../utils";
-import { elements, events, owlComponentAttributes, owlElementAttributes } from "./items";
-import { ParseResultType, ParseResult, parse, getNodePath, parseXml } from "./parser";
-
-/**
- * Commands return basic js object which needs to be converted
- * to actual CompletionItem instances, this methods streamlines
- * this process.
- */
-function mapCompletionItems(items: any): CompletionItem[] {
-    return items.map((i: any) => {
-        const item = new CompletionItem(i.label, i.kind);
-        item.sortText = i.sortText;
-        item.detail = i.detail;
-        item.filterText = i.filterText;
-        item.insertText = i.insertText?.startsWith?.(".") ? i.insertText.substring(1) : i.insertText;
-        return item;
-    });
-}
-
-function filterComponentItems(items: CompletionItem[], excludedLabels: string[] = []): CompletionItem[] {
-    return items.filter((item) => {
-        return !excludedLabels.includes(item.label.toString()) && [
-            CompletionItemKind.Field,
-            CompletionItemKind.Method,
-            CompletionItemKind.Variable,
-            CompletionItemKind.Property,
-        ].includes(item.kind as number);
-    });
-}
-
-/**
- * Adds "this." in front of the expression if needed and increments
- * the expression offset accordingly.
- */
-function contextualize(properties: string[], expression: string, expressionOffset = 0) {
-    const match = expression.match(/^([a-zA-Z_]+)\b/);
-    if (!expression.startsWith("this.") && ((match && properties.includes(match[1])) || expression.match(/^\s*$/))) {
-        expression = "this." + expression;
-        expressionOffset += 5;
-    }
-    return { expression, expressionOffset };
-};
-
-const Commands = {
-    Completion: "vscode.executeCompletionItemProvider",
-    Definition: "vscode.executeDefinitionProvider",
-}
-
-export class OwlLanguageFeaturesProvider implements CompletionItemProvider, TextDocumentContentProvider, DefinitionProvider {
-
-    virtualDocuments = new Map();
-    componentProperties = new Map();
-    search: Search;
-
-    constructor(search: Search) {
-        this.search = search;
-        workspace.registerTextDocumentContentProvider("owl", this);
-    }
-
-    /**
-     * TextDocumentContentProvider interface implementation to provide
-     * virtual documents to vscode commands.
-     */
-    async provideTextDocumentContent(uri: Uri) {
-        const id = uri.toString(true);
-        return this.virtualDocuments.get(id);
-    }
-
-    /**
-     * DefinitionProvider interface implementation.
-     *
-     * - If the target is a js expression, will try to find the definition
-     * inside the current component.
-     * - If the target is a component element, will try to find the definition
-     * of the component.
-     */
-    async provideDefinition(document: TextDocument, position: Position) {
-        let offset = document.offsetAt(position);
-        const documentText = document.getText();
-        const parseResult = await parse(documentText, offset);
-
-        if (parseResult.type === ParseResultType.Expression) {
-            const component = await this.search.getCurrentComponent();
-            if (!component) {
-                return;
-            }
-
-            const { xmlDocument, xmlNode } = parseXml(documentText, offset);
-            const componentText = await readFile(component.uri);
-            const virtualDocument = await this.getVirtualJsDocument(document.uri, component.componentName, componentText, xmlDocument, xmlNode, parseResult);
-
-            const definitions: any = await this.executeCommand(
-                Commands.Definition,
-                document.uri,
-                virtualDocument.content,
-                virtualDocument.offset
-            );
-
-            if (definitions.length > 0) {
-                const selectionRange = definitions[0].targetSelectionRange;
-                const range = new Range(
-                    new Position(selectionRange.start.line, selectionRange.start.character),
-                    new Position(selectionRange.end.line, selectionRange.end.character),
-                )
-                return new Location(component.uri, range);
-            }
-        } else if (parseResult.type === ParseResultType.Attribute) {
-            const { xmlNode } = parseXml(documentText, offset);
-
-            const childComponent = await this.search.findComponent(xmlNode.name);
-            if (!childComponent) {
-                return [];
-            }
-
-            const modifiersRegex = new RegExp([
-                "\\.bind",
-                "\\.stop",
-                "\\.prevent",
-                "\\.self",
-                "\\.capture",
-                "\\.sythetic",
-            ].join("|"), "g");
-
-            let attributeName = getSelectedText(/\b[a-zA-Z0-9_\-.]+\b/, document, position)
-            attributeName = attributeName?.replace(modifiersRegex, "") ?? "";
-
-            const componentText = await readFile(childComponent.uri);
-            const content = `${componentText}\n${xmlNode.name}.props.${attributeName}`;
-            const definitions: any = await this.executeCommand(Commands.Definition, document.uri, content);
-
-            if (definitions.length > 0) {
-                const selectionRange = definitions[0].targetSelectionRange;
-                const range = new Range(
-                    new Position(selectionRange.start.line, selectionRange.start.character),
-                    new Position(selectionRange.end.line, selectionRange.end.character),
-                )
-                return new Location(childComponent.uri, range);
-            }
-        } else if (parseResult.type === ParseResultType.Element) {
-            const currentWord = getSelectedText(/<\/?[A-Z][a-zA-Z]+/, document, position);
-            if (!currentWord) {
-                return;
-            }
-            const componentName = currentWord.replace(/[\/<]/g, "").trim();
-            return await this.search.findComponent(componentName);
-        }
-    }
-
-    /**
-     * CompletionItemProvider interface implementation
-     *
-     * See {@link provideElementItems}, {@link provideAttributeItems} and {@link provideExpressionItems}
-     * for further details.
-     */
-    async provideCompletionItems(
-        document: TextDocument,
-        position: Position,
-        token: CancellationToken,
-        context: CompletionContext
-    ): Promise<CompletionItem[]> {
-        const component = await this.search.getCurrentComponent();
-        if (!component || token.isCancellationRequested) {
-            return [];
-        }
-
-        const offset = document.offsetAt(position);
-        const documentText = document.getText();
-
-        const parseResult = await parse(documentText, offset);
-        const { xmlDocument, xmlNode } = parseXml(documentText, offset);
-
-        if (parseResult.type === ParseResultType.Expression) {
-            return this.provideExpressionItems(document.uri, component.uri, component.componentName, xmlDocument, xmlNode, parseResult);
-        } else if (parseResult.type === ParseResultType.Attribute) {
-            return this.provideAttributeItems(document.uri, xmlNode);
-        } else if (parseResult.type === ParseResultType.Element) {
-            return this.provideElementItems(document.uri, component.uri, component.componentName, parseResult);
-        }
-
-        return [];
-    }
-
-    /**
-     * Returns the completion items for attributes.
-     * - Returns props if the element is a component
-     * - Returns the owl directives based on the element type
-     */
-    private async provideAttributeItems(
-        documentUri: Uri,
-        xmlNode: any,
-    ): Promise<CompletionItem[]> {
-        if (!xmlNode || xmlNode.name === xmlNode.name.toLowerCase()) {
-            return [...owlElementAttributes, ...events];
-        }
-
-        const childComponent = await this.search.findComponent(xmlNode.name);
-        if (!childComponent) {
-            return [];
-        }
-
-        const componentText = await readFile(childComponent.uri);
-        const content = `${componentText}\n${xmlNode.name}.props.`;
-        const list = await this.executeCommand(Commands.Completion, documentUri, content) as CompletionList;
-
-        const modifiersRegex = new RegExp([
-            "\\.bind",
-            "\\.stop",
-            "\\.prevent",
-            "\\.self",
-            "\\.capture",
-            "\\.sythetic",
-        ].join("|"), "g");
-
-        const excludedAttrs = [
-            "slots",
-            ...Object.keys(xmlNode.attr).map(attr => attr.replace(modifiersRegex, ""))
-        ];
-
-        return mapCompletionItems(filterComponentItems([
-            ...owlComponentAttributes,
-            ...list.items
-        ], excludedAttrs));
-    }
-
-    /**
-     * Returns the completion items for elements, this includes
-     * components, "t" and html elements.
-     */
-    private async provideElementItems(
-        documentUri: Uri,
-        componentUri: Uri,
-        componentName: string,
-        parseResult: any,
-    ): Promise<CompletionItem[]> {
-        const componentText = await readFile(componentUri);
-
-        const content = `${componentText}\n${componentName}.components.${parseResult.expression}`;
-        const list = await this.executeCommand(Commands.Completion, documentUri, content) as CompletionList;
-
-        return mapCompletionItems([
-            ...elements,
-            ...filterComponentItems(list.items),
-        ]);
-    }
-
-    /**
-     * Returns the completion items for a js expression
-     */
-    private async provideExpressionItems(
-        documentUri: Uri,
-        componentUri: Uri,
-        componentName: string,
-        xmlDocument: any,
-        xmlNode: any,
-        parseResult: ParseResult,
-    ): Promise<CompletionItem[]> {
-        let { attributeName } = parseResult;
-
-        const dynamicAttributeRegex = new RegExp([
-            "t-if",
-            "t-elif",
-            "t-foreach",
-            "t-as",
-            "t-key",
-            "t-esc",
-            "t-out",
-            "t-props",
-            "t-component",
-            "t-set",
-            "t-value",
-            "t-portal",
-            "t-slot-scope",
-            "t-att",
-            "t-tag",
-            "t-log",
-            "t-model",
-            "t-att-[a-z_:.-]+",
-            "t-on-[a-z_:.-]+"
-        ].join("|"));
-
-        if (xmlNode.name === xmlNode.name.toLowerCase() && !dynamicAttributeRegex.test(attributeName)) {
-            return [];
-        }
-
-        const componentText = await readFile(componentUri);
-        const virtualDocument = await this.getVirtualJsDocument(documentUri, componentName, componentText, xmlDocument, xmlNode, parseResult);
-
-        const completionList = await this.executeCommand(
-            Commands.Completion,
-            documentUri,
-            virtualDocument.content,
-            virtualDocument.offset
-        ) as CompletionList;
-
-        let items = filterComponentItems(completionList.items, ["__VIRTUAL__", "setup"]);
-
-        if (!/\bthis\./.test(parseResult.expression)) {
-            items = items.map(item => {
-                let insertText = item.insertText as string;
-                if (/\bthis\./.test(insertText)) {
-                    item.insertText = insertText.replace(/\bthis\./, "");
-                }
-                return item;
-            })
-        }
-
-        return mapCompletionItems([...items]);
-    }
-
-    /**
-     * Creates a virtual document to provide the appropriate
-     * completion items for a parsed js expression.
-     *
-     * This method:
-     * - Adds default owl variables such as env and props
-     * - Adds mocks for frequently used Owl imports (which cannot be resolved using commands)
-     * - Adds local variables generated from Owl xml directives such as t-for or t-set
-     * - Will try to add a "this." in front of the js expression if it was omitted so it can
-     *   be understood by vscode typescript server.
-     *
-     * The expression offset is also modified accordingly.
-     */
-    async getVirtualJsDocument(
-        documentUri: Uri,
-        componentName: string,
-        componentText: string,
-        xmlDocument: any,
-        xmlNode: any,
-        parseResult: ParseResult,
-    ) {
-        const properties = await this.getComponentProperties(documentUri, componentName, componentText);
-
-        // As imports do not work, use mocks for frequently used owl functions.
-        let importReplacements = workspace.getConfiguration().get(`owl-vision.autocomplete-mocks`);
-
-        // As imports do not work, manually add "env" and "props"
-        // to the current component instance.
-        const localVariables = [
-            "let env = {};",
-            "this.env = env;",
-            `let props = ${componentName}.props;`,
-            `this.props = props;`,
-        ];
-
-        // Adds local variables generated based on the template
-        const path = getNodePath(xmlDocument, xmlNode);
-        for (const node of path) {
-            if (node.attr["t-foreach"]) {
-                let array = contextualize(properties, node.attr["t-foreach"]).expression;
-                localVariables.push(`const ${node.attr["t-as"]} = ${array}[0];`);
-                localVariables.push(`const ${node.attr["t-as"]}_index = 0;`);
-                localVariables.push(`const ${node.attr["t-as"]}_first = ${array}[0];`);
-                localVariables.push(`const ${node.attr["t-as"]}_last = ${array}.at(-1);`);
-                localVariables.push(`const ${node.attr["t-as"]}_value = {};`);
-            } else if (node.attr["t-set"]) {
-                localVariables.push(`const ${node.attr["t-set"]} = ${node.attr["t-value"]};`);
-            }
-        }
-
-        const { expression, expressionOffset } = contextualize(properties, parseResult.expression, parseResult.expressionOffset);
-
-        return {
-            offset: expressionOffset,
-            content: `${componentText}
-${importReplacements}
-class __VIRTUAL__ extends ${componentName} { __VIRTUAL__() {
-${localVariables.join("\n")}
-${expression} }}`,
-        }
-    }
-
-    /**
-     * Returns the list of properties for a given component class.
-     * The result in cached in `componentProperties`.
-     *
-     * @param documentUri
-     * @param componentName
-     * @param componentText
-     * @returns
-     */
-    async getComponentProperties(
-        documentUri: Uri,
-        componentName: string,
-        componentText: string,
-    ): Promise<string[]> {
-        const check = hash(componentText);
-
-        let cached = this.componentProperties.get(componentName);
-        if (!cached || cached.check !== check) {
-            const contextExpression = `${componentText}\nclass __VIRTUAL__ extends ${componentName} { __VIRTUAL__() { \nthis. }}`;
-            const contextItemsCompletion = await this.executeCommand(Commands.Completion, documentUri, contextExpression, 5) as CompletionList;
-
-            const items = filterComponentItems(contextItemsCompletion.items, ["__VIRTUAL__", "setup"]).map(item => item.label);
-
-            cached = { check, items };
-            this.componentProperties.set(componentName, cached);
-        }
-
-        return cached.items;
-    }
-
-    private async executeCommand(commandId: string, uri: Uri, content: string, offset: any = undefined) {
-        const lines = content.split(/\r\n|\r|\n/);
-        const _offset = offset !== undefined ? offset : (lines.at(-1)?.length ?? 0);
-        const position = new Position(lines.length - 1, _offset);
-
-        const originalUri = uri.toString(true);
-        const hashValue = hash(content);
-
-        const id = `owl://js/${originalUri}_${hashValue}.js`;
-        this.virtualDocuments.set(id, content);
-
-        return await commands.executeCommand(
-            commandId,
-            Uri.parse(`owl://js/${encodeURIComponent(originalUri)}_${hashValue}.js`),
-            position
-        );
-    }
-}
@@ -1,153 +0,0 @@
-import { XmlDocument, XmlElement, XmlNode } from "xmldoc";
-
-export enum ParseResultType {
-    Expression,
-    Attribute,
-    Element
-}
-
-export interface ParseResult {
-    type: ParseResultType;
-    expression: string;
-    expressionOffset: number;
-    attributeName: string
-}
-
-/**
- * Will parse the document to find the selected expression based on an offset.
- * The result can be on of three types:
- *
- * Element: The offset is on a element tag name, the expression is the current
- * tagname or and empty string if it's just a opening tag.
- *
- * Attribute: The offset is inside the element but not in an attribute value,
- * the expression is the current attribute name if any.
- *
- * Expression: The offset is inside an attribute value, the expression is the value.
- */
-export async function parse(
-    documentText: string,
-    offset: number,
-): Promise<ParseResult> {
-
-    // Check if the offset is preceded by "<xyz", if true returns a type Element
-    // with the current name.
-    const elementMatch = documentText.substring(0, offset).match(/<([a-zA-Z\-._]*)$/);
-    if (elementMatch) {
-        return {
-            type: ParseResultType.Element,
-            expression: elementMatch[1] || "",
-            expressionOffset: elementMatch[1].length || 0,
-            attributeName: "",
-        };
-    }
-
-    let {
-        value: expression,
-        offset: expressionOffset,
-        from,
-    } = getSection(documentText, offset, '="', '"');
-
-    // If the expression contains '"', it means we aren't inside an attribute
-    // value.
-    if (expression.includes('"')) {
-        const attributeMatch = documentText.substring(0, offset).match(/\s([a-zA-Z\-._]*)$/);
-        if (attributeMatch) {
-            return {
-                type: ParseResultType.Attribute,
-                expression: attributeMatch[1] || "",
-                expressionOffset: attributeMatch[1].length || 0,
-                attributeName: "",
-            };
-        }
-    }
-
-    let attributeName = "";
-    let i = from - 2;
-    while (/\S/.test(documentText[i])) {
-        attributeName = documentText[i] + attributeName;
-        i--;
-    }
-
-    return {
-        type: ParseResultType.Expression,
-        expression,
-        expressionOffset,
-        attributeName,
-    };
-}
-
-export function getSection(text: string, offset: number, prefix: string, postfix: string) {
-    const beforeText = text.substring(0, offset);
-    let from = beforeText.lastIndexOf(prefix);
-    const afterText = text.substring(offset);
-    const to = beforeText.length + afterText.indexOf(postfix);
-
-    from = from + (prefix.length);
-
-    return {
-        value: text.substring(from, to),
-        offset: offset - from,
-        from: from,
-        to,
-    };
-}
-
-/**
- * Returns 2 xml nodes:
- * xmlNode: Tries to create the current element based on a string offset,
- * even if the node is invalid.
- * xmlDocument: The document root element, only works if the document is
- * valid xml.
- */
-export function parseXml(text: string, offset: number): any {
-    let xmlDocument = undefined;
-    try {
-        xmlDocument = new XmlDocument(text);
-    } catch (error) { }
-
-    let i = 0;
-    while (text[offset + i] !== "<") {
-        i--;
-    }
-
-    let node = "";
-    while (text[offset + i] !== ">" || text[offset + i - 1] === "=") {
-        node += text[offset + i];
-        i++;
-    }
-
-    let xmlNode = undefined;
-    try {
-        xmlNode = new XmlDocument(`${node}${node.endsWith("/") ? '' : '/'}>`);
-    } catch (error) { }
-
-    return { xmlDocument, xmlNode };
-}
-
-/**
- * Returns an array representing the elements order from the document's
- * root to the specified element.
- */
-export function getNodePath(xmlDocument: XmlDocument, xmlNode: any): Array<XmlElement> {
-    let path: Array<XmlElement> = [];
-
-    const traverse = (node: XmlElement, currentPath: Array<XmlElement>) => {
-        if (node.name === xmlNode.name && JSON.stringify(node.attr) === JSON.stringify(xmlNode.attr)) {
-            path = currentPath;
-            return;
-        }
-
-        if (node.children) {
-            for (const child of node.children) {
-                if (child instanceof XmlElement && child.name) {
-                    traverse(child, currentPath.concat(child));
-                }
-            }
-        }
-    }
-
-    traverse(xmlDocument, []);
-
-    return path;
-}
@@ -94,31 +94,6 @@ export class Search {
        return await this.find(templateName, query, "xml");
    }

-    public async getCurrentComponent(): Promise<any | undefined> {
-        if (!this.currentDocument) {
-            return;
-        }
-
-        const text = this.currentDocument.getText();
-        const templateName = this.getTemplateName(text, false);
-
-        if (templateName) {
-            const component = await this.findComponentFromTemplateName(templateName);
-
-            if (component) {
-                const componentFile = await workspace.fs.readFile(component.uri);
-                const componentText = Buffer.from(componentFile).toString('utf8');
-                const componentName = this.getComponentName(componentText, templateName);
-
-                return {
-                    uri: component.uri,
-                    templateName,
-                    componentName,
-                };
-            }
-        }
-    }
-
    private findComponentFromTemplateName(templateName: string): Promise<Location | undefined> {
        const query = this.buildQuery(`template\\s*=\\s*["']`, templateName, `["']`);
        return this.find(templateName, query, "js");
@@ -132,27 +107,6 @@ export class Search {
        }
    }

-    private getComponentName(str: string, templateName: string): string {
-        const templateNameRegex = new RegExp(`template\\s*=\\s*["'](${templateName})["']`, 'g');
-        const templateIndex = [...str.matchAll(templateNameRegex)][0]?.index ?? 0;
-
-        const matches = [...str.matchAll(new RegExp(`class\\s+([A-Za-z_]+)\\sextends\\s+[A-Za-z_]+`, 'g'))];
-        let result = "";
-        let currentIndex = -1;
-        for (const match of matches) {
-            if (match.index > templateIndex) {
-                continue;
-            }
-
-            if (match.index > currentIndex) {
-                result = match[1];
-                currentIndex = match.index;
-            }
-        }
-
-        return result;
-    }
-
    public async find(
        name: string,
        searchQuery: string,
@@ -102,20 +102,3 @@ export async function showResult(result: vscode.Location, openDirection: OpenDir
    editor.revealRange(result.range);
    editor.selection = new vscode.Selection(result.range.start, result.range.end);
 }
-
-export async function readFile(uri: vscode.Uri): Promise<string> {
-    const data = await vscode.workspace.fs.readFile(uri);
-    return Buffer.from(data).toString('utf8');
-}
-
-export function hash(str: string) {
-    var hash = 0,
-        i, chr;
-    if (str.length === 0) return hash;
-    for (i = 0; i < str.length; i++) {
-        chr = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + chr;
-        hash |= 0;
-    }
-    return hash;
-}
@@ -160,7 +160,7 @@
            "patterns": [
                {
                    "contentName": "meta.embedded.block.javascript string.quoted.double.xml",
-                    "begin": "(\\s*)(t-if|t-elif|t-foreach|t-as|t-key|t-esc|t-out|t-props|t-component|t-set|t-value|t-portal|t-slot-scope|t-att|t-tag|t-log|t-model|t-att-[a-z_:.-]+|t-on-[a-z_:.-]+)(=)(\")",
+                    "begin": "(\\s*)(t-if|t-else|t-elif|t-foreach|t-as|t-key|t-esc|t-out|t-props|t-component|t-set|t-value|t-portal|t-slot-scope|t-att-[a-z_:.-]+|t-on-[a-z_:.-]+)(=)(\")",
                    "beginCaptures": {
                        "2": {
                            "name": "entity.other.attribute-name.localname.xml owl.attribute owl.attribute.dynamic"
@@ -183,7 +183,7 @@
                },
                {
                    "contentName": "meta.embedded.block.javascript string.quoted.single.xml",
-                    "begin": "(\\s*)(t-if|t-elif|t-foreach|t-as|t-key|t-esc|t-out|t-props|t-component|t-set|t-value|t-portal|t-slot-scope|t-att|t-tag|t-log|t-model|t-att-[a-z_:.-]+|t-on-[a-z_:.-]+)(=)(')",
+                    "begin": "(\\s*)(t-if|t-else|t-elif|t-foreach|t-as|t-key|t-esc|t-out|t-props|t-component|t-set|t-value|t-portal|t-slot-scope|t-att-[a-z_:.-]+|t-on-[a-z_:.-]+)(=)(')",
                    "beginCaptures": {
                        "2": {
                            "name": "entity.other.attribute-name.localname.xml owl.attribute owl.attribute.dynamic"
@@ -210,7 +210,7 @@
            "patterns": [
                {
                    "contentName": "string.quoted.double.xml",
-                    "begin": "(\\s*)(t-name|t-else|t-ref|t-set-slot|t-inherit|t-inherit-mode|t-translation|t-debug)(=)(\")",
+                    "begin": "(\\s*)(t-name|t-ref|t-set-slot|t-model|t-inherit|t-inherit-mode|t-translation)(=)(\")",
                    "beginCaptures": {
                        "2": {
                            "name": "entity.other.attribute-name.localname.xml owl.attribute owl.attribute.static"
@@ -229,7 +229,7 @@
                },
                {
                    "contentName": "string.quoted.single.xml",
-                    "begin": "(\\s*)(t-name|t-else|t-ref|t-set-slot|t-inherit|t-inherit-mode|t-translation|t-debug)(=)(')",
+                    "begin": "(\\s*)(t-name|t-ref|t-set-slot|t-model|t-inherit|t-inherit-mode|t-translation)(=)(')",
                    "beginCaptures": {
                        "2": {
                            "name": "entity.other.attribute-name.localname.xml owl.attribute owl.attribute.static"
@@ -140,6 +140,7 @@ async function startRelease() {
  }

  // ---------------------------------------------------------------------------
+
  log(`Step ${step++}/${STEPS}: Creating the release...`);
  const relaseResult = await execCommand(`gh release create v${next} dist/*.js dist/*.zip ${draft} -F ${file}`);
  if (relaseResult !== 0) {