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

package/dist/owl.es.js

@@ -1,5 +1,4 @@
-// ../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;
 };
@@ -17,7 +16,7 @@ function batched(callback) {
   return function batchedCall(...args) {
     if (!scheduled) {
       scheduled = true;
-      queueMicrotask(() => {
+      Promise.resolve().then(() => {
         scheduled = false;
         callback(...args);
       });
@@ -65,10 +64,11 @@ function onWriteAtom(atom) {
 }
 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;
@@ -87,6 +87,9 @@ function updateComputation(computation) {
         continue;
       }
       updateComputation(source);
+      if (computation.state === 1) {
+        break;
+      }
     }
     if (computation.state !== 1) {
       computation.state = 0;
@@ -96,15 +99,18 @@ function updateComputation(computation) {
   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();
 }
@@ -368,10 +374,10 @@ function proxifyTarget(target, atom) {
   } 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);
@@ -553,11 +559,11 @@ function buildSignal(value, set) {
   };
   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));
@@ -1183,6 +1189,9 @@ function startPlugins(manager, plugins) {
     );
   }
 }
+
+// ../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) {
@@ -1238,12 +1247,7 @@ function handleError(params) {
       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) {
@@ -2963,8 +2967,9 @@ var Fiber = class {
         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) {
@@ -3170,7 +3175,6 @@ var ComponentNode = class extends Scope {
       setComputation(prev);
       await Promise.all(promises);
     } catch (e) {
-      setComputation(prev);
       if (isAbortError(e) && this.status > STATUS.MOUNTED) {
         return;
       }
@@ -3524,7 +3528,10 @@ function createRef(ref2) {
     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`
@@ -3618,12 +3625,13 @@ function createComponent(app, name, isStatic, hasSlotsProp, hasDynamicPropList,
         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];
               }
             }
           }
@@ -3631,7 +3639,7 @@ function createComponent(app, name, isStatic, hasSlotsProp, hasDynamicPropList,
           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);
             }
@@ -3751,9 +3759,7 @@ var TemplateSet = class {
         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`);
@@ -3810,6 +3816,17 @@ function xml(...args) {
   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") {
@@ -4069,6 +4086,9 @@ function props(type, defaults) {
     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})`);
       });
@@ -4289,396 +4309,12 @@ var blockDom = {
 };
 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(
   ","
 );
@@ -4716,14 +4352,14 @@ var tokenizeString = function(expr) {
       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 === "`") {
@@ -4815,19 +4451,25 @@ function tokenize(expr) {
     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];
@@ -4843,6 +4485,10 @@ function processExpr(expr) {
       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) {
@@ -4861,9 +4507,14 @@ function processExpr(expr) {
       }
     }
     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;
       }
@@ -4871,31 +4522,29 @@ function processExpr(expr) {
         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 = [];
@@ -4911,8 +4560,8 @@ function processExpr(expr) {
   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) {
@@ -4954,7 +4603,7 @@ ${"-".repeat(columnIndex - 1)}^`;
         }
       }
     }
-    throw new OwlError2(msg);
+    throw new OwlError(msg);
   }
   return doc;
 }
@@ -5033,13 +4682,13 @@ function parseTCustom(node, ctx) {
   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);
@@ -5047,7 +4696,7 @@ function parseTCustom(node, ctx) {
       try {
         customDirective(node, value, modifiers);
       } catch (error) {
-        throw new OwlError2(
+        throw new OwlError(
           `Custom directive "${directiveName}" throw the following error: ${error}`
         );
       }
@@ -5094,7 +4743,7 @@ function parseDOMNode(node, ctx) {
     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") {
@@ -5111,14 +4760,14 @@ function parseDOMNode(node, ctx) {
   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>"
         );
       }
@@ -5147,7 +4796,7 @@ function parseDOMNode(node, ctx) {
         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-")) {
@@ -5156,7 +4805,7 @@ function parseDOMNode(node, ctx) {
       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)) {
@@ -5223,7 +4872,7 @@ function parseTForEach(node, ctx) {
   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}")`
     );
   }
@@ -5272,7 +4921,7 @@ function parseTCall(node, ctx) {
     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}>)`
     );
   }
@@ -5376,7 +5025,7 @@ function parseComponent(node, ctx) {
   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}>)`
     );
   }
@@ -5406,7 +5055,7 @@ function parseComponent(node, ctx) {
         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 || {};
@@ -5419,7 +5068,7 @@ function parseComponent(node, ctx) {
     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}>)`
         );
       }
@@ -5606,24 +5255,24 @@ function normalizeTIf(el) {
     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"
       );
     }
@@ -5635,7 +5284,7 @@ function normalizeTOut(el) {
   );
   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");
@@ -6042,7 +5691,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}"`;
     });
@@ -6593,7 +6242,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}'`;
@@ -6809,7 +6458,7 @@ function compile(template, options = {
   } 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: