@odoo/owl 3.0.0-alpha.29 → 3.0.0-alpha.30

package/dist/owl.iife.js

@@ -74,8 +74,7 @@ var owl = (() => {
     xml: () => xml
   });
 
-  // ../owl-runtime/dist/owl-runtime.es.js
-  var version = "3.0.0-alpha.29";
+  // ../owl-core/dist/owl-core.es.js
   var OwlError = class extends Error {
     cause;
   };
@@ -93,7 +92,7 @@ var owl = (() => {
     return function batchedCall(...args) {
       if (!scheduled) {
         scheduled = true;
-        queueMicrotask(() => {
+        Promise.resolve().then(() => {
           scheduled = false;
           callback(...args);
         });
@@ -141,10 +140,11 @@ var owl = (() => {
   }
   var batchProcessEffects = batched(processEffects);
   function processEffects() {
-    for (let i = 0; i < observers.length; i++) {
-      updateComputation(observers[i]);
+    const pending = observers;
+    observers = [];
+    for (let i = 0; i < pending.length; i++) {
+      updateComputation(pending[i]);
     }
-    observers.length = 0;
   }
   function getCurrentComputation() {
     return currentComputation;
@@ -163,6 +163,9 @@ var owl = (() => {
           continue;
         }
         updateComputation(source);
+        if (computation.state === 1) {
+          break;
+        }
       }
       if (computation.state !== 1) {
         computation.state = 0;
@@ -172,15 +175,18 @@ var owl = (() => {
     removeSources(computation);
     const previousComputation = currentComputation;
     currentComputation = computation;
-    computation.value = computation.compute();
-    computation.state = 0;
-    currentComputation = previousComputation;
+    try {
+      computation.value = computation.compute();
+      computation.state = 0;
+    } finally {
+      currentComputation = previousComputation;
+    }
   }
   function removeSources(computation) {
     const sources = computation.sources;
     for (const source of sources) {
-      const observers22 = source.observers;
-      observers22.delete(computation);
+      const observers2 = source.observers;
+      observers2.delete(computation);
     }
     sources.clear();
   }
@@ -444,10 +450,10 @@ var owl = (() => {
     } else {
       handler = basicProxyHandler(atom);
     }
-    const proxy22 = new Proxy(target, handler);
-    proxyCache.set(target, proxy22);
-    targets.set(proxy22, target);
-    return proxy22;
+    const proxy2 = new Proxy(target, handler);
+    proxyCache.set(target, proxy2);
+    targets.set(proxy2, target);
+    return proxy2;
   }
   function proxy(target) {
     return proxifyTarget(target, null);
@@ -629,11 +635,11 @@ var owl = (() => {
     };
     return readSignal;
   }
-  function triggerSignal(signal22) {
-    if (typeof signal22 !== "function" || signal22[atomSymbol]?.type !== "signal") {
-      throw new OwlError(`Value is not a signal (${signal22})`);
+  function triggerSignal(signal2) {
+    if (typeof signal2 !== "function" || signal2[atomSymbol]?.type !== "signal") {
+      throw new OwlError(`Value is not a signal (${signal2})`);
     }
-    onWriteAtom(signal22[atomSymbol]);
+    onWriteAtom(signal2[atomSymbol]);
   }
   function signalArray(initialValue) {
     return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom));
@@ -1259,6 +1265,9 @@ ${issueStrings}`);
       );
     }
   }
+
+  // ../owl-runtime/dist/owl-runtime.es.js
+  var version = "3.0.0-alpha.30";
   var fibersInError = /* @__PURE__ */ new WeakMap();
   var nodeErrorHandlers = /* @__PURE__ */ new WeakMap();
   function invokeErrorHandlers(node, error, finalize, markFibers) {
@@ -1314,12 +1323,7 @@ ${issueStrings}`);
         app.destroy();
       } catch (e) {
       }
-      if (error instanceof OwlError) {
-        return error;
-      }
-      return Object.assign(new OwlError(`[Owl] Unhandled error. Destroying the root component`), {
-        cause: error
-      });
+      return error;
     };
     const result = invokeErrorHandlers(node, error, finalize, true);
     if (!result.handled) {
@@ -3039,8 +3043,9 @@ ${issueStrings}`);
           this.bdom = node.renderFn();
         } catch (e) {
           handleError({ node, error: e });
+        } finally {
+          setComputation(c);
         }
-        setComputation(c);
         const newCounter = root.counter - 1;
         root.counter = newCounter;
         if (newCounter === 0) {
@@ -3246,7 +3251,6 @@ ${issueStrings}`);
         setComputation(prev);
         await Promise.all(promises);
       } catch (e) {
-        setComputation(prev);
         if (isAbortError(e) && this.status > STATUS.MOUNTED) {
           return;
         }
@@ -3600,7 +3604,10 @@ ${issueStrings}`);
       remove2 = ref2.delete.bind(ref2);
     } else if (ref2.set) {
       add = ref2.set.bind(ref2);
-      remove2 = () => ref2.set(null);
+      const atom = ref2[atomSymbol];
+      remove2 = atom ? (prevEl) => {
+        if (atom.value === prevEl) ref2.set(null);
+      } : () => ref2.set(null);
     } else {
       throw new OwlError(
         `Ref should implement either a 'set' function or 'add' and 'delete' functions`
@@ -3694,12 +3701,13 @@ ${issueStrings}`);
           if (node.patched.length) parentRoot.patched.push(fiber);
           let promises;
           if (hooks.length) {
+            let nextProps = props2;
             const defaultProps = node.defaultProps;
             if (defaultProps) {
-              props2 = Object.assign({}, props2);
+              nextProps = Object.assign({}, props2);
               for (const k in defaultProps) {
-                if (props2[k] === void 0) {
-                  props2[k] = defaultProps[k];
+                if (nextProps[k] === void 0) {
+                  nextProps[k] = defaultProps[k];
                 }
               }
             }
@@ -3707,7 +3715,7 @@ ${issueStrings}`);
             const prev = getCurrentComputation();
             setComputation(void 0);
             for (const f of hooks) {
-              const r = f.call(component, props2);
+              const r = f.call(component, nextProps);
               if (r && typeof r.then === "function") {
                 (promises ||= []).push(r);
               }
@@ -3827,9 +3835,7 @@ ${issueStrings}`);
           return;
         }
         const rawTemplate = this.rawTemplates[name];
-        const currentAsString = typeof rawTemplate === "string" ? rawTemplate : rawTemplate instanceof Element ? rawTemplate.outerHTML : rawTemplate.toString();
-        const newAsString = typeof template === "string" ? template : template.outerHTML;
-        if (currentAsString === newAsString) {
+        if (areTemplatesEqual(rawTemplate, template)) {
           return;
         }
         throw new OwlError(`Template ${name} already defined with different content`);
@@ -3886,6 +3892,17 @@ ${issueStrings}`);
     return name;
   }
   xml.nextId = 1;
+  function areTemplatesEqual(t1, t2) {
+    if (t1 === t2) {
+      return true;
+    }
+    if (typeof t1 === "function" !== (typeof t2 === "function")) {
+      return false;
+    }
+    const s1 = t1 instanceof Element ? t1.outerHTML : String(t1);
+    const s2 = t2 instanceof Element ? t2.outerHTML : String(t2);
+    return s1 === s2;
+  }
   var hasBeenLogged = false;
   var apps = /* @__PURE__ */ new Set();
   if (typeof window !== "undefined") {
@@ -4145,6 +4162,9 @@ ${issueStrings}`);
       if (app.dev) {
         const validation = defaults ? validateObjectWithDefaults(type, defaults) : types2.object(type);
         assertType(node.props, validation, `Invalid component props (${componentName})`);
+        if (defaults) {
+          assertType(defaults, validation, `Invalid default props (${componentName})`);
+        }
         node.willUpdateProps.push((np) => {
           assertType(np, validation, `Invalid component props (${componentName})`);
         });
@@ -4365,396 +4385,12 @@ ${issueStrings}`);
   };
   var __info__ = {
     version: App.version,
-    date: "2026-04-23T11:09:22.692Z",
-    hash: "2220e1dd",
+    date: "2026-05-19T14:24:07.068Z",
+    hash: "a826de4f",
     url: "https://github.com/odoo/owl"
   };
 
   // ../owl-compiler/dist/owl-compiler.es.js
-  var OwlError2 = class extends Error {
-    cause;
-  };
-  function batched2(callback) {
-    let scheduled = false;
-    return function batchedCall(...args) {
-      if (!scheduled) {
-        scheduled = true;
-        queueMicrotask(() => {
-          scheduled = false;
-          callback(...args);
-        });
-      }
-    };
-  }
-  var atomSymbol2 = /* @__PURE__ */ Symbol("Atom");
-  var observers2 = [];
-  var currentComputation2;
-  function onReadAtom2(atom) {
-    if (!currentComputation2) {
-      return;
-    }
-    currentComputation2.sources.add(atom);
-    atom.observers.add(currentComputation2);
-  }
-  function onWriteAtom2(atom) {
-    for (const ctx of atom.observers) {
-      if (ctx.state === 0) {
-        if (ctx.isDerived) {
-          markDownstream2(ctx);
-        } else {
-          observers2.push(ctx);
-        }
-      }
-      ctx.state = 1;
-    }
-    batchProcessEffects2();
-  }
-  var batchProcessEffects2 = batched2(processEffects2);
-  function processEffects2() {
-    for (let i = 0; i < observers2.length; i++) {
-      updateComputation2(observers2[i]);
-    }
-    observers2.length = 0;
-  }
-  function updateComputation2(computation) {
-    const state = computation.state;
-    if (state === 0) {
-      return;
-    }
-    if (state === 2) {
-      for (const source of computation.sources) {
-        if (!("compute" in source)) {
-          continue;
-        }
-        updateComputation2(source);
-      }
-      if (computation.state !== 1) {
-        computation.state = 0;
-        return;
-      }
-    }
-    removeSources2(computation);
-    const previousComputation = currentComputation2;
-    currentComputation2 = computation;
-    computation.value = computation.compute();
-    computation.state = 0;
-    currentComputation2 = previousComputation;
-  }
-  function removeSources2(computation) {
-    const sources = computation.sources;
-    for (const source of sources) {
-      const observers22 = source.observers;
-      observers22.delete(computation);
-    }
-    sources.clear();
-  }
-  function markDownstream2(computation) {
-    const stack = [computation];
-    let current;
-    while (current = stack.pop()) {
-      for (const observer of current.observers) {
-        if (observer.state) {
-          continue;
-        }
-        observer.state = 2;
-        if (observer.isDerived) {
-          stack.push(observer);
-        } else {
-          observers2.push(observer);
-        }
-      }
-    }
-  }
-  var KEYCHANGES2 = /* @__PURE__ */ Symbol("Key changes");
-  var objectToString2 = Object.prototype.toString;
-  var objectHasOwnProperty2 = Object.prototype.hasOwnProperty;
-  function canBeMadeReactive2(value) {
-    if (typeof value !== "object" || value === null) {
-      return false;
-    }
-    const raw = toRaw2(value);
-    if (Array.isArray(raw) || raw instanceof Set || raw instanceof Map || raw instanceof WeakMap) {
-      return true;
-    }
-    return objectToString2.call(raw) === "[object Object]";
-  }
-  function possiblyReactive2(val, atom) {
-    return !atom && canBeMadeReactive2(val) ? proxy2(val) : val;
-  }
-  var skipped2 = /* @__PURE__ */ new WeakSet();
-  function toRaw2(value) {
-    return targets2.has(value) ? targets2.get(value) : value;
-  }
-  var targetToKeysToAtomItem2 = /* @__PURE__ */ new WeakMap();
-  function getTargetKeyAtom2(target, key) {
-    let keyToAtomItem = targetToKeysToAtomItem2.get(target);
-    if (!keyToAtomItem) {
-      keyToAtomItem = /* @__PURE__ */ new Map();
-      targetToKeysToAtomItem2.set(target, keyToAtomItem);
-    }
-    let atom = keyToAtomItem.get(key);
-    if (!atom) {
-      atom = {
-        value: void 0,
-        observers: /* @__PURE__ */ new Set()
-      };
-      keyToAtomItem.set(key, atom);
-    }
-    return atom;
-  }
-  function onReadTargetKey2(target, key, atom) {
-    onReadAtom2(atom ?? getTargetKeyAtom2(target, key));
-  }
-  function onWriteTargetKey2(target, key, atom) {
-    if (!atom) {
-      const keyToAtomItem = targetToKeysToAtomItem2.get(target);
-      if (!keyToAtomItem) {
-        return;
-      }
-      if (!keyToAtomItem.has(key)) {
-        return;
-      }
-      atom = keyToAtomItem.get(key);
-    }
-    onWriteAtom2(atom);
-  }
-  var targets2 = /* @__PURE__ */ new WeakMap();
-  var proxyCache2 = /* @__PURE__ */ new WeakMap();
-  function proxifyTarget2(target, atom) {
-    if (!canBeMadeReactive2(target)) {
-      throw new OwlError2(`Cannot make the given value reactive`);
-    }
-    if (skipped2.has(target)) {
-      return target;
-    }
-    if (targets2.has(target)) {
-      return target;
-    }
-    const reactive = proxyCache2.get(target);
-    if (reactive) {
-      return reactive;
-    }
-    let handler;
-    if (target instanceof Map) {
-      handler = collectionsProxyHandler2(target, "Map", atom);
-    } else if (target instanceof Set) {
-      handler = collectionsProxyHandler2(target, "Set", atom);
-    } else if (target instanceof WeakMap) {
-      handler = collectionsProxyHandler2(target, "WeakMap", atom);
-    } else {
-      handler = basicProxyHandler2(atom);
-    }
-    const proxy22 = new Proxy(target, handler);
-    proxyCache2.set(target, proxy22);
-    targets2.set(proxy22, target);
-    return proxy22;
-  }
-  function proxy2(target) {
-    return proxifyTarget2(target, null);
-  }
-  function basicProxyHandler2(atom) {
-    return {
-      get(target, key, receiver) {
-        onReadTargetKey2(target, key, atom);
-        const value = Reflect.get(target, key, receiver);
-        if (atom || typeof value !== "object" || value === null) {
-          return value;
-        }
-        if (!canBeMadeReactive2(value)) {
-          return value;
-        }
-        const desc = Object.getOwnPropertyDescriptor(target, key);
-        if (desc && !desc.writable && !desc.configurable) {
-          return value;
-        }
-        return proxifyTarget2(value, null);
-      },
-      set(target, key, value, receiver) {
-        const hadKey = objectHasOwnProperty2.call(target, key);
-        const originalValue = Reflect.get(target, key, receiver);
-        const ret = Reflect.set(target, key, toRaw2(value), receiver);
-        if (!hadKey && objectHasOwnProperty2.call(target, key)) {
-          onWriteTargetKey2(target, KEYCHANGES2, atom);
-        }
-        if (originalValue !== Reflect.get(target, key, receiver) || key === "length" && Array.isArray(target)) {
-          onWriteTargetKey2(target, key, atom);
-        }
-        return ret;
-      },
-      deleteProperty(target, key) {
-        const ret = Reflect.deleteProperty(target, key);
-        onWriteTargetKey2(target, KEYCHANGES2, atom);
-        onWriteTargetKey2(target, key, atom);
-        return ret;
-      },
-      ownKeys(target) {
-        onReadTargetKey2(target, KEYCHANGES2, atom);
-        return Reflect.ownKeys(target);
-      },
-      has(target, key) {
-        onReadTargetKey2(target, KEYCHANGES2, atom);
-        return Reflect.has(target, key);
-      }
-    };
-  }
-  function makeKeyObserver2(methodName, target, atom) {
-    return (key) => {
-      key = toRaw2(key);
-      onReadTargetKey2(target, key, atom);
-      return possiblyReactive2(target[methodName](key), atom);
-    };
-  }
-  function makeIteratorObserver2(methodName, target, atom) {
-    return function* () {
-      onReadTargetKey2(target, KEYCHANGES2, atom);
-      const keys = target.keys();
-      for (const item of target[methodName]()) {
-        const key = keys.next().value;
-        onReadTargetKey2(target, key, atom);
-        yield possiblyReactive2(item, atom);
-      }
-    };
-  }
-  function makeForEachObserver2(target, atom) {
-    return function forEach(forEachCb, thisArg) {
-      onReadTargetKey2(target, KEYCHANGES2, atom);
-      target.forEach(function(val, key, targetObj) {
-        onReadTargetKey2(target, key, atom);
-        forEachCb.call(
-          thisArg,
-          possiblyReactive2(val, atom),
-          possiblyReactive2(key, atom),
-          possiblyReactive2(targetObj, atom)
-        );
-      }, thisArg);
-    };
-  }
-  function delegateAndNotify2(setterName, getterName, target, atom) {
-    return (key, value) => {
-      key = toRaw2(key);
-      const hadKey = target.has(key);
-      const originalValue = target[getterName](key);
-      const ret = target[setterName](key, value);
-      const hasKey = target.has(key);
-      if (hadKey !== hasKey) {
-        onWriteTargetKey2(target, KEYCHANGES2, atom);
-      }
-      if (originalValue !== target[getterName](key)) {
-        onWriteTargetKey2(target, key, atom);
-      }
-      return ret;
-    };
-  }
-  function makeClearNotifier2(target, atom) {
-    return () => {
-      const allKeys = [...target.keys()];
-      target.clear();
-      onWriteTargetKey2(target, KEYCHANGES2, atom);
-      for (const key of allKeys) {
-        onWriteTargetKey2(target, key, atom);
-      }
-    };
-  }
-  var rawTypeToFuncHandlers2 = {
-    Set: (target, atom) => ({
-      has: makeKeyObserver2("has", target, atom),
-      add: delegateAndNotify2("add", "has", target, atom),
-      delete: delegateAndNotify2("delete", "has", target, atom),
-      keys: makeIteratorObserver2("keys", target, atom),
-      values: makeIteratorObserver2("values", target, atom),
-      entries: makeIteratorObserver2("entries", target, atom),
-      [Symbol.iterator]: makeIteratorObserver2(Symbol.iterator, target, atom),
-      forEach: makeForEachObserver2(target, atom),
-      clear: makeClearNotifier2(target, atom),
-      get size() {
-        onReadTargetKey2(target, KEYCHANGES2, atom);
-        return target.size;
-      }
-    }),
-    Map: (target, atom) => ({
-      has: makeKeyObserver2("has", target, atom),
-      get: makeKeyObserver2("get", target, atom),
-      set: delegateAndNotify2("set", "get", target, atom),
-      delete: delegateAndNotify2("delete", "has", target, atom),
-      keys: makeIteratorObserver2("keys", target, atom),
-      values: makeIteratorObserver2("values", target, atom),
-      entries: makeIteratorObserver2("entries", target, atom),
-      [Symbol.iterator]: makeIteratorObserver2(Symbol.iterator, target, atom),
-      forEach: makeForEachObserver2(target, atom),
-      clear: makeClearNotifier2(target, atom),
-      get size() {
-        onReadTargetKey2(target, KEYCHANGES2, atom);
-        return target.size;
-      }
-    }),
-    WeakMap: (target, atom) => ({
-      has: makeKeyObserver2("has", target, atom),
-      get: makeKeyObserver2("get", target, atom),
-      set: delegateAndNotify2("set", "get", target, atom),
-      delete: delegateAndNotify2("delete", "has", target, atom)
-    })
-  };
-  function collectionsProxyHandler2(target, targetRawType, atom) {
-    const specialHandlers = rawTypeToFuncHandlers2[targetRawType](target, atom);
-    return Object.assign(basicProxyHandler2(atom), {
-      // FIXME: probably broken when part of prototype chain since we ignore the receiver
-      get(target2, key) {
-        if (objectHasOwnProperty2.call(specialHandlers, key)) {
-          return specialHandlers[key];
-        }
-        onReadTargetKey2(target2, key, atom);
-        return possiblyReactive2(target2[key], atom);
-      }
-    });
-  }
-  function buildSignal2(value, set) {
-    const atom = {
-      type: "signal",
-      value,
-      observers: /* @__PURE__ */ new Set()
-    };
-    let readValue = set(atom);
-    const readSignal = () => {
-      onReadAtom2(atom);
-      return readValue;
-    };
-    readSignal[atomSymbol2] = atom;
-    readSignal.set = function writeSignal(newValue) {
-      if (Object.is(atom.value, newValue)) {
-        return;
-      }
-      atom.value = newValue;
-      readValue = set(atom);
-      onWriteAtom2(atom);
-    };
-    return readSignal;
-  }
-  function triggerSignal2(signal22) {
-    if (typeof signal22 !== "function" || signal22[atomSymbol2]?.type !== "signal") {
-      throw new OwlError2(`Value is not a signal (${signal22})`);
-    }
-    onWriteAtom2(signal22[atomSymbol2]);
-  }
-  function signalArray2(initialValue) {
-    return buildSignal2(initialValue, (atom) => proxifyTarget2(atom.value, atom));
-  }
-  function signalObject2(initialValue) {
-    return buildSignal2(initialValue, (atom) => proxifyTarget2(atom.value, atom));
-  }
-  function signalMap2(initialValue) {
-    return buildSignal2(initialValue, (atom) => proxifyTarget2(atom.value, atom));
-  }
-  function signalSet2(initialValue) {
-    return buildSignal2(initialValue, (atom) => proxifyTarget2(atom.value, atom));
-  }
-  function signal2(value) {
-    return buildSignal2(value, (atom) => atom.value);
-  }
-  signal2.trigger = triggerSignal2;
-  signal2.Array = signalArray2;
-  signal2.Map = signalMap2;
-  signal2.Object = signalObject2;
-  signal2.Set = signalSet2;
   var RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date,__globals__".split(
     ","
   );
@@ -4792,14 +4428,14 @@ ${issueStrings}`);
         i++;
         cur = expr[i];
         if (!cur) {
-          throw new OwlError2("Invalid expression");
+          throw new OwlError("Invalid expression");
         }
         s += cur;
       }
       i++;
     }
     if (expr[i] !== start) {
-      throw new OwlError2("Invalid expression");
+      throw new OwlError("Invalid expression");
     }
     s += start;
     if (start === "`") {
@@ -4891,19 +4527,25 @@ ${issueStrings}`);
       error = e;
     }
     if (current.length || error) {
-      throw new OwlError2(`Tokenizer error: could not tokenize \`${expr}\``);
+      throw new OwlError(`Tokenizer error: could not tokenize \`${expr}\``);
     }
     return result;
   }
   var isLeftSeparator = (token) => token && (token.type === "LEFT_BRACE" || token.type === "COMMA");
   var isRightSeparator = (token) => token && (token.type === "RIGHT_BRACE" || token.type === "COMMA");
   var paddedValues = /* @__PURE__ */ new Map([["in ", " in "]]);
-  function processExpr(expr) {
-    const localVars = /* @__PURE__ */ new Set();
+  function processExpr(expr, seededLocals) {
+    const scopeStack2 = [];
+    if (seededLocals?.size) {
+      scopeStack2.push({ vars: seededLocals, depth: -Infinity });
+    }
     const tokens = tokenize(expr);
     let i = 0;
     let stack = [];
     let topLevelArrowIndex = -1;
+    function isLocal(name) {
+      return scopeStack2.some((s) => s.vars.has(name));
+    }
     while (i < tokens.length) {
       let token = tokens[i];
       let prevToken = tokens[i - 1];
@@ -4919,6 +4561,10 @@ ${issueStrings}`);
         case "RIGHT_BRACKET":
         case "RIGHT_PAREN":
           stack.pop();
+          while (scopeStack2.length > 0 && stack.length < scopeStack2[scopeStack2.length - 1].depth) {
+            scopeStack2.pop();
+          }
+          break;
       }
       let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
       if (isVar) {
@@ -4937,9 +4583,14 @@ ${issueStrings}`);
         }
       }
       if (token.type === "TEMPLATE_STRING") {
-        token.value = token.replace((expr2) => compileExpr(expr2));
+        const currentLocals = /* @__PURE__ */ new Set();
+        for (const scope of scopeStack2) {
+          for (const v of scope.vars) currentLocals.add(v);
+        }
+        token.value = token.replace((expr2) => compileExpr(expr2, currentLocals));
       }
       if (nextToken && nextToken.type === "OPERATOR" && nextToken.value === "=>") {
+        const newScope = /* @__PURE__ */ new Set();
         if (stack.length === 0) {
           topLevelArrowIndex = i + 1;
         }
@@ -4947,31 +4598,29 @@ ${issueStrings}`);
           let j = i - 1;
           while (j > 0 && tokens[j].type !== "LEFT_PAREN") {
             if (tokens[j].type === "SYMBOL" && tokens[j].originalValue) {
-              tokens[j].value = tokens[j].originalValue;
-              localVars.add(tokens[j].value);
+              newScope.add(tokens[j].originalValue);
+              tokens[j].value = `_${tokens[j].originalValue}`;
+              tokens[j].isLocal = true;
             }
             j--;
           }
         } else {
-          localVars.add(token.value);
+          newScope.add(token.value);
         }
+        scopeStack2.push({ vars: newScope, depth: stack.length });
       }
       if (isVar) {
         token.varName = token.value;
-        if (!localVars.has(token.value)) {
+        if (!isLocal(token.value)) {
           token.originalValue = token.value;
           token.value = `ctx['${token.value}']`;
+        } else {
+          token.value = `_${token.value}`;
+          token.isLocal = true;
         }
       }
       i++;
     }
-    for (const token of tokens) {
-      if (token.type === "SYMBOL" && token.varName && localVars.has(token.value)) {
-        token.originalValue = token.value;
-        token.value = `_${token.value}`;
-        token.isLocal = true;
-      }
-    }
     let freeVariables = null;
     if (topLevelArrowIndex !== -1) {
       freeVariables = [];
@@ -4987,8 +4636,8 @@ ${issueStrings}`);
     const compiled = tokens.map((t) => paddedValues.get(t.value) || t.value).join("");
     return { expr: compiled, freeVariables };
   }
-  function compileExpr(expr) {
-    return processExpr(expr).expr;
+  function compileExpr(expr, seededLocals) {
+    return processExpr(expr, seededLocals).expr;
   }
   var INTERP_REGEXP = /\{\{.*?\}\}|\#\{.*?\}/g;
   function replaceDynamicParts(s, replacer) {
@@ -5030,7 +4679,7 @@ ${"-".repeat(columnIndex - 1)}^`;
           }
         }
       }
-      throw new OwlError2(msg);
+      throw new OwlError(msg);
     }
     return doc;
   }
@@ -5109,13 +4758,13 @@ ${"-".repeat(columnIndex - 1)}^`;
     const nodeAttrsNames = node.getAttributeNames();
     for (let attr of nodeAttrsNames) {
       if (attr === "t-custom" || attr === "t-custom-") {
-        throw new OwlError2("Missing custom directive name with t-custom directive");
+        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 OwlError2(`Custom directive "${directiveName}" is not defined`);
+          throw new OwlError(`Custom directive "${directiveName}" is not defined`);
         }
         const value = node.getAttribute(attr);
         const modifiers = attr.split(".").slice(1);
@@ -5123,7 +4772,7 @@ ${"-".repeat(columnIndex - 1)}^`;
         try {
           customDirective(node, value, modifiers);
         } catch (error) {
-          throw new OwlError2(
+          throw new OwlError(
             `Custom directive "${directiveName}" throw the following error: ${error}`
           );
         }
@@ -5170,7 +4819,7 @@ ${"-".repeat(columnIndex - 1)}^`;
       return null;
     }
     if (tagName.startsWith("block-")) {
-      throw new OwlError2(`Invalid tag name: '${tagName}'`);
+      throw new OwlError(`Invalid tag name: '${tagName}'`);
     }
     ctx = Object.assign({}, ctx);
     if (tagName === "pre") {
@@ -5187,14 +4836,14 @@ ${"-".repeat(columnIndex - 1)}^`;
     for (let attr of nodeAttrsNames) {
       const value = node.getAttribute(attr);
       if (attr === "t-on" || attr === "t-on-") {
-        throw new OwlError2("Missing event name with t-on directive");
+        throw new OwlError("Missing event name with t-on directive");
       }
       if (attr.startsWith("t-on-")) {
         on = on || {};
         on[attr.slice(5)] = value;
       } else if (attr.startsWith("t-model")) {
         if (!["input", "select", "textarea"].includes(tagName)) {
-          throw new OwlError2(
+          throw new OwlError(
             "The t-model directive only works with <input>, <textarea> and <select>"
           );
         }
@@ -5223,7 +4872,7 @@ ${"-".repeat(columnIndex - 1)}^`;
           ctx.tModelInfo = model;
         }
       } else if (attr.startsWith("block-")) {
-        throw new OwlError2(`Invalid attribute: '${attr}'`);
+        throw new OwlError(`Invalid attribute: '${attr}'`);
       } else if (attr === "xmlns") {
         ns = value;
       } else if (attr.startsWith("t-translation-context-")) {
@@ -5232,7 +4881,7 @@ ${"-".repeat(columnIndex - 1)}^`;
         attrsTranslationCtx[attrName] = value;
       } else if (attr !== "t-name") {
         if (attr.startsWith("t-") && !attr.startsWith("t-att")) {
-          throw new OwlError2(`Unknown QWeb directive: '${attr}'`);
+          throw new OwlError(`Unknown QWeb directive: '${attr}'`);
         }
         const tModel = ctx.tModelInfo;
         if (tModel && ["t-att-value", "t-attf-value"].includes(attr)) {
@@ -5299,7 +4948,7 @@ ${"-".repeat(columnIndex - 1)}^`;
     node.removeAttribute("t-as");
     const key = node.getAttribute("t-key");
     if (!key) {
-      throw new OwlError2(
+      throw new OwlError(
         `"Directive t-foreach should always be used with a t-key!" (expression: t-foreach="${collection}" t-as="${elem}")`
       );
     }
@@ -5348,7 +4997,7 @@ ${"-".repeat(columnIndex - 1)}^`;
       return null;
     }
     if (node.tagName !== "t") {
-      throw new OwlError2(
+      throw new OwlError(
         `Directive 't-call' can only be used on <t> nodes (used on a <${node.tagName}>)`
       );
     }
@@ -5452,7 +5101,7 @@ ${"-".repeat(columnIndex - 1)}^`;
     const firstLetter = name[0];
     let isDynamic = node.hasAttribute("t-component");
     if (isDynamic && name !== "t") {
-      throw new OwlError2(
+      throw new OwlError(
         `Directive 't-component' can only be used on <t> nodes (used on a <${name}>)`
       );
     }
@@ -5482,7 +5131,7 @@ ${"-".repeat(columnIndex - 1)}^`;
           on[name2.slice(5)] = value;
         } else {
           const message = directiveErrorMap.get(name2.split("-").slice(0, 2).join("-"));
-          throw new OwlError2(message || `unsupported directive on Component: ${name2}`);
+          throw new OwlError(message || `unsupported directive on Component: ${name2}`);
         }
       } else {
         props2 = props2 || {};
@@ -5495,7 +5144,7 @@ ${"-".repeat(columnIndex - 1)}^`;
       const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
       for (let slotNode of slotNodes) {
         if (slotNode.tagName !== "t") {
-          throw new OwlError2(
+          throw new OwlError(
             `Directive 't-set-slot' can only be used on <t> nodes (used on a <${slotNode.tagName}>)`
           );
         }
@@ -5682,24 +5331,24 @@ ${"-".repeat(columnIndex - 1)}^`;
       let nattr = (name) => +!!node.getAttribute(name);
       if (prevElem && (pattr("t-if") || pattr("t-elif"))) {
         if (pattr("t-foreach")) {
-          throw new OwlError2(
+          throw new OwlError(
             "t-if cannot stay at the same level as t-foreach when using t-elif or t-else"
           );
         }
         if (["t-if", "t-elif", "t-else"].map(nattr).reduce(function(a, b) {
           return a + b;
         }) > 1) {
-          throw new OwlError2("Only one conditional branching directive is allowed per node");
+          throw new OwlError("Only one conditional branching directive is allowed per node");
         }
         let textNode;
         while ((textNode = node.previousSibling) !== prevElem) {
           if (textNode.nodeValue.trim().length && textNode.nodeType !== 8) {
-            throw new OwlError2("text is not allowed between branching directives");
+            throw new OwlError("text is not allowed between branching directives");
           }
           textNode.remove();
         }
       } else {
-        throw new OwlError2(
+        throw new OwlError(
           "t-elif and t-else directives must be preceded by a t-if or t-elif directive"
         );
       }
@@ -5711,7 +5360,7 @@ ${"-".repeat(columnIndex - 1)}^`;
     );
     for (const el2 of elements) {
       if (el2.childNodes.length) {
-        throw new OwlError2(`Cannot have t-out on a component that already has content`);
+        throw new OwlError(`Cannot have t-out on a component that already has content`);
       }
       const value = el2.getAttribute("t-out");
       el2.removeAttribute("t-out");
@@ -6118,7 +5767,7 @@ ${code}`;
     generateHandlerCode(rawEvent, handler) {
       const modifiers = rawEvent.split(".").slice(1).map((m) => {
         if (!MODS.has(m)) {
-          throw new OwlError2(`Unknown event modifier: '${m}'`);
+          throw new OwlError(`Unknown event modifier: '${m}'`);
         }
         return `"${m}"`;
       });
@@ -6669,7 +6318,7 @@ ${code}`;
           case "translate":
             break;
           default:
-            throw new OwlError2(`Invalid prop suffix: ${suffix}`);
+            throw new OwlError(`Invalid prop suffix: ${suffix}`);
         }
       }
       name = /^[a-z_]+$/i.test(name) ? name : `'${name}'`;
@@ -6885,7 +6534,7 @@ ${code}`;
     } catch (originalError) {
       const { name } = options;
       const nameStr = name ? `template "${name}"` : "anonymous template";
-      const err = new OwlError2(
+      const err = new OwlError(
         `Failed to compile ${nameStr}: ${originalError.message}
 
 generated code: