@odoo/owl 2.8.1 → 3.0.0-alpha.10

package/dist/compile_templates.mjs

@@ -250,7 +250,7 @@ function compileExprToArray(expr) {
                 stack.pop();
         }
         let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
-        if (token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value)) {
+        if (isVar) {
             if (prevToken) {
                 // normalize missing tokens: {a} should be equivalent to {a:a}
                 if (groupType === "LEFT_BRACE" &&
@@ -442,7 +442,6 @@ class CodeTarget {
         this.hasRoot = false;
         this.hasCache = false;
         this.shouldProtectScope = false;
-        this.hasRefWrapper = false;
         this.name = name;
         this.on = on || null;
     }
@@ -462,9 +461,6 @@ class CodeTarget {
             result.push(`  ctx = Object.create(ctx);`);
             result.push(`  ctx[isBoundary] = 1`);
         }
-        if (this.hasRefWrapper) {
-            result.push(`  let refWrapper = makeRefWrapper(this.__owl__);`);
-        }
         if (this.hasCache) {
             result.push(`  let cache = ctx.cache || {};`);
             result.push(`  let nextCache = ctx.cache = {};`);
@@ -531,7 +527,7 @@ class CodeGenerator {
     }
     generateCode() {
         const ast = this.ast;
-        this.isDebug = ast.type === 12 /* TDebug */;
+        this.isDebug = ast.type === 11 /* ASTType.TDebug */;
         BlockDescription.nextBlockId = 1;
         nextDataIds = {};
         this.compileAST(ast, {
@@ -687,43 +683,41 @@ class CodeGenerator {
      */
     compileAST(ast, ctx) {
         switch (ast.type) {
-            case 1 /* Comment */:
+            case 1 /* ASTType.Comment */:
                 return this.compileComment(ast, ctx);
-            case 0 /* Text */:
+            case 0 /* ASTType.Text */:
                 return this.compileText(ast, ctx);
-            case 2 /* DomNode */:
+            case 2 /* ASTType.DomNode */:
                 return this.compileTDomNode(ast, ctx);
-            case 4 /* TEsc */:
-                return this.compileTEsc(ast, ctx);
-            case 8 /* TOut */:
+            case 7 /* ASTType.TOut */:
                 return this.compileTOut(ast, ctx);
-            case 5 /* TIf */:
+            case 4 /* ASTType.TIf */:
                 return this.compileTIf(ast, ctx);
-            case 9 /* TForEach */:
+            case 8 /* ASTType.TForEach */:
                 return this.compileTForeach(ast, ctx);
-            case 10 /* TKey */:
+            case 9 /* ASTType.TKey */:
                 return this.compileTKey(ast, ctx);
-            case 3 /* Multi */:
+            case 3 /* ASTType.Multi */:
                 return this.compileMulti(ast, ctx);
-            case 7 /* TCall */:
+            case 6 /* ASTType.TCall */:
                 return this.compileTCall(ast, ctx);
-            case 15 /* TCallBlock */:
+            case 14 /* ASTType.TCallBlock */:
                 return this.compileTCallBlock(ast, ctx);
-            case 6 /* TSet */:
+            case 5 /* ASTType.TSet */:
                 return this.compileTSet(ast, ctx);
-            case 11 /* TComponent */:
+            case 10 /* ASTType.TComponent */:
                 return this.compileComponent(ast, ctx);
-            case 12 /* TDebug */:
+            case 11 /* ASTType.TDebug */:
                 return this.compileDebug(ast, ctx);
-            case 13 /* TLog */:
+            case 12 /* ASTType.TLog */:
                 return this.compileLog(ast, ctx);
-            case 14 /* TSlot */:
-                return this.compileTSlot(ast, ctx);
-            case 16 /* TTranslation */:
+            case 13 /* ASTType.TCallSlot */:
+                return this.compileTCallSlot(ast, ctx);
+            case 15 /* ASTType.TTranslation */:
                 return this.compileTTranslation(ast, ctx);
-            case 17 /* TTranslationContext */:
+            case 16 /* ASTType.TTranslationContext */:
                 return this.compileTTranslationContext(ast, ctx);
-            case 18 /* TPortal */:
+            case 17 /* ASTType.TPortal */:
                 return this.compileTPortal(ast, ctx);
         }
     }
@@ -774,7 +768,7 @@ class CodeGenerator {
             });
         }
         else {
-            const createFn = ast.type === 0 /* Text */ ? xmlDoc.createTextNode : xmlDoc.createComment;
+            const createFn = ast.type === 0 /* ASTType.Text */ ? xmlDoc.createTextNode : xmlDoc.createComment;
             block.insert(createFn.call(xmlDoc, value));
         }
         return block.varName;
@@ -868,14 +862,11 @@ class CodeGenerator {
         // t-model
         let tModelSelectedExpr;
         if (ast.model) {
-            const { hasDynamicChildren, baseExpr, expr, eventType, shouldNumberize, shouldTrim, targetAttr, specialInitTargetAttr, } = ast.model;
-            const baseExpression = compileExpr(baseExpr);
-            const bExprId = generateId("bExpr");
-            this.define(bExprId, baseExpression);
+            const { hasDynamicChildren, expr, eventType, shouldNumberize, shouldTrim, targetAttr, specialInitTargetAttr, } = ast.model;
             const expression = compileExpr(expr);
             const exprId = generateId("expr");
-            this.define(exprId, expression);
-            const fullExpression = `${bExprId}[${exprId}]`;
+            this.helpers.add("modelExpr");
+            this.define(exprId, `modelExpr(${expression})`);
             let idx;
             if (specialInitTargetAttr) {
                 let targetExpr = targetAttr in attrs && `'${attrs[targetAttr]}'`;
@@ -886,23 +877,23 @@ class CodeGenerator {
                         targetExpr = compileExpr(dynamicTgExpr);
                     }
                 }
-                idx = block.insertData(`${fullExpression} === ${targetExpr}`, "prop");
+                idx = block.insertData(`${exprId}() === ${targetExpr}`, "prop");
                 attrs[`block-property-${idx}`] = specialInitTargetAttr;
             }
             else if (hasDynamicChildren) {
                 const bValueId = generateId("bValue");
                 tModelSelectedExpr = `${bValueId}`;
-                this.define(tModelSelectedExpr, fullExpression);
+                this.define(tModelSelectedExpr, `${exprId}()`);
             }
             else {
-                idx = block.insertData(`${fullExpression}`, "prop");
+                idx = block.insertData(`${exprId}()`, "prop");
                 attrs[`block-property-${idx}`] = targetAttr;
             }
             this.helpers.add("toNumber");
             let valueCode = `ev.target.${targetAttr}`;
             valueCode = shouldTrim ? `${valueCode}.trim()` : valueCode;
             valueCode = shouldNumberize ? `toNumber(${valueCode})` : valueCode;
-            const handler = `[(ev) => { ${fullExpression} = ${valueCode}; }]`;
+            const handler = `[(ev) => { ${exprId}.set(${valueCode}); }]`;
             idx = block.insertData(handler, "hdlr");
             attrs[`block-handler-${idx}`] = eventType;
         }
@@ -914,19 +905,9 @@ class CodeGenerator {
         }
         // t-ref
         if (ast.ref) {
-            if (this.dev) {
-                this.helpers.add("makeRefWrapper");
-                this.target.hasRefWrapper = true;
-            }
-            const isDynamic = INTERP_REGEXP.test(ast.ref);
-            let name = `\`${ast.ref}\``;
-            if (isDynamic) {
-                name = replaceDynamicParts(ast.ref, (expr) => this.captureExpression(expr, true));
-            }
-            let setRefStr = `(el) => this.__owl__.setRef((${name}), el)`;
-            if (this.dev) {
-                setRefStr = `refWrapper(${name}, ${setRefStr})`;
-            }
+            const refExpr = compileExpr(ast.ref);
+            this.helpers.add("createRef");
+            const setRefStr = `createRef(${refExpr})`;
             const idx = block.insertData(setRefStr, "ref");
             attrs["block-ref"] = String(idx);
         }
@@ -980,32 +961,6 @@ class CodeGenerator {
         }
         return block.varName;
     }
-    compileTEsc(ast, ctx) {
-        let { block, forceNewBlock } = ctx;
-        let expr;
-        if (ast.expr === "0") {
-            this.helpers.add("zero");
-            expr = `ctx[zero]`;
-        }
-        else {
-            expr = compileExpr(ast.expr);
-            if (ast.defaultValue) {
-                this.helpers.add("withDefault");
-                // FIXME: defaultValue is not translated
-                expr = `withDefault(${expr}, ${toStringExpression(ast.defaultValue)})`;
-            }
-        }
-        if (!block || forceNewBlock) {
-            block = this.createBlock(block, "text", ctx);
-            this.insertBlock(`text(${expr})`, block, { ...ctx, forceNewBlock: forceNewBlock && !block });
-        }
-        else {
-            const idx = block.insertData(expr, "txt");
-            const text = xmlDoc.createElement(`block-text-${idx}`);
-            block.insert(text);
-        }
-        return block.varName;
-    }
     compileTOut(ast, ctx) {
         let { block } = ctx;
         if (block) {
@@ -1021,7 +976,7 @@ class CodeGenerator {
             let bodyValue = null;
             bodyValue = BlockDescription.nextBlockId;
             const subCtx = createContext(ctx);
-            this.compileAST({ type: 3 /* Multi */, content: ast.body }, subCtx);
+            this.compileAST({ type: 3 /* ASTType.Multi */, content: ast.body }, subCtx);
             this.helpers.add("safeOutput");
             blockStr = `safeOutput(${compileExpr(ast.expr)}, b${bodyValue})`;
         }
@@ -1226,7 +1181,7 @@ class CodeGenerator {
         let ctxVar = ctx.ctxVar || "ctx";
         if (ast.context) {
             ctxVar = generateId("ctx");
-            this.addLine(`let ${ctxVar} = ${compileExpr(ast.context)};`);
+            this.addLine(`let ${ctxVar} = {this: ${compileExpr(ast.context)}, __owl__: this.__owl__};`);
         }
         const isDynamic = INTERP_REGEXP.test(ast.name);
         const subTemplate = isDynamic ? interpolate(ast.name) : "`" + ast.name + "`";
@@ -1239,7 +1194,7 @@ class CodeGenerator {
             this.addLine(`${ctxVar}[isBoundary] = 1;`);
             this.helpers.add("isBoundary");
             const subCtx = createContext(ctx, { ctxVar });
-            const bl = this.compileMulti({ type: 3 /* Multi */, content: ast.body }, subCtx);
+            const bl = this.compileMulti({ type: 3 /* ASTType.Multi */, content: ast.body }, subCtx);
             if (bl) {
                 this.helpers.add("zero");
                 this.addLine(`${ctxVar}[zero] = ${bl};`);
@@ -1287,7 +1242,7 @@ class CodeGenerator {
         const expr = ast.value ? compileExpr(ast.value || "") : "null";
         if (ast.body) {
             this.helpers.add("LazyValue");
-            const bodyAst = { type: 3 /* Multi */, content: ast.body };
+            const bodyAst = { type: 3 /* ASTType.Multi */, content: ast.body };
             const name = this.compileInNewTarget("value", bodyAst, ctx);
             let key = this.target.currentKey(ctx);
             let value = `new LazyValue(${name}, ctx, this, node, ${key})`;
@@ -1426,9 +1381,6 @@ class CodeGenerator {
         else {
             expr = `\`${ast.name}\``;
         }
-        if (this.dev) {
-            this.addLine(`helpers.validateProps(${expr}, ${propVar}, this);`);
-        }
         if (block && (ctx.forceNewBlock === false || ctx.tKeyExpr)) {
             // todo: check the forcenewblock condition
             this.insertAnchor(block);
@@ -1483,7 +1435,7 @@ class CodeGenerator {
         this.staticDefs.push({ id: name, expr: `createCatcher(${JSON.stringify(spec)})` });
         return `${name}(${expr}, [${handlers.join(",")}])`;
     }
-    compileTSlot(ast, ctx) {
+    compileTCallSlot(ast, ctx) {
         this.helpers.add("callSlot");
         let { block } = ctx;
         let blockString;
@@ -1636,7 +1588,7 @@ function parse(xml, customDir) {
 }
 function _parse(xml, ctx) {
     normalizeXML(xml);
-    return parseNode(xml, ctx) || { type: 0 /* Text */, value: "" };
+    return parseNode(xml, ctx) || { type: 0 /* ASTType.Text */, value: "" };
 }
 function parseNode(node, ctx) {
     if (!(node instanceof Element)) {
@@ -1652,9 +1604,8 @@ function parseNode(node, ctx) {
         parseTTranslation(node, ctx) ||
         parseTTranslationContext(node, ctx) ||
         parseTKey(node, ctx) ||
-        parseTEscNode(node, ctx) ||
         parseTOutNode(node, ctx) ||
-        parseTSlot(node, ctx) ||
+        parseTCallSlot(node, ctx) ||
         parseComponent(node, ctx) ||
         parseDOMNode(node, ctx) ||
         parseTSetNode(node, ctx) ||
@@ -1679,10 +1630,10 @@ function parseTextCommentNode(node, ctx) {
         if (!ctx.inPreTag && lineBreakRE.test(value) && !value.trim()) {
             return null;
         }
-        return { type: 0 /* Text */, value };
+        return { type: 0 /* ASTType.Text */, value };
     }
     else if (node.nodeType === Node.COMMENT_NODE) {
-        return { type: 1 /* Comment */, value: node.textContent || "" };
+        return { type: 1 /* ASTType.Comment */, value: node.textContent || "" };
     }
     return null;
 }
@@ -1723,7 +1674,7 @@ function parseTDebugLog(node, ctx) {
         node.removeAttribute("t-debug");
         const content = parseNode(node, ctx);
         const ast = {
-            type: 12 /* TDebug */,
+            type: 11 /* ASTType.TDebug */,
             content,
         };
         if (content === null || content === void 0 ? void 0 : content.hasNoRepresentation) {
@@ -1736,7 +1687,7 @@ function parseTDebugLog(node, ctx) {
         node.removeAttribute("t-log");
         const content = parseNode(node, ctx);
         const ast = {
-            type: 13 /* TLog */,
+            type: 12 /* ASTType.TLog */,
             expr,
             content,
         };
@@ -1750,8 +1701,6 @@ function parseTDebugLog(node, ctx) {
 // -----------------------------------------------------------------------------
 // Regular dom node
 // -----------------------------------------------------------------------------
-const hasDotAtTheEnd = /\.[\w_]+\s*$/;
-const hasBracketsAtTheEnd = /\[[^\[]+\]\s*$/;
 const ROOT_SVG_TAGS = new Set(["svg", "g", "path"]);
 function parseDOMNode(node, ctx) {
     const { tagName } = node;
@@ -1788,20 +1737,6 @@ function parseDOMNode(node, ctx) {
             if (!["input", "select", "textarea"].includes(tagName)) {
                 throw new OwlError("The t-model directive only works with <input>, <textarea> and <select>");
             }
-            let baseExpr, expr;
-            if (hasDotAtTheEnd.test(value)) {
-                const index = value.lastIndexOf(".");
-                baseExpr = value.slice(0, index);
-                expr = `'${value.slice(index + 1)}'`;
-            }
-            else if (hasBracketsAtTheEnd.test(value)) {
-                const index = value.lastIndexOf("[");
-                baseExpr = value.slice(0, index);
-                expr = value.slice(index + 1, -1);
-            }
-            else {
-                throw new OwlError(`Invalid t-model expression: "${value}" (it should be assignable)`);
-            }
             const typeAttr = node.getAttribute("type");
             const isInput = tagName === "input";
             const isSelect = tagName === "select";
@@ -1812,8 +1747,7 @@ function parseDOMNode(node, ctx) {
             const hasNumberMod = attr.includes(".number");
             const eventType = isRadioInput ? "click" : isSelect || hasLazyMod ? "change" : "input";
             model = {
-                baseExpr,
-                expr,
+                expr: value,
                 targetAttr: isCheckboxInput ? "checked" : "value",
                 specialInitTargetAttr: isRadioInput ? "checked" : null,
                 eventType,
@@ -1855,7 +1789,7 @@ function parseDOMNode(node, ctx) {
     }
     const children = parseChildren(node, ctx);
     return {
-        type: 2 /* DomNode */,
+        type: 2 /* ASTType.DomNode */,
         tag: tagName,
         dynamicTag,
         attrs,
@@ -1868,55 +1802,26 @@ function parseDOMNode(node, ctx) {
     };
 }
 // -----------------------------------------------------------------------------
-// t-esc
-// -----------------------------------------------------------------------------
-function parseTEscNode(node, ctx) {
-    if (!node.hasAttribute("t-esc")) {
-        return null;
-    }
-    const escValue = node.getAttribute("t-esc");
-    node.removeAttribute("t-esc");
-    const tesc = {
-        type: 4 /* TEsc */,
-        expr: escValue,
-        defaultValue: node.textContent || "",
-    };
-    let ref = node.getAttribute("t-ref");
-    node.removeAttribute("t-ref");
-    const ast = parseNode(node, ctx);
-    if (!ast) {
-        return tesc;
-    }
-    if (ast.type === 2 /* DomNode */) {
-        return {
-            ...ast,
-            ref,
-            content: [tesc],
-        };
-    }
-    return tesc;
-}
-// -----------------------------------------------------------------------------
 // t-out
 // -----------------------------------------------------------------------------
 function parseTOutNode(node, ctx) {
-    if (!node.hasAttribute("t-out") && !node.hasAttribute("t-raw")) {
+    if (!node.hasAttribute("t-out") && !node.hasAttribute("t-esc")) {
         return null;
     }
-    if (node.hasAttribute("t-raw")) {
-        console.warn(`t-raw has been deprecated in favor of t-out. If the value to render is not wrapped by the "markup" function, it will be escaped`);
+    if (node.hasAttribute("t-esc")) {
+        console.warn(`t-esc has been deprecated in favor of t-out. If the value to render is not wrapped by the "markup" function, it will be escaped`);
     }
-    const expr = (node.getAttribute("t-out") || node.getAttribute("t-raw"));
+    const expr = (node.getAttribute("t-out") || node.getAttribute("t-esc"));
     node.removeAttribute("t-out");
-    node.removeAttribute("t-raw");
-    const tOut = { type: 8 /* TOut */, expr, body: null };
+    node.removeAttribute("t-esc");
+    const tOut = { type: 7 /* ASTType.TOut */, expr, body: null };
     const ref = node.getAttribute("t-ref");
     node.removeAttribute("t-ref");
     const ast = parseNode(node, ctx);
     if (!ast) {
         return tOut;
     }
-    if (ast.type === 2 /* DomNode */) {
+    if (ast.type === 2 /* ASTType.DomNode */) {
         tOut.body = ast.content.length ? ast.content : null;
         return {
             ...ast,
@@ -1955,7 +1860,7 @@ function parseTForEach(node, ctx) {
     const hasNoIndex = hasNoTCall && !html.includes(`${elem}_index`);
     const hasNoValue = hasNoTCall && !html.includes(`${elem}_value`);
     return {
-        type: 9 /* TForEach */,
+        type: 8 /* ASTType.TForEach */,
         collection,
         elem,
         body,
@@ -1978,7 +1883,7 @@ function parseTKey(node, ctx) {
         return null;
     }
     const ast = {
-        type: 10 /* TKey */,
+        type: 9 /* ASTType.TKey */,
         expr: key,
         content,
     };
@@ -2000,12 +1905,12 @@ function parseTCall(node, ctx) {
     node.removeAttribute("t-call-context");
     if (node.tagName !== "t") {
         const ast = parseNode(node, ctx);
-        const tcall = { type: 7 /* TCall */, name: subTemplate, body: null, context };
-        if (ast && ast.type === 2 /* DomNode */) {
+        const tcall = { type: 6 /* ASTType.TCall */, name: subTemplate, body: null, context };
+        if (ast && ast.type === 2 /* ASTType.DomNode */) {
             ast.content = [tcall];
             return ast;
         }
-        if (ast && ast.type === 11 /* TComponent */) {
+        if (ast && ast.type === 10 /* ASTType.TComponent */) {
             return {
                 ...ast,
                 slots: {
@@ -2022,7 +1927,7 @@ function parseTCall(node, ctx) {
     }
     const body = parseChildren(node, ctx);
     return {
-        type: 7 /* TCall */,
+        type: 6 /* ASTType.TCall */,
         name: subTemplate,
         body: body.length ? body : null,
         context,
@@ -2037,7 +1942,7 @@ function parseTCallBlock(node, ctx) {
     }
     const name = node.getAttribute("t-call-block");
     return {
-        type: 15 /* TCallBlock */,
+        type: 14 /* ASTType.TCallBlock */,
         name,
     };
 }
@@ -2050,7 +1955,7 @@ function parseTIf(node, ctx) {
     }
     const condition = node.getAttribute("t-if");
     node.removeAttribute("t-if");
-    const content = parseNode(node, ctx) || { type: 0 /* Text */, value: "" };
+    const content = parseNode(node, ctx) || { type: 0 /* ASTType.Text */, value: "" };
     let nextElement = node.nextElementSibling;
     // t-elifs
     const tElifs = [];
@@ -2073,7 +1978,7 @@ function parseTIf(node, ctx) {
         nextElement.remove();
     }
     return {
-        type: 5 /* TIf */,
+        type: 4 /* ASTType.TIf */,
         condition,
         content,
         tElif: tElifs.length ? tElifs : null,
@@ -2094,7 +1999,7 @@ function parseTSetNode(node, ctx) {
     if (node.textContent !== node.innerHTML) {
         body = parseChildren(node, ctx);
     }
-    return { type: 6 /* TSet */, name, value, defaultValue, body, hasNoRepresentation: true };
+    return { type: 5 /* ASTType.TSet */, name, value, defaultValue, body, hasNoRepresentation: true };
 }
 // -----------------------------------------------------------------------------
 // Components
@@ -2223,7 +2128,7 @@ function parseComponent(node, ctx) {
         }
     }
     return {
-        type: 11 /* TComponent */,
+        type: 10 /* ASTType.TComponent */,
         name,
         isDynamic,
         dynamicProps,
@@ -2236,12 +2141,12 @@ function parseComponent(node, ctx) {
 // -----------------------------------------------------------------------------
 // Slots
 // -----------------------------------------------------------------------------
-function parseTSlot(node, ctx) {
-    if (!node.hasAttribute("t-slot")) {
+function parseTCallSlot(node, ctx) {
+    if (!node.hasAttribute("t-call-slot")) {
         return null;
     }
-    const name = node.getAttribute("t-slot");
-    node.removeAttribute("t-slot");
+    const name = node.getAttribute("t-call-slot");
+    node.removeAttribute("t-call-slot");
     let attrs = null;
     let attrsTranslationCtx = null;
     let on = null;
@@ -2262,7 +2167,7 @@ function parseTSlot(node, ctx) {
         }
     }
     return {
-        type: 14 /* TSlot */,
+        type: 13 /* ASTType.TCallSlot */,
         name,
         attrs,
         attrsTranslationCtx,
@@ -2274,7 +2179,7 @@ function parseTSlot(node, ctx) {
 // Translation
 // -----------------------------------------------------------------------------
 function wrapInTTranslationAST(r) {
-    const ast = { type: 16 /* TTranslation */, content: r };
+    const ast = { type: 15 /* ASTType.TTranslation */, content: r };
     if (r === null || r === void 0 ? void 0 : r.hasNoRepresentation) {
         ast.hasNoRepresentation = true;
     }
@@ -2286,7 +2191,7 @@ function parseTTranslation(node, ctx) {
     }
     node.removeAttribute("t-translation");
     const result = parseNode(node, ctx);
-    if ((result === null || result === void 0 ? void 0 : result.type) === 3 /* Multi */) {
+    if ((result === null || result === void 0 ? void 0 : result.type) === 3 /* ASTType.Multi */) {
         const children = result.content.map(wrapInTTranslationAST);
         return makeASTMulti(children);
     }
@@ -2297,7 +2202,7 @@ function parseTTranslation(node, ctx) {
 // -----------------------------------------------------------------------------
 function wrapInTTranslationContextAST(r, translationCtx) {
     const ast = {
-        type: 17 /* TTranslationContext */,
+        type: 16 /* ASTType.TTranslationContext */,
         content: r,
         translationCtx,
     };
@@ -2313,7 +2218,7 @@ function parseTTranslationContext(node, ctx) {
     }
     node.removeAttribute("t-translation-context");
     const result = parseNode(node, ctx);
-    if ((result === null || result === void 0 ? void 0 : result.type) === 3 /* Multi */) {
+    if ((result === null || result === void 0 ? void 0 : result.type) === 3 /* ASTType.Multi */) {
         const children = result.content.map((c) => wrapInTTranslationContextAST(c, translationCtx));
         return makeASTMulti(children);
     }
@@ -2331,12 +2236,12 @@ function parseTPortal(node, ctx) {
     const content = parseNode(node, ctx);
     if (!content) {
         return {
-            type: 0 /* Text */,
+            type: 0 /* ASTType.Text */,
             value: "",
         };
     }
     return {
-        type: 18 /* TPortal */,
+        type: 17 /* ASTType.TPortal */,
         target,
         content,
     };
@@ -2352,7 +2257,7 @@ function parseChildren(node, ctx) {
     for (let child of node.childNodes) {
         const childAst = parseNode(child, ctx);
         if (childAst) {
-            if (childAst.type === 3 /* Multi */) {
+            if (childAst.type === 3 /* ASTType.Multi */) {
                 children.push(...childAst.content);
             }
             else {
@@ -2363,7 +2268,7 @@ function parseChildren(node, ctx) {
     return children;
 }
 function makeASTMulti(children) {
-    const ast = { type: 3 /* Multi */, content: children };
+    const ast = { type: 3 /* ASTType.Multi */, content: children };
     if (children.every((c) => c.hasNoRepresentation)) {
         ast.hasNoRepresentation = true;
     }
@@ -2424,28 +2329,26 @@ function normalizeTIf(el) {
     }
 }
 /**
- * Normalizes the content of an Element so that t-esc directives on components
- * are removed and instead places a <t t-esc=""> as the default slot of the
+ * Normalizes the content of an Element so that t-out directives on components
+ * are removed and instead places a <t t-out=""> as the default slot of the
  * component. Also throws if the component already has content. This function
  * modifies the Element in place.
  *
  * @param el the element containing the tree that should be normalized
  */
-function normalizeTEscTOut(el) {
-    for (const d of ["t-esc", "t-out"]) {
-        const elements = [...el.querySelectorAll(`[${d}]`)].filter((el) => el.tagName[0] === el.tagName[0].toUpperCase() || el.hasAttribute("t-component"));
-        for (const el of elements) {
-            if (el.childNodes.length) {
-                throw new OwlError(`Cannot have ${d} on a component that already has content`);
-            }
-            const value = el.getAttribute(d);
-            el.removeAttribute(d);
-            const t = el.ownerDocument.createElement("t");
-            if (value != null) {
-                t.setAttribute(d, value);
-            }
-            el.appendChild(t);
+function normalizeTOut(el) {
+    const elements = [...el.querySelectorAll(`[t-out]`)].filter((el) => el.tagName[0] === el.tagName[0].toUpperCase() || el.hasAttribute("t-component"));
+    for (const el of elements) {
+        if (el.childNodes.length) {
+            throw new OwlError(`Cannot have t-out on a component that already has content`);
+        }
+        const value = el.getAttribute("t-out");
+        el.removeAttribute("t-out");
+        const t = el.ownerDocument.createElement("t");
+        if (value != null) {
+            t.setAttribute("t-out", value);
         }
+        el.appendChild(t);
     }
 }
 /**
@@ -2456,7 +2359,7 @@ function normalizeTEscTOut(el) {
  */
 function normalizeXML(el) {
     normalizeTIf(el);
-    normalizeTEscTOut(el);
+    normalizeTOut(el);
 }
 
 function compile(template, options = {
@@ -2467,7 +2370,7 @@ function compile(template, options = {
     // some work
     const hasSafeContext = template instanceof Node
         ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
-        : !template.includes("t-set") && !template.includes("t-call");
+        : !template.includes("t-set=") && !template.includes("t-call=");
     // code generation
     const codeGenerator = new CodeGenerator(ast, { ...options, hasSafeContext });
     const code = codeGenerator.generateCode();