@optionfactory/fml 8.0.2 → 9.0.0-rc1

package/dist/ftl.iife.js

@@ -1,6 +1,46 @@
 var ftl = (function (exports) {
     'use strict';
 
+    /**
+     * A Map bounded by entry count, evicting in insertion order: not an LRU (a hit
+     * does not refresh an entry), just a cap keeping unbounded key spaces (parsed
+     * expressions, compiled masks, formatter instances) from growing forever. The
+     * capacity is sized so eviction never happens on a sane page: hitting it means
+     * dynamically generated keys, where FIFO's worst case (evicting a hot entry)
+     * costs one recomputation.
+     */
+    class BoundedCache {
+        #max;
+        #entries = new Map();
+        /** @param {number} max */
+        constructor(max) {
+            this.#max = max;
+        }
+        /**
+         * The cached value for the key, computing and caching it on a miss. A
+         * computed null or undefined is cached like any value; a throwing compute
+         * caches nothing.
+         * @template K, V
+         * @param {K} key
+         * @param {(key: K) => V} compute
+         * @returns {V}
+         */
+        getOrCompute(key, compute) {
+            if (this.#entries.has(key)) {
+                return this.#entries.get(key);
+            }
+            const value = compute(key);
+            if (this.#entries.size >= this.#max) {
+                this.#entries.delete(this.#entries.keys().next().value);
+            }
+            this.#entries.set(key, value);
+            return value;
+        }
+        get size() {
+            return this.#entries.size;
+        }
+    }
+
     const nodes = {
         ter: Symbol('ternary'),
         elv: Symbol('elvis'),
@@ -38,6 +78,16 @@ var ftl = (function (exports) {
     //
     // https://peggyjs.org/
 
+        //keyword classification lives here, not in the grammar's ordered choice: the
+        //identifier rule consumes the whole word and the action decides, so no keyword
+        //can grab a longer identifier's prefix. A Map, not a plain object: `in` on the
+        //latter would classify inherited names such as `constructor` as keywords
+        const keywords = new Map([
+            ['true', true],
+            ['false', false],
+            ['null', null],
+            ['undefined', undefined],
+        ]);
 
     class peg$SyntaxError extends SyntaxError {
       constructor(message, expected, found, location) {
@@ -222,22 +272,18 @@ var ftl = (function (exports) {
       const peg$c32 = "(";
       const peg$c34 = ",";
       const peg$c36 = ")";
-      const peg$c39 = "true";
-      const peg$c40 = "false";
-      const peg$c41 = "null";
-      const peg$c42 = "undefined";
-      const peg$c43 = "-";
-      const peg$c44 = "'";
-      const peg$c45 = "\"";
-      const peg$c46 = "`";
-      const peg$c47 = "}";
-      const peg$c49 = "#";
-      const peg$c53 = "==";
-      const peg$c54 = "!=";
-      const peg$c55 = ">=";
-      const peg$c56 = ">";
-      const peg$c57 = "<=";
-      const peg$c58 = "<";
+      const peg$c39 = "-";
+      const peg$c40 = "'";
+      const peg$c41 = "\"";
+      const peg$c42 = "`";
+      const peg$c43 = "}";
+      const peg$c45 = "#";
+      const peg$c49 = "==";
+      const peg$c50 = "!=";
+      const peg$c51 = ">=";
+      const peg$c52 = ">";
+      const peg$c53 = "<=";
+      const peg$c54 = "<";
 
       const peg$r0 = /^[^\\{]/;
       const peg$r1 = /^[0-9]/;
@@ -245,7 +291,7 @@ var ftl = (function (exports) {
       const peg$r3 = /^[^"]/;
       const peg$r4 = /^[^\\`{]/;
       const peg$r5 = /^[a-zA-Z$_]/;
-      const peg$r6 = /^[a-zA-Z$_0-9_]/;
+      const peg$r6 = /^[a-zA-Z$_0-9]/;
       const peg$r7 = /^[ \t\n\r]/;
 
       const peg$e0 = peg$literalExpectation("{{{{", false);
@@ -276,40 +322,33 @@ var ftl = (function (exports) {
       const peg$e25 = peg$literalExpectation(",", false);
       const peg$e26 = peg$literalExpectation(")", false);
       const peg$e27 = peg$otherExpectation("module-function-call");
-      const peg$e28 = peg$otherExpectation("boolean-literal");
-      const peg$e29 = peg$literalExpectation("true", false);
-      const peg$e30 = peg$literalExpectation("false", false);
-      const peg$e31 = peg$otherExpectation("null-literal");
-      const peg$e32 = peg$literalExpectation("null", false);
-      const peg$e33 = peg$otherExpectation("undefined-literal");
-      const peg$e34 = peg$literalExpectation("undefined", false);
-      const peg$e35 = peg$otherExpectation("number-literal");
-      const peg$e36 = peg$literalExpectation("-", false);
-      const peg$e37 = peg$classExpectation([["0", "9"]], false, false, false);
-      const peg$e38 = peg$otherExpectation("string-literal");
-      const peg$e39 = peg$literalExpectation("'", false);
-      const peg$e40 = peg$classExpectation(["'"], true, false, false);
-      const peg$e41 = peg$literalExpectation("\"", false);
-      const peg$e42 = peg$classExpectation(["\""], true, false, false);
-      const peg$e43 = peg$literalExpectation("`", false);
-      const peg$e44 = peg$otherExpectation("tstring-expression");
-      const peg$e45 = peg$literalExpectation("}", false);
-      const peg$e46 = peg$otherExpectation("tstring-literal");
-      const peg$e47 = peg$classExpectation(["\\", "`", "{"], true, false, false);
-      const peg$e48 = peg$otherExpectation("array-literal");
-      const peg$e49 = peg$otherExpectation("dict-literal");
-      const peg$e50 = peg$otherExpectation("module-function");
-      const peg$e51 = peg$literalExpectation("#", false);
-      const peg$e52 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_"], false, false, false);
-      const peg$e53 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_", ["0", "9"], "_"], false, false, false);
-      const peg$e54 = peg$otherExpectation("symbol");
-      const peg$e55 = peg$literalExpectation("==", false);
-      const peg$e56 = peg$literalExpectation("!=", false);
-      const peg$e57 = peg$literalExpectation(">=", false);
-      const peg$e58 = peg$literalExpectation(">", false);
-      const peg$e59 = peg$literalExpectation("<=", false);
-      const peg$e60 = peg$literalExpectation("<", false);
-      const peg$e61 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false, false);
+      const peg$e28 = peg$otherExpectation("number-literal");
+      const peg$e29 = peg$literalExpectation("-", false);
+      const peg$e30 = peg$classExpectation([["0", "9"]], false, false, false);
+      const peg$e31 = peg$otherExpectation("string-literal");
+      const peg$e32 = peg$literalExpectation("'", false);
+      const peg$e33 = peg$classExpectation(["'"], true, false, false);
+      const peg$e34 = peg$literalExpectation("\"", false);
+      const peg$e35 = peg$classExpectation(["\""], true, false, false);
+      const peg$e36 = peg$literalExpectation("`", false);
+      const peg$e37 = peg$otherExpectation("tstring-expression");
+      const peg$e38 = peg$literalExpectation("}", false);
+      const peg$e39 = peg$otherExpectation("tstring-literal");
+      const peg$e40 = peg$classExpectation(["\\", "`", "{"], true, false, false);
+      const peg$e41 = peg$otherExpectation("array-literal");
+      const peg$e42 = peg$otherExpectation("dict-literal");
+      const peg$e43 = peg$otherExpectation("module-function");
+      const peg$e44 = peg$literalExpectation("#", false);
+      const peg$e45 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_"], false, false, false);
+      const peg$e46 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_", ["0", "9"]], false, false, false);
+      const peg$e47 = peg$otherExpectation("identifier-or-keyword");
+      const peg$e48 = peg$literalExpectation("==", false);
+      const peg$e49 = peg$literalExpectation("!=", false);
+      const peg$e50 = peg$literalExpectation(">=", false);
+      const peg$e51 = peg$literalExpectation(">", false);
+      const peg$e52 = peg$literalExpectation("<=", false);
+      const peg$e53 = peg$literalExpectation("<", false);
+      const peg$e54 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false, false);
 
       function peg$f0(value) {    return {type:nodes.templated.ten, value}  }
       function peg$f1(value) {    return {type:nodes.templated.teh, value}  }
@@ -353,8 +392,8 @@ var ftl = (function (exports) {
       }
       function peg$f16(expr) {    return {type:nodes.not, expr}  }
       function peg$f17(lhs, rhs) {    return {type: nodes.access, lhs, rhs}  }
-      function peg$f18(op, rhs) {    
-               return {type: nodes.member, ns: op === '?.', rhs: rhs.value}; 
+      function peg$f18(op, rhs) {
+        return {type: nodes.member, ns: op === '?.', rhs: rhs};
       }
       function peg$f19(op, rhs) {    
                return {type: nodes.subscript, ns: op !== null, rhs}; 
@@ -367,41 +406,29 @@ var ftl = (function (exports) {
         const args = h === null ? [] : [h, ...t];
         return {type: nodes.call, value: fn, args};
       }
-      function peg$f23() {    
-               return {type: nodes.literal, value: true}; 
-      }
-      function peg$f24() {    
-               return {type: nodes.literal, value: false}; 
-      }
-      function peg$f25() {
-        return {type: nodes.literal, value: null};
-      }
-      function peg$f26() {
-        return {type: nodes.literal, value: undefined};
-      }
-      function peg$f27(value) {
+      function peg$f23(value) {
         return { type: nodes.literal, value: parseFloat(value) };
       }
-      function peg$f28(value) {    return {type: nodes.literal, value};  }
-      function peg$f29(value) {    return {type: nodes.literal, value};  }
-      function peg$f30(parts) {    
+      function peg$f24(value) {    return {type: nodes.literal, value};  }
+      function peg$f25(value) {    return {type: nodes.literal, value};  }
+      function peg$f26(parts) {    
                return {type: nodes.tstring, parts}; 
       }
-      function peg$f31(expr) {    
+      function peg$f27(expr) {    
                return expr; 
       }
-      function peg$f32(c) {    return c;  }
-      function peg$f33(parts) {
+      function peg$f28(c) {    return c;  }
+      function peg$f29(parts) {
         return { type: nodes.literal, value: parts.join('') };
       }
-      function peg$f34(char) {    
+      function peg$f30(char) {    
                return { type: nodes.literal, value: char }; 
       }
-      function peg$f35(h, t) {    
+      function peg$f31(h, t) {    
                const value = h === null ? [] : [h, ...t];
                return {type: nodes.array, value};
       }
-      function peg$f36(h, t) {
+      function peg$f32(h, t) {
         var value = [];
         if (h !== null){
             value.push(h);
@@ -409,11 +436,13 @@ var ftl = (function (exports) {
         value.push.apply(value, t);
         return {type: nodes.dict, value};   
       }
-      function peg$f37(module, v) {
+      function peg$f33(module, v) {
         return {type: nodes.function, module, value: v}
       }
-      function peg$f38(s) {    
-               return {type: nodes.symbol, value: s}; 
+      function peg$f34(s) {
+        return keywords.has(s)
+            ? {type: nodes.literal, value: keywords.get(s)}
+            : {type: nodes.symbol, value: s};
       }
       let peg$currPos = options.peg$currPos | 0;
       const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -541,7 +570,7 @@ var ftl = (function (exports) {
       function peg$parseTemplatedRoot() {
         let s0, s1;
 
-        const key = peg$currPos * 40 + 0;
+        const key = peg$currPos * 38 + 0;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -565,7 +594,7 @@ var ftl = (function (exports) {
       function peg$parseTemplatedExpression() {
         let s0, s1, s2, s3, s4;
 
-        const key = peg$currPos * 40 + 1;
+        const key = peg$currPos * 38 + 1;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -670,7 +699,7 @@ var ftl = (function (exports) {
       function peg$parseBeginNode() {
         let s0;
 
-        const key = peg$currPos * 40 + 2;
+        const key = peg$currPos * 38 + 2;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -695,7 +724,7 @@ var ftl = (function (exports) {
       function peg$parseEndNode() {
         let s0;
 
-        const key = peg$currPos * 40 + 3;
+        const key = peg$currPos * 38 + 3;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -720,7 +749,7 @@ var ftl = (function (exports) {
       function peg$parseBeginHtml() {
         let s0;
 
-        const key = peg$currPos * 40 + 4;
+        const key = peg$currPos * 38 + 4;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -745,7 +774,7 @@ var ftl = (function (exports) {
       function peg$parseEndHtml() {
         let s0;
 
-        const key = peg$currPos * 40 + 5;
+        const key = peg$currPos * 38 + 5;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -770,7 +799,7 @@ var ftl = (function (exports) {
       function peg$parseBeginText() {
         let s0;
 
-        const key = peg$currPos * 40 + 6;
+        const key = peg$currPos * 38 + 6;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -795,7 +824,7 @@ var ftl = (function (exports) {
       function peg$parseEndText() {
         let s0;
 
-        const key = peg$currPos * 40 + 7;
+        const key = peg$currPos * 38 + 7;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -818,9 +847,9 @@ var ftl = (function (exports) {
       }
 
       function peg$parseTemplatedText() {
-        let s0, s1, s2, s3, s4, s5;
+        let s0, s1, s2, s3, s4, s5, s6;
 
-        const key = peg$currPos * 40 + 8;
+        const key = peg$currPos * 38 + 8;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -888,40 +917,46 @@ var ftl = (function (exports) {
           }
           if (s2 === peg$FAILED) {
             s2 = peg$currPos;
+            s3 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 123) {
-              s3 = peg$c9;
+              s4 = peg$c9;
               peg$currPos++;
             } else {
-              s3 = peg$FAILED;
+              s4 = peg$FAILED;
               if (peg$silentFails === 0) { peg$fail(peg$e9); }
             }
-            if (s3 !== peg$FAILED) {
-              s4 = peg$currPos;
+            if (s4 !== peg$FAILED) {
+              s5 = peg$currPos;
               peg$silentFails++;
               if (input.charCodeAt(peg$currPos) === 123) {
-                s5 = peg$c9;
+                s6 = peg$c9;
                 peg$currPos++;
               } else {
-                s5 = peg$FAILED;
+                s6 = peg$FAILED;
                 if (peg$silentFails === 0) { peg$fail(peg$e9); }
               }
               peg$silentFails--;
-              if (s5 === peg$FAILED) {
-                s4 = undefined;
+              if (s6 === peg$FAILED) {
+                s5 = undefined;
               } else {
-                peg$currPos = s4;
-                s4 = peg$FAILED;
+                peg$currPos = s5;
+                s5 = peg$FAILED;
               }
-              if (s4 !== peg$FAILED) {
-                s3 = [s3, s4];
-                s2 = s3;
+              if (s5 !== peg$FAILED) {
+                s4 = [s4, s5];
+                s3 = s4;
               } else {
-                peg$currPos = s2;
-                s2 = peg$FAILED;
+                peg$currPos = s3;
+                s3 = peg$FAILED;
               }
             } else {
-              peg$currPos = s2;
-              s2 = peg$FAILED;
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+              s2 = input.substring(s2, peg$currPos);
+            } else {
+              s2 = s3;
             }
           }
         }
@@ -985,40 +1020,46 @@ var ftl = (function (exports) {
               }
               if (s2 === peg$FAILED) {
                 s2 = peg$currPos;
+                s3 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 123) {
-                  s3 = peg$c9;
+                  s4 = peg$c9;
                   peg$currPos++;
                 } else {
-                  s3 = peg$FAILED;
+                  s4 = peg$FAILED;
                   if (peg$silentFails === 0) { peg$fail(peg$e9); }
                 }
-                if (s3 !== peg$FAILED) {
-                  s4 = peg$currPos;
+                if (s4 !== peg$FAILED) {
+                  s5 = peg$currPos;
                   peg$silentFails++;
                   if (input.charCodeAt(peg$currPos) === 123) {
-                    s5 = peg$c9;
+                    s6 = peg$c9;
                     peg$currPos++;
                   } else {
-                    s5 = peg$FAILED;
+                    s6 = peg$FAILED;
                     if (peg$silentFails === 0) { peg$fail(peg$e9); }
                   }
                   peg$silentFails--;
-                  if (s5 === peg$FAILED) {
-                    s4 = undefined;
+                  if (s6 === peg$FAILED) {
+                    s5 = undefined;
                   } else {
-                    peg$currPos = s4;
-                    s4 = peg$FAILED;
+                    peg$currPos = s5;
+                    s5 = peg$FAILED;
                   }
-                  if (s4 !== peg$FAILED) {
-                    s3 = [s3, s4];
-                    s2 = s3;
+                  if (s5 !== peg$FAILED) {
+                    s4 = [s4, s5];
+                    s3 = s4;
                   } else {
-                    peg$currPos = s2;
-                    s2 = peg$FAILED;
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
                   }
                 } else {
-                  peg$currPos = s2;
-                  s2 = peg$FAILED;
+                  peg$currPos = s3;
+                  s3 = peg$FAILED;
+                }
+                if (s3 !== peg$FAILED) {
+                  s2 = input.substring(s2, peg$currPos);
+                } else {
+                  s2 = s3;
                 }
               }
             }
@@ -1039,7 +1080,7 @@ var ftl = (function (exports) {
       function peg$parseExpressionRoot() {
         let s0, s2;
 
-        const key = peg$currPos * 40 + 9;
+        const key = peg$currPos * 38 + 9;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1067,7 +1108,7 @@ var ftl = (function (exports) {
       function peg$parseTernaryExpression() {
         let s0, s1, s3, s5, s7, s9;
 
-        const key = peg$currPos * 40 + 10;
+        const key = peg$currPos * 38 + 10;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1136,7 +1177,7 @@ var ftl = (function (exports) {
       function peg$parseElvisExpression() {
         let s0, s1, s3, s5;
 
-        const key = peg$currPos * 40 + 11;
+        const key = peg$currPos * 38 + 11;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1185,7 +1226,7 @@ var ftl = (function (exports) {
       function peg$parseNullCoalescingExpression() {
         let s0, s1, s3, s5;
 
-        const key = peg$currPos * 40 + 12;
+        const key = peg$currPos * 38 + 12;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1234,7 +1275,7 @@ var ftl = (function (exports) {
       function peg$parseOrExpression() {
         let s0, s1, s2, s3, s5, s7;
 
-        const key = peg$currPos * 40 + 13;
+        const key = peg$currPos * 38 + 13;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1308,7 +1349,7 @@ var ftl = (function (exports) {
       function peg$parseAndExpression() {
         let s0, s1, s2, s3, s5, s7;
 
-        const key = peg$currPos * 40 + 14;
+        const key = peg$currPos * 38 + 14;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1382,7 +1423,7 @@ var ftl = (function (exports) {
       function peg$parseEqExpression() {
         let s0, s1, s2, s3, s5, s7;
 
-        const key = peg$currPos * 40 + 15;
+        const key = peg$currPos * 38 + 15;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1444,7 +1485,7 @@ var ftl = (function (exports) {
       function peg$parseRelExpression() {
         let s0, s1, s2, s3, s5, s7;
 
-        const key = peg$currPos * 40 + 16;
+        const key = peg$currPos * 38 + 16;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1506,7 +1547,7 @@ var ftl = (function (exports) {
       function peg$parseNotExpression() {
         let s0, s1, s3;
 
-        const key = peg$currPos * 40 + 17;
+        const key = peg$currPos * 38 + 17;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1548,7 +1589,7 @@ var ftl = (function (exports) {
       function peg$parseAccess() {
         let s0, s1, s3, s4, s5;
 
-        const key = peg$currPos * 40 + 18;
+        const key = peg$currPos * 38 + 18;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1609,7 +1650,7 @@ var ftl = (function (exports) {
       function peg$parseAccessExpression() {
         let s0;
 
-        const key = peg$currPos * 40 + 19;
+        const key = peg$currPos * 38 + 19;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1634,7 +1675,7 @@ var ftl = (function (exports) {
       function peg$parseAccessMember() {
         let s0, s1, s3;
 
-        const key = peg$currPos * 40 + 20;
+        const key = peg$currPos * 38 + 20;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1663,7 +1704,7 @@ var ftl = (function (exports) {
         }
         if (s1 !== peg$FAILED) {
           peg$parse_();
-          s3 = peg$parseSymbol();
+          s3 = peg$parseWord();
           if (s3 !== peg$FAILED) {
             s0 = peg$f18(s1, s3);
           } else {
@@ -1688,7 +1729,7 @@ var ftl = (function (exports) {
       function peg$parseAccessSubscript() {
         let s0, s1, s2, s4, s6;
 
-        const key = peg$currPos * 40 + 21;
+        const key = peg$currPos * 38 + 21;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1756,7 +1797,7 @@ var ftl = (function (exports) {
       function peg$parseAccessMethodCall() {
         let s0, s1, s2, s4, s5, s6, s7, s9;
 
-        const key = peg$currPos * 40 + 22;
+        const key = peg$currPos * 38 + 22;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1877,7 +1918,7 @@ var ftl = (function (exports) {
       function peg$parseGroupingExpression() {
         let s0, s1, s3, s5;
 
-        const key = peg$currPos * 40 + 23;
+        const key = peg$currPos * 38 + 23;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -1925,7 +1966,7 @@ var ftl = (function (exports) {
           if (s0 === peg$FAILED) {
             s0 = peg$parseAnyLiteral();
             if (s0 === peg$FAILED) {
-              s0 = peg$parseSymbol();
+              s0 = peg$parseIdentifier();
             }
           }
         }
@@ -1938,7 +1979,7 @@ var ftl = (function (exports) {
       function peg$parseModuleFunctionCall() {
         let s0, s1, s2, s4, s5, s6, s7, s9;
 
-        const key = peg$currPos * 40 + 24;
+        const key = peg$currPos * 38 + 24;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2055,7 +2096,7 @@ var ftl = (function (exports) {
       function peg$parseAnyLiteral() {
         let s0;
 
-        const key = peg$currPos * 40 + 25;
+        const key = peg$currPos * 38 + 25;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2066,20 +2107,11 @@ var ftl = (function (exports) {
 
         s0 = peg$parseNumberLiteral();
         if (s0 === peg$FAILED) {
-          s0 = peg$parseBooleanLiteral();
+          s0 = peg$parseStringLiteral();
           if (s0 === peg$FAILED) {
-            s0 = peg$parseNullLiteral();
+            s0 = peg$parseArrayLiteral();
             if (s0 === peg$FAILED) {
-              s0 = peg$parseUndefinedLiteral();
-              if (s0 === peg$FAILED) {
-                s0 = peg$parseStringLiteral();
-                if (s0 === peg$FAILED) {
-                  s0 = peg$parseArrayLiteral();
-                  if (s0 === peg$FAILED) {
-                    s0 = peg$parseDictLiteral();
-                  }
-                }
-              }
+              s0 = peg$parseDictLiteral();
             }
           }
         }
@@ -2089,132 +2121,10 @@ var ftl = (function (exports) {
         return s0;
       }
 
-      function peg$parseBooleanLiteral() {
-        let s0, s1;
-
-        const key = peg$currPos * 40 + 26;
-        const cached = peg$resultsCache[key];
-
-        if (cached) {
-          peg$currPos = cached.nextPos;
-
-          return cached.result;
-        }
-
-        peg$silentFails++;
-        s0 = peg$currPos;
-        if (input.substr(peg$currPos, 4) === peg$c39) {
-          s1 = peg$c39;
-          peg$currPos += 4;
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e29); }
-        }
-        if (s1 !== peg$FAILED) {
-          s1 = peg$f23();
-        }
-        s0 = s1;
-        if (s0 === peg$FAILED) {
-          s0 = peg$currPos;
-          if (input.substr(peg$currPos, 5) === peg$c40) {
-            s1 = peg$c40;
-            peg$currPos += 5;
-          } else {
-            s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e30); }
-          }
-          if (s1 !== peg$FAILED) {
-            s1 = peg$f24();
-          }
-          s0 = s1;
-        }
-        peg$silentFails--;
-        if (s0 === peg$FAILED) {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e28); }
-        }
-
-        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-        return s0;
-      }
-
-      function peg$parseNullLiteral() {
-        let s0, s1;
-
-        const key = peg$currPos * 40 + 27;
-        const cached = peg$resultsCache[key];
-
-        if (cached) {
-          peg$currPos = cached.nextPos;
-
-          return cached.result;
-        }
-
-        peg$silentFails++;
-        s0 = peg$currPos;
-        if (input.substr(peg$currPos, 4) === peg$c41) {
-          s1 = peg$c41;
-          peg$currPos += 4;
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e32); }
-        }
-        if (s1 !== peg$FAILED) {
-          s1 = peg$f25();
-        }
-        s0 = s1;
-        peg$silentFails--;
-        if (s0 === peg$FAILED) {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e31); }
-        }
-
-        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-        return s0;
-      }
-
-      function peg$parseUndefinedLiteral() {
-        let s0, s1;
-
-        const key = peg$currPos * 40 + 28;
-        const cached = peg$resultsCache[key];
-
-        if (cached) {
-          peg$currPos = cached.nextPos;
-
-          return cached.result;
-        }
-
-        peg$silentFails++;
-        s0 = peg$currPos;
-        if (input.substr(peg$currPos, 9) === peg$c42) {
-          s1 = peg$c42;
-          peg$currPos += 9;
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e34); }
-        }
-        if (s1 !== peg$FAILED) {
-          s1 = peg$f26();
-        }
-        s0 = s1;
-        peg$silentFails--;
-        if (s0 === peg$FAILED) {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e33); }
-        }
-
-        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
-
-        return s0;
-      }
-
       function peg$parseNumberLiteral() {
         let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-        const key = peg$currPos * 40 + 29;
+        const key = peg$currPos * 38 + 26;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2228,11 +2138,11 @@ var ftl = (function (exports) {
         s1 = peg$currPos;
         s2 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 45) {
-          s3 = peg$c43;
+          s3 = peg$c39;
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e36); }
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
         }
         if (s3 === peg$FAILED) {
           s3 = null;
@@ -2244,7 +2154,7 @@ var ftl = (function (exports) {
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e37); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
         if (s6 !== peg$FAILED) {
           while (s6 !== peg$FAILED) {
@@ -2254,7 +2164,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
           }
         } else {
@@ -2276,7 +2186,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             while (s9 !== peg$FAILED) {
               s8.push(s9);
@@ -2285,7 +2195,7 @@ var ftl = (function (exports) {
                 peg$currPos++;
               } else {
                 s9 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                if (peg$silentFails === 0) { peg$fail(peg$e30); }
               }
             }
             s7 = [s7, s8];
@@ -2319,7 +2229,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
             if (s7 !== peg$FAILED) {
               while (s7 !== peg$FAILED) {
@@ -2329,7 +2239,7 @@ var ftl = (function (exports) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e30); }
                 }
               }
             } else {
@@ -2360,13 +2270,13 @@ var ftl = (function (exports) {
           s1 = s2;
         }
         if (s1 !== peg$FAILED) {
-          s1 = peg$f27(s1);
+          s1 = peg$f23(s1);
         }
         s0 = s1;
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e35); }
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -2377,7 +2287,7 @@ var ftl = (function (exports) {
       function peg$parseStringLiteral() {
         let s0, s1, s2, s3, s4;
 
-        const key = peg$currPos * 40 + 30;
+        const key = peg$currPos * 38 + 27;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2389,11 +2299,11 @@ var ftl = (function (exports) {
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 39) {
-          s1 = peg$c44;
+          s1 = peg$c40;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
@@ -2403,7 +2313,7 @@ var ftl = (function (exports) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e40); }
+            if (peg$silentFails === 0) { peg$fail(peg$e33); }
           }
           while (s4 !== peg$FAILED) {
             s3.push(s4);
@@ -2412,19 +2322,19 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e40); }
+              if (peg$silentFails === 0) { peg$fail(peg$e33); }
             }
           }
           s2 = input.substring(s2, peg$currPos);
           if (input.charCodeAt(peg$currPos) === 39) {
-            s3 = peg$c44;
+            s3 = peg$c40;
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+            if (peg$silentFails === 0) { peg$fail(peg$e32); }
           }
           if (s3 !== peg$FAILED) {
-            s0 = peg$f28(s2);
+            s0 = peg$f24(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -2436,11 +2346,11 @@ var ftl = (function (exports) {
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 34) {
-            s1 = peg$c45;
+            s1 = peg$c41;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            if (peg$silentFails === 0) { peg$fail(peg$e34); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -2450,7 +2360,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e42); }
+              if (peg$silentFails === 0) { peg$fail(peg$e35); }
             }
             while (s4 !== peg$FAILED) {
               s3.push(s4);
@@ -2459,19 +2369,19 @@ var ftl = (function (exports) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e42); }
+                if (peg$silentFails === 0) { peg$fail(peg$e35); }
               }
             }
             s2 = input.substring(s2, peg$currPos);
             if (input.charCodeAt(peg$currPos) === 34) {
-              s3 = peg$c45;
+              s3 = peg$c41;
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e41); }
+              if (peg$silentFails === 0) { peg$fail(peg$e34); }
             }
             if (s3 !== peg$FAILED) {
-              s0 = peg$f29(s2);
+              s0 = peg$f25(s2);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -2483,11 +2393,11 @@ var ftl = (function (exports) {
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 96) {
-              s1 = peg$c46;
+              s1 = peg$c42;
               peg$currPos++;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e43); }
+              if (peg$silentFails === 0) { peg$fail(peg$e36); }
             }
             if (s1 !== peg$FAILED) {
               s2 = [];
@@ -2503,14 +2413,14 @@ var ftl = (function (exports) {
                 }
               }
               if (input.charCodeAt(peg$currPos) === 96) {
-                s3 = peg$c46;
+                s3 = peg$c42;
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+                if (peg$silentFails === 0) { peg$fail(peg$e36); }
               }
               if (s3 !== peg$FAILED) {
-                s0 = peg$f30(s2);
+                s0 = peg$f26(s2);
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -2524,7 +2434,7 @@ var ftl = (function (exports) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e38); }
+          if (peg$silentFails === 0) { peg$fail(peg$e31); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -2535,7 +2445,7 @@ var ftl = (function (exports) {
       function peg$parseTemplateStringExpression() {
         let s0, s1, s3, s5;
 
-        const key = peg$currPos * 40 + 31;
+        const key = peg$currPos * 38 + 28;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2559,14 +2469,14 @@ var ftl = (function (exports) {
           if (s3 !== peg$FAILED) {
             peg$parse_();
             if (input.charCodeAt(peg$currPos) === 125) {
-              s5 = peg$c47;
+              s5 = peg$c43;
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e45); }
+              if (peg$silentFails === 0) { peg$fail(peg$e38); }
             }
             if (s5 !== peg$FAILED) {
-              s0 = peg$f31(s3);
+              s0 = peg$f27(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -2582,7 +2492,7 @@ var ftl = (function (exports) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e44); }
+          if (peg$silentFails === 0) { peg$fail(peg$e37); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -2593,7 +2503,7 @@ var ftl = (function (exports) {
       function peg$parseTemplateStringLiteral() {
         let s0, s1, s2, s3, s4;
 
-        const key = peg$currPos * 40 + 32;
+        const key = peg$currPos * 38 + 29;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2612,7 +2522,7 @@ var ftl = (function (exports) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e47); }
+          if (peg$silentFails === 0) { peg$fail(peg$e40); }
         }
         if (s4 !== peg$FAILED) {
           while (s4 !== peg$FAILED) {
@@ -2622,7 +2532,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e47); }
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
             }
           }
         } else {
@@ -2651,7 +2561,7 @@ var ftl = (function (exports) {
               if (peg$silentFails === 0) { peg$fail(peg$e8); }
             }
             if (s4 !== peg$FAILED) {
-              s2 = peg$f32(s4);
+              s2 = peg$f28(s4);
             } else {
               peg$currPos = s2;
               s2 = peg$FAILED;
@@ -2671,7 +2581,7 @@ var ftl = (function (exports) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e47); }
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
             }
             if (s4 !== peg$FAILED) {
               while (s4 !== peg$FAILED) {
@@ -2681,7 +2591,7 @@ var ftl = (function (exports) {
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                  if (peg$silentFails === 0) { peg$fail(peg$e40); }
                 }
               }
             } else {
@@ -2710,7 +2620,7 @@ var ftl = (function (exports) {
                   if (peg$silentFails === 0) { peg$fail(peg$e8); }
                 }
                 if (s4 !== peg$FAILED) {
-                  s2 = peg$f32(s4);
+                  s2 = peg$f28(s4);
                 } else {
                   peg$currPos = s2;
                   s2 = peg$FAILED;
@@ -2725,7 +2635,7 @@ var ftl = (function (exports) {
           s1 = peg$FAILED;
         }
         if (s1 !== peg$FAILED) {
-          s1 = peg$f33(s1);
+          s1 = peg$f29(s1);
         }
         s0 = s1;
         if (s0 === peg$FAILED) {
@@ -2738,14 +2648,14 @@ var ftl = (function (exports) {
             if (peg$silentFails === 0) { peg$fail(peg$e9); }
           }
           if (s1 !== peg$FAILED) {
-            s1 = peg$f34(s1);
+            s1 = peg$f30(s1);
           }
           s0 = s1;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+          if (peg$silentFails === 0) { peg$fail(peg$e39); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -2756,7 +2666,7 @@ var ftl = (function (exports) {
       function peg$parseArrayLiteral() {
         let s0, s1, s3, s5, s6, s7, s9;
 
-        const key = peg$currPos * 40 + 33;
+        const key = peg$currPos * 38 + 30;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -2837,7 +2747,7 @@ var ftl = (function (exports) {
             if (peg$silentFails === 0) { peg$fail(peg$e22); }
           }
           if (s6 !== peg$FAILED) {
-            s0 = peg$f35(s3, s5);
+            s0 = peg$f31(s3, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -2849,7 +2759,7 @@ var ftl = (function (exports) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+          if (peg$silentFails === 0) { peg$fail(peg$e41); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -2860,7 +2770,7 @@ var ftl = (function (exports) {
       function peg$parseDictLiteral() {
         let s0, s1, s3, s4, s5, s6, s7, s8, s9, s11, s13;
 
-        const key = peg$currPos * 40 + 34;
+        const key = peg$currPos * 38 + 31;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3001,14 +2911,14 @@ var ftl = (function (exports) {
             }
           }
           if (input.charCodeAt(peg$currPos) === 125) {
-            s6 = peg$c47;
+            s6 = peg$c43;
             peg$currPos++;
           } else {
             s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e45); }
+            if (peg$silentFails === 0) { peg$fail(peg$e38); }
           }
           if (s6 !== peg$FAILED) {
-            s0 = peg$f36(s3, s5);
+            s0 = peg$f32(s3, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -3020,7 +2930,7 @@ var ftl = (function (exports) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e49); }
+          if (peg$silentFails === 0) { peg$fail(peg$e42); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -3029,9 +2939,9 @@ var ftl = (function (exports) {
       }
 
       function peg$parseModuleFunction() {
-        let s0, s1, s2, s3, s4, s5, s6, s7;
+        let s0, s1, s2, s3, s4;
 
-        const key = peg$currPos * 40 + 35;
+        const key = peg$currPos * 38 + 32;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3043,53 +2953,15 @@ var ftl = (function (exports) {
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 35) {
-          s1 = peg$c49;
+          s1 = peg$c45;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e51); }
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
         }
         if (s1 !== peg$FAILED) {
           s2 = peg$currPos;
-          s3 = peg$currPos;
-          s4 = peg$currPos;
-          s5 = input.charAt(peg$currPos);
-          if (peg$r5.test(s5)) {
-            peg$currPos++;
-          } else {
-            s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e52); }
-          }
-          if (s5 !== peg$FAILED) {
-            s6 = [];
-            s7 = input.charAt(peg$currPos);
-            if (peg$r6.test(s7)) {
-              peg$currPos++;
-            } else {
-              s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e53); }
-            }
-            while (s7 !== peg$FAILED) {
-              s6.push(s7);
-              s7 = input.charAt(peg$currPos);
-              if (peg$r6.test(s7)) {
-                peg$currPos++;
-              } else {
-                s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e53); }
-              }
-            }
-            s5 = [s5, s6];
-            s4 = s5;
-          } else {
-            peg$currPos = s4;
-            s4 = peg$FAILED;
-          }
-          if (s4 !== peg$FAILED) {
-            s3 = input.substring(s3, peg$currPos);
-          } else {
-            s3 = s4;
-          }
+          s3 = peg$parseWord();
           if (s3 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 58) {
               s4 = peg$c15;
@@ -3111,47 +2983,9 @@ var ftl = (function (exports) {
           if (s2 === peg$FAILED) {
             s2 = null;
           }
-          s3 = peg$currPos;
-          s4 = peg$currPos;
-          s5 = input.charAt(peg$currPos);
-          if (peg$r5.test(s5)) {
-            peg$currPos++;
-          } else {
-            s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e52); }
-          }
-          if (s5 !== peg$FAILED) {
-            s6 = [];
-            s7 = input.charAt(peg$currPos);
-            if (peg$r6.test(s7)) {
-              peg$currPos++;
-            } else {
-              s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e53); }
-            }
-            while (s7 !== peg$FAILED) {
-              s6.push(s7);
-              s7 = input.charAt(peg$currPos);
-              if (peg$r6.test(s7)) {
-                peg$currPos++;
-              } else {
-                s7 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e53); }
-              }
-            }
-            s5 = [s5, s6];
-            s4 = s5;
-          } else {
-            peg$currPos = s4;
-            s4 = peg$FAILED;
-          }
-          if (s4 !== peg$FAILED) {
-            s3 = input.substring(s3, peg$currPos);
-          } else {
-            s3 = s4;
-          }
+          s3 = peg$parseWord();
           if (s3 !== peg$FAILED) {
-            s0 = peg$f37(s2, s3);
+            s0 = peg$f33(s2, s3);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -3163,7 +2997,7 @@ var ftl = (function (exports) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e50); }
+          if (peg$silentFails === 0) { peg$fail(peg$e43); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -3171,10 +3005,10 @@ var ftl = (function (exports) {
         return s0;
       }
 
-      function peg$parseSymbol() {
-        let s0, s1, s2, s3, s4, s5;
+      function peg$parseWord() {
+        let s0, s1, s2, s3, s4;
 
-        const key = peg$currPos * 40 + 36;
+        const key = peg$currPos * 38 + 33;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3183,55 +3017,74 @@ var ftl = (function (exports) {
           return cached.result;
         }
 
-        peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$currPos;
-        s2 = peg$currPos;
-        s3 = input.charAt(peg$currPos);
-        if (peg$r5.test(s3)) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r5.test(s2)) {
           peg$currPos++;
         } else {
-          s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e52); }
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e45); }
         }
-        if (s3 !== peg$FAILED) {
-          s4 = [];
-          s5 = input.charAt(peg$currPos);
-          if (peg$r6.test(s5)) {
+        if (s2 !== peg$FAILED) {
+          s3 = [];
+          s4 = input.charAt(peg$currPos);
+          if (peg$r6.test(s4)) {
             peg$currPos++;
           } else {
-            s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e53); }
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e46); }
           }
-          while (s5 !== peg$FAILED) {
-            s4.push(s5);
-            s5 = input.charAt(peg$currPos);
-            if (peg$r6.test(s5)) {
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = input.charAt(peg$currPos);
+            if (peg$r6.test(s4)) {
               peg$currPos++;
             } else {
-              s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e53); }
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e46); }
             }
           }
-          s3 = [s3, s4];
-          s2 = s3;
+          s2 = [s2, s3];
+          s1 = s2;
         } else {
-          peg$currPos = s2;
-          s2 = peg$FAILED;
+          peg$currPos = s1;
+          s1 = peg$FAILED;
         }
-        if (s2 !== peg$FAILED) {
-          s1 = input.substring(s1, peg$currPos);
+        if (s1 !== peg$FAILED) {
+          s0 = input.substring(s0, peg$currPos);
         } else {
-          s1 = s2;
+          s0 = s1;
         }
-        if (s1 !== peg$FAILED) {
-          s1 = peg$f38(s1);
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseIdentifier() {
+        let s0, s1;
+
+        const key = peg$currPos * 38 + 34;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$parseWord();
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f34(s1);
         }
         s0 = s1;
         peg$silentFails--;
         if (s0 === peg$FAILED) {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+          if (peg$silentFails === 0) { peg$fail(peg$e47); }
         }
 
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -3242,7 +3095,7 @@ var ftl = (function (exports) {
       function peg$parseEqualityOp() {
         let s0;
 
-        const key = peg$currPos * 40 + 37;
+        const key = peg$currPos * 38 + 35;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3251,20 +3104,20 @@ var ftl = (function (exports) {
           return cached.result;
         }
 
-        if (input.substr(peg$currPos, 2) === peg$c53) {
-          s0 = peg$c53;
+        if (input.substr(peg$currPos, 2) === peg$c49) {
+          s0 = peg$c49;
           peg$currPos += 2;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e55); }
+          if (peg$silentFails === 0) { peg$fail(peg$e48); }
         }
         if (s0 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c54) {
-            s0 = peg$c54;
+          if (input.substr(peg$currPos, 2) === peg$c50) {
+            s0 = peg$c50;
             peg$currPos += 2;
           } else {
             s0 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e56); }
+            if (peg$silentFails === 0) { peg$fail(peg$e49); }
           }
         }
 
@@ -3276,7 +3129,7 @@ var ftl = (function (exports) {
       function peg$parseRelationalOp() {
         let s0;
 
-        const key = peg$currPos * 40 + 38;
+        const key = peg$currPos * 38 + 36;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3285,36 +3138,36 @@ var ftl = (function (exports) {
           return cached.result;
         }
 
-        if (input.substr(peg$currPos, 2) === peg$c55) {
-          s0 = peg$c55;
+        if (input.substr(peg$currPos, 2) === peg$c51) {
+          s0 = peg$c51;
           peg$currPos += 2;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e57); }
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
         }
         if (s0 === peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 62) {
-            s0 = peg$c56;
+            s0 = peg$c52;
             peg$currPos++;
           } else {
             s0 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e58); }
+            if (peg$silentFails === 0) { peg$fail(peg$e51); }
           }
           if (s0 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c57) {
-              s0 = peg$c57;
+            if (input.substr(peg$currPos, 2) === peg$c53) {
+              s0 = peg$c53;
               peg$currPos += 2;
             } else {
               s0 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e59); }
+              if (peg$silentFails === 0) { peg$fail(peg$e52); }
             }
             if (s0 === peg$FAILED) {
               if (input.charCodeAt(peg$currPos) === 60) {
-                s0 = peg$c58;
+                s0 = peg$c54;
                 peg$currPos++;
               } else {
                 s0 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e60); }
+                if (peg$silentFails === 0) { peg$fail(peg$e53); }
               }
             }
           }
@@ -3328,7 +3181,7 @@ var ftl = (function (exports) {
       function peg$parse_() {
         let s0, s1;
 
-        const key = peg$currPos * 40 + 39;
+        const key = peg$currPos * 38 + 37;
         const cached = peg$resultsCache[key];
 
         if (cached) {
@@ -3344,7 +3197,7 @@ var ftl = (function (exports) {
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e61); }
+          if (peg$silentFails === 0) { peg$fail(peg$e54); }
         }
         while (s1 !== peg$FAILED) {
           s0.push(s1);
@@ -3353,7 +3206,7 @@ var ftl = (function (exports) {
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e61); }
+            if (peg$silentFails === 0) { peg$fail(peg$e54); }
           }
         }
         peg$silentFails--;
@@ -3397,6 +3250,34 @@ var ftl = (function (exports) {
       }
     }
 
+    /**
+     * The one lookup against a data stack: the innermost overlay carrying the name
+     * wins, `self` is the innermost overlay itself, and a function overlay counts
+     * like an object one. Every lookup that resolves a name goes through this, so the
+     * imperative facades cannot drift from what a template sees.
+     * @param {any[]} dataStack
+     * @param {string|symbol} prop
+     */
+    const resolveInStack = (dataStack, prop) => {
+        if (prop === 'self') {
+            return dataStack[dataStack.length - 1];
+        }
+        for (let i = dataStack.length - 1; i >= 0; i--) {
+            const overlay = dataStack[i];
+            if (overlay != null && (typeof overlay === 'object' || typeof overlay === 'function')) {
+                if (prop in overlay) {
+                    return overlay[prop];
+                }
+            }
+        }
+        return undefined;
+    };
+
+    /**
+     * Evaluates a parsed expression against a scope. One instance per evaluation:
+     * it holds the modules and the data stack that names resolve against, and keeps
+     * no state between visits.
+     */
     class EvaluatingVisitor {
         #modules;
         #dataStack;
@@ -3405,25 +3286,29 @@ var ftl = (function (exports) {
             this.#dataStack = dataStack;
         }
         #resolve(prop) {
-            if (prop === 'self') {
-                return this.#dataStack[this.#dataStack.length - 1];
-            }
-            for (let i = this.#dataStack.length - 1; i >= 0; i--) {
-                const overlay = this.#dataStack[i];
-                if (overlay != null && (typeof overlay === 'object' || typeof overlay === 'function')) {
-                    if (prop in overlay) {
-                        return overlay[prop];
-                    }
-                }
+            return resolveInStack(this.#dataStack, prop);
+        }
+        /**
+         * The name a missing-method report can carry: the called symbol for a bare
+         * `boom()`, the member for a dotted `a.boom()`, nothing for anything else
+         * (a subscript or a grouped left-hand side has no static name).
+         */
+        #reportableName(node, index) {
+            const source = index === 0 ? node.lhs : node.rhs[index - 1];
+            if (source.type === nodes.symbol) {
+                return source.value;
             }
-            return undefined;
+            if (source.type === nodes.member) {
+                return source.rhs;
+            }
+            return null;
         }
 
         #cached_resolve_proxy;
         #resolve_proxy() {
             if (!this.#cached_resolve_proxy) {
                 this.#cached_resolve_proxy = new Proxy(this.#dataStack, {
-                    get: (target, prop) => this.#resolve(prop)
+                    get: (target, prop) => this.#resolve(prop),
                 });
             }
             return this.#cached_resolve_proxy;
@@ -3494,7 +3379,7 @@ var ftl = (function (exports) {
             return this.#resolve(node.value);
         }
         [nodes.dict](node) {
-            return Object.fromEntries(node.value.map((entry) => [entry[0].value, this.visit(entry[1])]));
+            return Object.fromEntries(node.value.map((entry) => [this.visit(entry[0]), this.visit(entry[1])]));
         }
         [nodes.array](node) {
             return node.value.map((v) => this.visit(v));
@@ -3507,14 +3392,14 @@ var ftl = (function (exports) {
             return cond ? cond : this.visit(node.ifFalse);
         }
         [nodes.access](node) {
-            let prev ;
+            let prev;
             let cur = this.visit(node.lhs);
             for (let i = 0; i !== node.rhs.length; ++i) {
                 const rhs = node.rhs[i];
                 if (rhs.ns && cur == null) {
                     return undefined;
                 }
-                let value ;
+                let value;
                 switch (rhs.type) {
                     case nodes.member: {
                         value = cur[rhs.rhs];
@@ -3526,7 +3411,8 @@ var ftl = (function (exports) {
                     }
                     case nodes.method: {
                         if (!cur) {
-                            throw new Error(`Method missing "${node.rhs[i - 1].rhs}"`);
+                            const name = this.#reportableName(node, i);
+                            throw new Error(name === null ? 'Method missing' : `Method missing "${name}"`);
                         }
                         const args = rhs.args.map((arg) => this.visit(arg));
                         value = cur.apply(prev, args);
@@ -3545,28 +3431,34 @@ var ftl = (function (exports) {
             return !templated
                 ? this.visit(ast)
                 : ast.map((node) => {
-                    switch (node.type) {
-                        case nodes.templated.tel:
-                            return { type: nodes.dom.t, value: node.value };
-                        case nodes.templated.tet:
-                            return { type: nodes.dom.t, value: this.visit(node.value) };
-                        case nodes.templated.teh:
-                            return { type: nodes.dom.h, value: this.visit(node.value) };
-                        case nodes.templated.ten:
-                            return { type: nodes.dom.n, value: this.visit(node.value) };
-                        default:
-                            throw new Error(`unknown node type ${node.type.toString()}`);
-                    }
-                });
+                      switch (node.type) {
+                          case nodes.templated.tel:
+                              return { type: nodes.dom.t, value: node.value };
+                          case nodes.templated.tet:
+                              return { type: nodes.dom.t, value: this.visit(node.value) };
+                          case nodes.templated.teh:
+                              return { type: nodes.dom.h, value: this.visit(node.value) };
+                          case nodes.templated.ten:
+                              return { type: nodes.dom.n, value: this.visit(node.value) };
+                          default:
+                              throw new Error(`unknown node type ${node.type.toString()}`);
+                      }
+                  });
         }
     }
 
+    /**
+     * The expression language: parsing to an ast, caching the parses, and
+     * interpreting one against a scope. Member access and calls are unfiltered, so
+     * an expression can do whatever the page's own javascript can. Expressions are
+     * written by the page author; untrusted data is passed in as data and never
+     * spliced into the expression text.
+     */
     class Expressions {
         static MODE_EXPRESSION = Symbol('MODE_EXPRESSION');
         static MODE_TEMPLATED = Symbol('MODE_TEMPLATED');
 
-        static #astCache = new Map();
-        static #MAX_CACHE_SIZE = 1000;
+        static #astCache = new BoundedCache(1000);
 
         /**
          * Parses an expression.
@@ -3576,18 +3468,11 @@ var ftl = (function (exports) {
          */
         static parse(expression, mode) {
             const key = mode?.toString() + expression;
-
-            if (!this.#astCache.has(key)) {
-                if (this.#astCache.size >= this.#MAX_CACHE_SIZE) {
-                    const oldestKey = this.#astCache.keys().next().value;
-                    this.#astCache.delete(oldestKey);
-                }
-                this.#astCache.set(key, peg$parse(expression, {
+            return this.#astCache.getOrCompute(key, () =>
+                peg$parse(expression, {
                     startRule: mode === Expressions.MODE_TEMPLATED ? 'TemplatedRoot' : 'ExpressionRoot',
-                }));
-            }
-
-            return this.#astCache.get(key);
+                }),
+            );
         }
         /**
          * Evaluates an expression.
@@ -3613,6 +3498,12 @@ var ftl = (function (exports) {
         }
     }
 
+    /**
+     * A scope: the modules that `#name:fn()` resolves against and the data stack
+     * that a bare identifier resolves against, as a single value. Adding an overlay
+     * returns a new evaluator instead of modifying this one, so a template can add
+     * data for one subtree without affecting the rest of the render.
+     */
     class ExpressionEvaluator {
         #modules;
         #dataStack;
@@ -3630,17 +3521,25 @@ var ftl = (function (exports) {
                 data.length === 0 ? this.#dataStack : [...this.#dataStack, ...data],
             );
         }
-        evaluate(expression, mode) {
-            return Expressions.interpret(this.#modules, this.#dataStack, expression, mode);
+        /**
+         * Resolves a name against the data stack, with no parse round trip: the
+         * lookup a template's bare identifier makes, for an imperative caller.
+         * @param {string} name
+         */
+        resolve(name) {
+            return resolveInStack(this.#dataStack, name);
         }
+        /** Evaluates an expression against this scope. */
         evaluateExpression(expression) {
-            return this.evaluate(expression, Expressions.MODE_EXPRESSION);
+            return Expressions.interpret(this.#modules, this.#dataStack, expression, Expressions.MODE_EXPRESSION);
         }
-        evaluateTemplated(expression) {
-            return this.evaluate(expression, Expressions.MODE_TEMPLATED);
+        /** Evaluates a templated text, the `{{ }}` form, against this scope. */
+        evaluateTemplated(text) {
+            return Expressions.interpret(this.#modules, this.#dataStack, text, Expressions.MODE_TEMPLATED);
         }
     }
 
+    /** Creates and inspects the DocumentFragments a Template renders into. */
     class Fragments {
         /**
          * Creates a DocumentFragment from an string.
@@ -3653,7 +3552,9 @@ var ftl = (function (exports) {
             return document.adoptNode(el.content);
         }
         /**
-         * Creates a string representation (HTML) of a DocumentFragment.
+         * Creates a string representation (HTML) of a DocumentFragment, consuming it:
+         * the nodes are moved out, not copied, and the fragment is left empty. Pass
+         * `fragment.cloneNode(true)` to keep the original usable.
          * @param {DocumentFragment} fragment
          * @returns {string} the html
          */
@@ -3696,6 +3597,7 @@ var ftl = (function (exports) {
         }
     }
 
+    /** Attribute reads and writes where a nullish value removes the attribute instead of setting it to the string 'null'. */
     class Attributes {
         static id = 0;
         /**
@@ -3731,38 +3633,17 @@ var ftl = (function (exports) {
                 .forEach((a) => {
                     const target = a.substring(prefix.length);
                     if (target === 'class') {
-                        const classes = from.getAttribute(`${prefix}class`)?.split(/\s+/).filter((a) => a.length) ?? [];
+                        const classes =
+                            from
+                                .getAttribute(`${prefix}class`)
+                                ?.split(/\s+/)
+                                .filter((a) => a.length) ?? [];
                         to.classList.add(...classes);
                         return;
                     }
-                    to.setAttribute(target, /** @type {string} */(from.getAttribute(a)));
+                    to.setAttribute(target, /** @type {string} */ (from.getAttribute(a)));
                 });
         }
-        /**
-         * Changes the presence of an attribute.
-         * @param {Element} el
-         * @param {string} attr
-         * @param {boolean} value
-         */
-        static toggle(el, attr, value) {
-            if (value) {
-                el.setAttribute(attr, '');
-            } else {
-                el.removeAttribute(attr);
-            }
-        }
-        /**
-         * Changes the presence of an attribute based on its current state.
-         * @param {Element} el
-         * @param {string} attr
-         */
-        static flip(el, attr) {
-            if (el.hasAttribute(attr)) {
-                el.removeAttribute(attr);
-            } else {
-                el.setAttribute(attr, '');
-            }
-        }
         /**
          * Sets the value of an attribute. nullish values remove the attribute.
          * @param {Element} el
@@ -3778,6 +3659,12 @@ var ftl = (function (exports) {
         }
     }
 
+    /**
+     * Reads an element's light-dom slots: the named `<template slot=…>` and
+     * `[slot=…]` children are removed and collected by name, and the remaining
+     * children become the default slot. fml renders into the light dom, so this
+     * replaces the slotting a shadow root would do.
+     */
     class LightSlots {
         /**
          * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
@@ -3785,12 +3672,19 @@ var ftl = (function (exports) {
          * @returns the slots
          */
         static from(el) {
+            //the platform reads slot="" as the default slot: such children stay in
+            //the document order of the default content, their claim stripped like any named one
+            for (const child of el.children) {
+                if (child.matches('[slot=""]')) {
+                    child.removeAttribute('slot');
+                }
+            }
             /** @type [string, Element|DocumentFragment][] */
             const namedSlots = Array.from(el.children)
                 .filter((el) => el.matches('[slot]'))
                 .map((el) => {
                     el.remove();
-                    const slot = el.getAttribute('slot') || 'unnamed';
+                    const slot = /** @type {string} */ (el.getAttribute('slot'));
                     el.removeAttribute('slot');
                     return [slot, LightSlots.slotFromNode(el)];
                 });
@@ -3809,13 +3703,14 @@ var ftl = (function (exports) {
             if (el instanceof HTMLTemplateElement) {
                 return document.adoptNode(el.content);
             }
-            if (el instanceof HTMLScriptElement && el.type !== '' && el.type !== 'text/javascript') {
+            if (el instanceof HTMLScriptElement && el.type === 'text/html') {
                 return Fragments.fromHtml(el.innerHTML);
             }
             return el;
         }
     }
 
+    /** Waits for the parser and for the document, for elements that upgrade before their own markup is complete. */
     class Nodes {
         /**
          * Checks if an element is already parsed.
@@ -3831,26 +3726,78 @@ var ftl = (function (exports) {
             return false;
         }
 
+        /**
+         * Waits for the document's DOMContentLoaded, resolving immediately when
+         * that moment already passed. 'interactive' alone cannot tell a document
+         * still waiting for deferred scripts (the event comes, however late) from
+         * a module imported past it (the event is gone): the two events order
+         * themselves, DOMContentLoaded always precedes load, so racing the two
+         * resolves with DCL whenever it is still coming and with load otherwise,
+         * never early.
+         */
+        static waitDomContentLoaded(doc) {
+            if (doc.readyState === 'loading') {
+                return new Promise((resolve) => {
+                    doc.addEventListener('DOMContentLoaded', () => resolve(undefined), { once: true });
+                });
+            }
+            if (doc.readyState === 'complete') {
+                return Promise.resolve();
+            }
+            const win = doc.defaultView;
+            if (win === null) {
+                //a viewless document can receive no event at all
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                const done = () => {
+                    win.removeEventListener('DOMContentLoaded', done);
+                    win.removeEventListener('load', done);
+                    resolve(undefined);
+                };
+                win.addEventListener('DOMContentLoaded', done);
+                win.addEventListener('load', done);
+            });
+        }
+
+        /**
+         * Waits for the element's closing tag to be parsed: one MutationObserver
+         * resolves once the element, or any of its ancestors, gains a next sibling,
+         * which is the parser having moved past this subtree. The document's
+         * DOMContentLoaded is the deadline. Resolves immediately for an element
+         * that is already parsed.
+         *
+         * Every ancestor is watched, not only the parent, because that is what the
+         * predicate reads: an element last among its siblings becomes parsed when
+         * an ancestor gains one, and a childList observer on the parent never sees
+         * that. Formatted markup usually hides the difference, the whitespace
+         * before a closing tag being a text node the parent does gain, so the gap
+         * shows on whitespace-free markup, where the wait fell back to the
+         * deadline. One observer takes many targets, so the cost is one observe()
+         * per level, and it is disconnected at the first checkpoint past the
+         * element either way.
+         * @param {any} el
+         * @returns {Promise<any>}
+         */
         static waitParsed(el) {
-            if (el.ownerDocument.readyState === 'complete' || Nodes.isParsed(el)) {
+            if (Nodes.isParsed(el)) {
                 return Promise.resolve(el);
             }
             return new Promise((resolve) => {
-                const ac = new AbortController();
-                const clearAndQueue = () => {
-                    ac.abort();
-                    observer.disconnect();
-                    resolve(el);
-                };
-                el.ownerDocument.addEventListener('DOMContentLoaded', clearAndQueue, { signal: ac.signal });
                 const observer = new MutationObserver(() => {
                     if (!Nodes.isParsed(el)) {
                         return;
                     }
-                    clearAndQueue();
+                    observer.disconnect();
+                    resolve(el);
+                });
+                for (let c = el.parentNode; c; c = c.parentNode) {
+                    observer.observe(c, { childList: true });
+                }
+                Nodes.waitDomContentLoaded(el.ownerDocument).then(() => {
+                    observer.disconnect();
+                    resolve(el);
                 });
-                const parent = /** @type {Node} */ (el.parentNode);
-                observer.observe(parent, { childList: true });
             });
         }
 
@@ -3885,6 +3832,11 @@ var ftl = (function (exports) {
         }
     }
 
+    /**
+     * Collects the changes a render makes to the tree it is traversing, deferring
+     * those that would break the traversal: a node marked for removal stays in
+     * place until the render finishes, so the iteration containing it completes.
+     */
     class NodeOperations {
         #forRemoval = new Set();
         removed(node) {
@@ -3922,7 +3874,11 @@ var ftl = (function (exports) {
         }
     }
 
+    /** The `data-tpl-*` commands, each taking the node it is written on and the scope it evaluates in. */
     class CommandsHandler {
+        //the order is the semantics: each command sees the node as the ones before
+        //it left it, so tplIf gates before tplWith/tplEach push their overlay and
+        //tplWhen gates after (inside the sub-render, where the overlay is in scope)
         static ORDERED_COMMANDS = [
             'tplIf',
             'tplWith',
@@ -3930,48 +3886,98 @@ var ftl = (function (exports) {
             'tplWhen',
             'tplClassAppend',
             'tplAttrAppend',
-            'tplText',
-            'tplHtml',
             'tplRemove',
             'tplVerbatim',
         ];
-        static tplIf(node, expression, ops, modules, dataStack) {
-            const accept = Expressions.interpret(modules, dataStack, expression);
+        //same body as tplWhen: the two differ only in ORDERED_COMMANDS position,
+        //if evaluates in the outer scope, before with/each
+        static tplIf(node, expression, ops, evaluator) {
+            const accept = evaluator.evaluateExpression(expression);
             if (!accept) {
                 ops.remove(node);
             }
         }
-        static tplWith(node, expression, ops, modules, dataStack) {
-            const evaluated = Expressions.interpret(modules, dataStack, expression);
+        static tplWith(node, expression, ops, evaluator) {
+            const evaluated = evaluator.evaluateExpression(expression);
             const varName = ops.popData(node, 'tplVar');
-            const newNode = new Template(node, modules, dataStack)
+            const newNode = new Template(node, evaluator)
                 .withOverlay(varName ? { [varName]: evaluated } : evaluated)
                 .render();
             ops.replace(node, newNode);
         }
-        static tplEach(node, expression, ops, modules, dataStack) {
+        static tplEach(node, expression, ops, evaluator) {
             const varName = ops.popData(node, 'tplVar');
-            const template = new Template(node, modules, dataStack);
-            const evaluated = Expressions.interpret(modules, dataStack, expression);
-            if (!evaluated?.[Symbol.iterator]) {
+            const statName = ops.popData(node, 'tplStat');
+            const template = new Template(node, evaluator);
+            const evaluated = evaluator.evaluateExpression(expression);
+            //keyed collections iterate as {key, value} entries: a Map in its own
+            //order, a non-iterable plain dict in Object.entries order. Plain alone:
+            //a class instance or a response wrapper standing where an array was
+            //expected still fails loudly below, and any other iterable (a Set, a
+            //generator, an entries() iterator) iterates as itself
+            const proto = evaluated === null || typeof evaluated !== 'object' ? undefined : Object.getPrototypeOf(evaluated);
+            const keyed =
+                evaluated instanceof Map
+                    ? [...evaluated]
+                    : !evaluated?.[Symbol.iterator] && (proto === Object.prototype || proto === null)
+                      ? Object.entries(evaluated)
+                      : null;
+            const entries = keyed === null ? evaluated : keyed.map(([key, value]) => ({ key, value }));
+            if (!entries?.[Symbol.iterator]) {
                 throw new Error(`Expected an iterable got '${evaluated}'`);
             }
-            for (const v of evaluated) {
-                ops.prepend(node, template.withOverlay(varName ? { [varName]: v } : v).render());
+            if (!statName) {
+                for (const v of entries) {
+                    ops.prepend(node, template.withOverlay(varName ? { [varName]: v } : v).render());
+                }
+                ops.remove(node);
+                return;
+            }
+            //the stat rides grouped under its declared name, overlaid below the
+            //item, so data can never collide with its fields and an item property
+            //sharing the stat's very name wins, as data always does. The size is
+            //read where the collection already knows it (arrays and keyed entries
+            //by length, sets and the like by size): an arbitrary iterator is never
+            //consumed to learn it, so its size and last read null, the unknown
+            const size = Array.isArray(entries)
+                ? entries.length
+                : typeof entries.length === 'number'
+                  ? entries.length
+                  : typeof entries.size === 'number'
+                    ? entries.size
+                    : null;
+            let index = 0;
+            for (const v of entries) {
+                const stat = {
+                    index,
+                    count: index + 1,
+                    size,
+                    first: index === 0,
+                    last: size === null ? null : index === size - 1,
+                    even: index % 2 === 0,
+                    odd: index % 2 === 1,
+                };
+                ops.prepend(
+                    node,
+                    template.withOverlay({ [statName]: stat }, varName ? { [varName]: v } : v).render(),
+                );
+                ++index;
             }
             ops.remove(node);
         }
-        static tplWhen(node, expression, ops, modules, dataStack) {
-            const accept = Expressions.interpret(modules, dataStack, expression);
+        //same body as tplIf: the two differ only in ORDERED_COMMANDS position,
+        //when evaluates after with/each, in the scope their overlay opened
+        static tplWhen(node, expression, ops, evaluator) {
+            const accept = evaluator.evaluateExpression(expression);
             if (!accept) {
                 ops.remove(node);
             }
         }
-        static tplVerbatim(node, expression, ops, modules, dataStack) {
+        static tplVerbatim(node, expression, ops, evaluator) {
             const newNode = node.cloneNode(true);
             ops.replace(node, newNode);
         }
-        static tplRemove(node, value, ops, modules, dataStack) {
+        static tplRemove(node, value, ops, evaluator) {
             switch (value.toLowerCase()) {
                 case 'tag': {
                     const fragment = new DocumentFragment();
@@ -3996,34 +4002,20 @@ var ftl = (function (exports) {
                     break;
             }
         }
-        static tplText(node, expression, ops, modules, dataStack) {
-            const text = Expressions.interpret(modules, dataStack, expression);
-            const newNode = node.cloneNode();
-            newNode.replaceChildren(text == null ? '' : text);
-            ops.replace(node, newNode);
-        }
-        static tplHtml(node, expression, ops, modules, dataStack) {
-            const html = Expressions.interpret(modules, dataStack, expression);
-            const newNode = node.cloneNode();
-            newNode.innerHTML = html == null ? '' : html;
-            ops.replace(node, newNode);
-        }
-        static tplClassAppend(node, expression, ops, modules, dataStack) {
-            const classes = Expressions.interpret(modules, dataStack, expression);
+        static tplClassAppend(node, expression, ops, evaluator) {
+            const classes = evaluator.evaluateExpression(expression);
             if (!classes) {
                 return;
             }
             const classesAsArray = Array.isArray(classes) ? classes : [classes];
-            const cleanClasses = classesAsArray
-                .flatMap(c => typeof c === 'string' ? c.split(' ') : c)
-                .filter(Boolean);
+            const cleanClasses = classesAsArray.flatMap((c) => (typeof c === 'string' ? c.split(' ') : c)).filter(Boolean);
             if (cleanClasses.length === 0) {
                 return;
             }
             node.classList.add(...cleanClasses);
         }
-        static tplAttrAppend(node, expression, ops, modules, dataStack) {
-            const attributesAndValues = Expressions.interpret(modules, dataStack, expression);
+        static tplAttrAppend(node, expression, ops, evaluator) {
+            const attributesAndValues = evaluator.evaluateExpression(expression);
             if (!attributesAndValues || attributesAndValues.length === 0) {
                 return;
             }
@@ -4032,8 +4024,8 @@ var ftl = (function (exports) {
                 node.setAttribute(k, v);
             });
         }
-        static textNode(node, expression, ops, modules, dataStack) {
-            for (const v of Expressions.interpret(modules, dataStack, expression, Expressions.MODE_TEMPLATED)) {
+        static textNode(node, expression, ops, evaluator) {
+            for (const v of evaluator.evaluateTemplated(expression)) {
                 if (v.value == null) {
                     continue;
                 }
@@ -4042,9 +4034,12 @@ var ftl = (function (exports) {
                         ops.prepend(node, document.createTextNode(v.value));
                         break;
                     case nodes.dom.h:
-                        ops.prepend(node, Fragments.fromHtml(v.value));
+                        ops.prepend(node, Fragments.fromHtml(typeof v.value === 'string' ? v.value : String(v.value)));
                         break;
                     case nodes.dom.n:
+                        if (!(v.value instanceof Node)) {
+                            throw new TypeError(`Expected a Node, got '${typeof v.value}'`);
+                        }
                         ops.prepend(node, v.value);
                         break;
                 }
@@ -4053,10 +4048,8 @@ var ftl = (function (exports) {
         }
     }
 
-    // Module-isolated string cache for dataset-to-attribute conversions, bounded with
-    // FIFO eviction like the expression ast cache
-    const attributeCache = new Map();
-    const ATTRIBUTE_CACHE_MAX_SIZE = 1000;
+    // Module-isolated string cache for dataset-to-attribute conversions
+    const attributeCache = new BoundedCache(1000);
 
     /**
      * Converts a tpl camelCase dataset key into a kebab-case attribute name.
@@ -4065,21 +4058,21 @@ var ftl = (function (exports) {
      * @returns {string}
      */
     function toAttr(dataSetKey) {
-        let cached = attributeCache.get(dataSetKey);
-        if (!cached) {
-            if (attributeCache.size >= ATTRIBUTE_CACHE_MAX_SIZE) {
-                attributeCache.delete(attributeCache.keys().next().value);
-            }
-            cached = dataSetKey
+        return attributeCache.getOrCompute(dataSetKey, (k) =>
+            k
                 .substring(3)
                 .split(/(?=[A-Z])/)
                 .join('-')
-                .toLowerCase();
-            attributeCache.set(dataSetKey, cached);
-        }
-        return cached;
+                .toLowerCase(),
+        );
     }
 
+    /**
+     * A compiled fragment together with the scope it renders in. Both are
+     * immutable: adding data or replacing the scope returns a new Template, so one
+     * piece of compiled markup can be rendered against any number of scopes and a
+     * registry can reuse a single template for every element that requests it.
+     */
     class Template {
         /**
          * Creates a template from a string.
@@ -4089,7 +4082,7 @@ var ftl = (function (exports) {
          * @returns the template
          */
         static fromHtml(html, modules, ...data) {
-            return new Template(Fragments.fromHtml(html), modules, data);
+            return new Template(Fragments.fromHtml(html), new ExpressionEvaluator(modules, data));
         }
 
         /**
@@ -4105,7 +4098,7 @@ var ftl = (function (exports) {
                 throw new Error('template selector does not match any template tag');
             }
             const fragment = document.adoptNode(templateEl.content);
-            return new Template(fragment, modules, data);
+            return new Template(fragment, new ExpressionEvaluator(modules, data));
         }
 
         /**
@@ -4117,7 +4110,7 @@ var ftl = (function (exports) {
          */
         static fromTemplate(templateEl, modules, ...data) {
             const fragment = document.adoptNode(templateEl.content);
-            return new Template(fragment, modules, data);
+            return new Template(fragment, new ExpressionEvaluator(modules, data));
         }
 
         /**
@@ -4128,42 +4121,33 @@ var ftl = (function (exports) {
          * @returns the template
          */
         static fromFragment(fragment, modules, ...data) {
-            return new Template(fragment, modules, data);
+            return new Template(fragment, new ExpressionEvaluator(modules, data));
         }
         #fragment;
-        #modules;
-        #dataStack;
+        #evaluator;
         /**
-         * Creates a template.
+         * Creates a template: a fragment plus the scope it renders in.
          * @param {DocumentFragment} fragment
-         * @param {{ [x: string]: any; } | null | undefined} modules
-         * @param {any[]} dataStack
+         * @param {ExpressionEvaluator} evaluator the modules and data stack the expressions resolve against
          */
-        constructor(fragment, modules, dataStack) {
+        constructor(fragment, evaluator) {
             this.#fragment = fragment;
-            this.#modules = modules;
-            this.#dataStack = dataStack;
-        }
-        /**
-         * Creates a new Template replacing the modules and dataStack from a context.
-         * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
-         */
-        withContext({ modules, data }) {
-            return new Template(this.#fragment, modules, data);
+            this.#evaluator = evaluator;
         }
         /**
-         * Creates a new Template replacing the modules and dataStack from a registry.
-         * @param any registry
+         * Creates a new Template rendering in another scope: the one way to rebind
+         * a compiled template to a registry's modules and data.
+         * @param {ExpressionEvaluator} evaluator
          */
-        withContextFrom(registry) {
-            return this.withContext(registry.context());
+        withEvaluator(evaluator) {
+            return new Template(this.#fragment, evaluator);
         }
         /**
          * Creates a new Template replacing the fragment.
          * @param {DocumentFragment} fragment
          */
         withFragment(fragment) {
-            return new Template(fragment, this.#modules, this.#dataStack);
+            return new Template(fragment, this.#evaluator);
         }
         /**
          * Creates a new Template with a new module added.
@@ -4171,49 +4155,38 @@ var ftl = (function (exports) {
          * @param {{[k: string]: any}} value
          */
         withModule(name, value) {
-            const module = name ? { [name]: value } : value;
-            return new Template(this.#fragment, { ...this.#modules, ...module }, this.#dataStack);
-        }
-        /**
-         * Creates a new Template replacing the modules.
-         * @param {{ [x: string]: any; }?} modules
-         */
-        withModules(modules) {
-            return new Template(this.#fragment, modules, this.#dataStack);
-        }
-        /**
-         * Creates a new Template replacing the data stack.
-         * @param {any[]} dataStack the dataStack
-         */
-        withData(dataStack) {
-            return new Template(this.#fragment, this.#modules, dataStack);
+            return new Template(this.#fragment, this.#evaluator.withModule(name, value));
         }
         /**
          * Creates a new Template with new a data overlay added to the stack.
          * @param {...*} data
          */
         withOverlay(...data) {
-            return new Template(
-                this.#fragment,
-                this.#modules,
-                data.length === 0 ? this.#dataStack : [...this.#dataStack, ...data],
-            );
+            return new Template(this.#fragment, this.#evaluator.withOverlay(...data));
         }
         /**
-         * Evaluates an expression using the configured modules and data.
+         * Evaluates an expression in this template's scope, widened by the overlays.
          * @param {string} expression
-         * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
          * @param {...*} data
          * @returns the evaluated expression result
          */
-        evaluate(expression, mode, ...data) {
-            return new ExpressionEvaluator(this.#modules, this.#dataStack).withOverlay(...data).evaluate(expression, mode);
+        evaluateExpression(expression, ...data) {
+            return this.#evaluator.withOverlay(...data).evaluateExpression(expression);
+        }
+        /**
+         * Evaluates a templated text, the `{{ }}` form, in this template's scope.
+         * @param {string} text
+         * @param {...*} data
+         * @returns the parts the text evaluates to
+         */
+        evaluateTemplated(text, ...data) {
+            return this.#evaluator.withOverlay(...data).evaluateTemplated(text);
         }
         /**
          * Returns an expression evaluator with bound modules and dataStack.
          */
         evaluator() {
-            return new ExpressionEvaluator(this.#modules, this.#dataStack);
+            return this.#evaluator;
         }
         /**
          * Renders the template.
@@ -4227,10 +4200,10 @@ var ftl = (function (exports) {
                     imported.nodeType === Node.DOCUMENT_FRAGMENT_NODE
                         ? imported
                         : (() => {
-                            const d = new DocumentFragment();
-                            d.appendChild(imported);
-                            return d;
-                        })();
+                              const d = new DocumentFragment();
+                              d.appendChild(imported);
+                              return d;
+                          })();
                 const iterator = document.createNodeIterator(
                     fragment,
                     NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
@@ -4241,9 +4214,9 @@ var ftl = (function (exports) {
                     ops.cleanup();
                     if (node.nodeType === Node.TEXT_NODE) {
                         try {
-                            CommandsHandler.textNode(node, node.nodeValue, ops, this.#modules, this.#dataStack);
+                            CommandsHandler.textNode(node, node.nodeValue, ops, this.#evaluator);
                         } catch (ex) {
-                            throw new RenderError('Error evaluating text node', node, ex);
+                            throw RenderError.wrap('Error evaluating text node', node, ex);
                         }
                         continue;
                     }
@@ -4254,9 +4227,11 @@ var ftl = (function (exports) {
                         }
                         const value = ops.popData(el, command);
                         try {
-                            CommandsHandler[command](el, value, ops, this.#modules, this.#dataStack);
+                            CommandsHandler[command](el, value, ops, this.#evaluator);
                         } catch (ex) {
-                            throw new RenderError(`Error evaluating command ${command}`, el, ex);
+                            //the directive is popped before it runs, so the open tag no
+                            //longer carries it: the frame names it and its expression
+                            throw RenderError.wrap(`Error evaluating data-tpl-${toAttr(command)}="${value}"`, el, ex);
                         }
                         if (ops.removed(el)) {
                             break;
@@ -4267,24 +4242,31 @@ var ftl = (function (exports) {
                             continue;
                         }
                         const attributeName = toAttr(dataSetKey);
+                        const expression = ops.popData(el, dataSetKey);
                         try {
-                            const expression = ops.popData(el, dataSetKey);
-                            const evaluated = Expressions.interpret(this.#modules, this.#dataStack, expression);
+                            const evaluated = this.#evaluator.evaluateExpression(expression);
                             if (typeof evaluated === 'boolean') {
-                                Attributes.toggle(el, attributeName, evaluated);
+                                el.toggleAttribute(attributeName, evaluated);
                                 continue;
                             }
                             if (evaluated !== null && evaluated !== undefined) {
                                 el.setAttribute(attributeName, evaluated);
                             }
                         } catch (ex) {
-                            throw new RenderError(`Error evaluating command ${dataSetKey}`, el, ex);
+                            throw RenderError.wrap(`Error evaluating data-tpl-${toAttr(dataSetKey)}="${expression}"`, el, ex);
                         }
                     }
                 }
                 ops.cleanup();
                 return fragment;
             } catch (ex) {
+                //a command, a text node or a nested render already named the node it
+                //failed on: wrapping again would add a frame for the fragment that
+                //contains it, one per level, serializing the whole template into the
+                //message that survives. Only a failure outside those is framed here
+                if (ex instanceof RenderError) {
+                    throw ex;
+                }
                 throw new RenderError('Error rendering template', this.#fragment, ex);
             }
         }
@@ -4303,7 +4285,7 @@ var ftl = (function (exports) {
             el.appendChild(this.render());
         }
         /**
-         * Renders this template appending the resulting fragment to the first Element maching the selector, if exists.
+         * Renders this template on the first Element matching the selector (replacing children), if exists.
          * @param {string} selector
          */
         renderToSelector(selector) {
@@ -4313,7 +4295,7 @@ var ftl = (function (exports) {
             }
         }
         /**
-         * Renders this template appending the resulting fragment to the Element maching the selector, if exists.
+         * Renders this template appending the resulting fragment to the Element matching the selector, if exists.
          * @param {string} selector
          */
         appendToSelector(selector) {
@@ -4337,11 +4319,77 @@ var ftl = (function (exports) {
         }
     }
 
+    /**
+     * A render failure, one frame per nesting level. Each frame names the node it
+     * failed on and what was being evaluated there, so the chain reads as the path
+     * from the template's root down to the offending expression. The frame carries
+     * the node's identification only, an open tag rather than its whole subtree:
+     * the markup is serialized on demand through `html`, and the live node stays on
+     * `node`, so a failure costs no clone and a nested failure does not embed the
+     * page in its own message.
+     */
     class RenderError extends Error {
+        /**
+         * How many frames a chain keeps. The innermost are the specific ones, so a
+         * deeper nesting drops the outer context rather than the failure site: three
+         * frames name the offending node and the two levels that hold it, which is
+         * the path a reader follows without the page arriving with it.
+         */
+        static FRAMES = 3;
+        #node;
+        #depth;
+        /** true when the budget dropped the outer frames of this chain */
+        truncated = false;
+        /**
+         * Frames a failure, unless the chain already spent its budget: then the
+         * cause travels on, marked so a report can say the outer context was
+         * dropped.
+         */
+        static wrap(message, nodeOrFragment, cause) {
+            if (cause instanceof RenderError && cause.depth >= RenderError.FRAMES) {
+                cause.truncated = true;
+                return cause;
+            }
+            return new RenderError(message, nodeOrFragment, cause);
+        }
         constructor(message, nodeOrFragment, cause) {
-            super(`${message} in \`${RenderError.stringify(nodeOrFragment)}\``, { cause });
+            super(`${message} in \`${RenderError.describe(nodeOrFragment)}\``, { cause });
             this.name = 'RenderError';
-            this.node = nodeOrFragment.cloneNode(true);
+            this.#node = nodeOrFragment;
+            this.#depth = (cause instanceof RenderError ? cause.depth : 0) + 1;
+        }
+        /** How many frames this chain carries, this one included. */
+        get depth() {
+            return this.#depth;
+        }
+        /** The node the render failed on, live: it keeps its place in the fragment being built. */
+        get node() {
+            return this.#node;
+        }
+        /** The node's markup, serialized when asked for rather than on every failure. */
+        get html() {
+            return RenderError.stringify(this.#node);
+        }
+        /**
+         * What identifies a node in a frame: an element by its open tag, a text node
+         * by its source, a fragment by the open tags of the elements it holds.
+         */
+        static describe(nodeOrFragment) {
+            if (nodeOrFragment.nodeType === Node.TEXT_NODE) {
+                return RenderError.#ellipsize(String(nodeOrFragment.nodeValue).trim());
+            }
+            if (nodeOrFragment.nodeType === Node.ELEMENT_NODE) {
+                const el = /** @type Element */ (nodeOrFragment);
+                const attrs = Array.from(el.attributes, (a) => ` ${a.name}="${a.value}"`).join('');
+                return RenderError.#ellipsize(`<${el.localName}${attrs}>`);
+            }
+            const children = Array.from(nodeOrFragment.childNodes)
+                .filter((n) => n.nodeType === Node.ELEMENT_NODE || String(n.nodeValue ?? '').trim().length > 0)
+                .map((n) => RenderError.describe(n));
+            return RenderError.#ellipsize(children.join(''));
+        }
+        static #ellipsize(text) {
+            return text.length > 120 ? `${text.slice(0, 120)}…` : text;
         }
         static stringify(nodeOrFragment) {
             const t = document.createElement('template');
@@ -4368,59 +4416,107 @@ var ftl = (function (exports) {
         }
     }
 
+    /**
+     * Tracks the elements waiting to render. `ready` resolves once the queue has
+     * drained and never rejects; the promise kept per element resolves when that
+     * element has rendered and rejects with whatever its upgrade threw.
+     */
     class UpgradeQueue {
         #q = new Map();
+        #readyResolve;
+        #ready = new Promise((resolve) => {
+            this.#readyResolve = resolve;
+        });
         constructor() {
-            document.addEventListener('DOMContentLoaded', async () => {
-                await this.settle();
-                document.dispatchEvent(
-                    new CustomEvent('ftl:ready', {
-                        bubbles: false,
-                        cancelable: false,
-                    }),
-                );
+            Nodes.waitDomContentLoaded(document).then(() => {
+                this.#start();
             });
         }
-        #finished = new Map();
+        /**
+         * Waits for the page's readiness: the promise resolves right after the
+         * ftl:ready event is dispatched, and immediately when that moment already
+         * passed.
+         * @returns {Promise<void>}
+         */
+        ready() {
+            return this.#ready;
+        }
+        async #start() {
+            await this.settled();
+            document.dispatchEvent(
+                new CustomEvent('ftl:ready', {
+                    bubbles: false,
+                    cancelable: false,
+                }),
+            );
+            this.#readyResolve();
+        }
         enqueue(el) {
             if (this.#q.has(el)) {
                 //already upgrading, can happen when disconnecting an element
                 //while it's already queued for upgrade (e.g.: ful-form)
                 return;
             }
-            //settling waits on a signal that only ever resolves, so nothing here attaches a
-            //rejection handler to the upgrade itself: a component that fails is still
-            //reported the way it always was
+            //one entry, two signals: readiness waits on a signal that only ever
+            //resolves, so nothing here attaches a rejection handler to the upgrade
+            //itself and a component that fails is still reported the way it always was
             const { promise: finished, resolve: markFinished } = /** @type {PromiseWithResolvers<void>} */ (
                 Promise.withResolvers()
             );
-            const promise = Nodes.waitParsed(el)
+            const upgrade = Nodes.waitParsed(el)
                 .then(() => el.upgrade())
                 .finally(() => {
                     this.#q.delete(el);
-                    this.#finished.delete(el);
                     markFinished();
                 });
-            this.#q.set(el, promise);
-            this.#finished.set(el, finished);
+            this.#q.set(el, { upgrade, finished });
         }
         /**
-         * Waits for every queued upgrade to settle, including the ones enqueued while
-         * waiting: a component is only queued once its parent connects it, so a single pass
-         * would miss everything nested. A component that fails to upgrade does not hold the
-         * others back, readiness means the queue drained rather than that everything worked.
+         * The one fixed-point loop: drains the accepted entries, including the ones
+         * enqueued while waiting, since a component is only queued once its parent
+         * connects it and a single pass would miss everything nested.
          */
-        async settle() {
-            while (this.#finished.size !== 0) {
-                await Promise.all(Array.from(this.#finished.values()));
+        async #drain(accept, pick) {
+            for (;;) {
+                const pending = Array.from(this.#q)
+                    .filter(([el]) => accept(el))
+                    .map(([, entry]) => pick(entry));
+                if (pending.length === 0) {
+                    return;
+                }
+                await Promise.all(pending);
             }
         }
-        get entries() {
-            return this.#q.entries();
+        /**
+         * Waits for the whole queue to drain. Never rejects: a component that fails
+         * does not hold the others back, and readiness means the queue drained rather
+         * than that everything worked.
+         */
+        settled() {
+            return this.#drain(() => true, (entry) => entry.finished);
+        }
+        /** Waits for the accepted upgrades, rejecting with the first that failed. */
+        upgraded(accept) {
+            return this.#drain(accept, (entry) => entry.upgrade);
+        }
+        /** The pending upgrade of one element, undefined when it is not queued. */
+        whenUpgraded(el) {
+            return this.#q.get(el)?.upgrade;
+        }
+        /** The elements whose upgrade is still pending, in queue order. */
+        pending() {
+            return Array.from(this.#q.keys());
         }
     }
 
-
+    /**
+     * The page's single source of truth for elements, modules, data, components
+     * and attribute mappers. Elements defined before configure() are deferred and
+     * defined by it; from then on every defineElement takes effect immediately.
+     * The exported `registry` singleton is the page's own; a `new Registry()` is a
+     * separate instance, and Rendering and the ftl:ready machinery wait on the
+     * singleton alone.
+     */
     class Registry {
         #tagToClass = {};
         #configured = false;
@@ -4478,30 +4574,20 @@ var ftl = (function (exports) {
                     return value == null ? null : value.join(',');
                 },
             },
-            csvm: {
-                unmarshal(str, name, el) {
-                    if (el.hasAttribute('multiple')) {
-                        return str === null
-                            ? []
-                            : str
-                                  .split(',')
-                                  .map((e) => e.trim())
-                                  .filter((e) => e);
-                    }
-                    return str === null || str === '' ? null : str;
-                },
-                marshal(value, name, el) {
-                    if (el.hasAttribute('multiple')) {
-                        return value === null ? null : value.join(',');
-                    }
-                    return value == null ? null : String(value);
-                },
-            },
         };
         #components = {};
         #modules;
         #data = [];
+        #evaluator = new ExpressionEvaluator(undefined, []);
         #upgradeQueue = new UpgradeQueue();
+        /**
+         * Registers a custom element under its tag: the class is augmented with its
+         * BITS (observed attributes, mappers, templates) and handed to the platform.
+         * Before configure() the definition is deferred, so import order never
+         * matters.
+         * @param {string} tag
+         * @param {*} klass a ParsedElement subclass
+         */
         defineElement(tag, klass) {
             if (!this.#configured) {
                 this.#tagToClass[tag] = klass;
@@ -4510,16 +4596,69 @@ var ftl = (function (exports) {
             this.#augmentAndDefineElement(tag, klass);
             return this;
         }
+        /**
+         * The attribute declarations a class composes along its inheritance chain,
+         * base first: `observed` stay live after the upgrade and drive the property
+         * `propertyOf` names, `attributes` are the configuration read once at it and
+         * drive no property at all. A subclass's entry for a name overrides its
+         * ancestors', so a base class declares what every subclass keeps observing
+         * (a protocol attribute such as Field's disabled claim) and a leaf refines a
+         * mapping, or moves a name's position, without repeating the whole list.
+         *
+         * The walk stops where the platform's own class hierarchy begins: no earlier
+         * stop can work, since a registered ancestor carries an own BITS of its own,
+         * and nothing above the elements declares anything.
+         *
+         * Everything deriving a component's attribute vocabulary reads it here, so
+         * the runtime and whatever documents it cannot walk the chain differently.
+         * @param {*} klass a ParsedElement subclass
+         * @returns {{ observed: string[], attributes: string[] }}
+         */
+        static declarationsOf(klass) {
+            const chain = [];
+            for (let c = klass; c !== null && c !== HTMLElement; c = Object.getPrototypeOf(c)) {
+                chain.unshift(c);
+            }
+            const own = (name) => chain.flatMap((c) => Object.getOwnPropertyDescriptor(c, name)?.value ?? []);
+            return { observed: own('observed'), attributes: own('attributes') };
+        }
+        /**
+         * The property an observed attribute drives, by the platform's own
+         * dash-to-camel rule: the one `dataset` applies, so `clear-invalid-on-change`
+         * would reach `clearInvalidOnChange` the way `data-clear-invalid-on-change`
+         * reaches `dataset.clearInvalidOnChange`. A single-word name is returned
+         * unchanged, which is what every observed attribute in the library is.
+         *
+         * It exists because the observed tier is the one that becomes properties:
+         * without it an attribute could only be observed if its name happened to be
+         * a usable identifier, which is why every multiword observed attribute here
+         * used to be squashed into one word while the configuration tier, which
+         * never becomes a property, spelled the same idea with a dash.
+         *
+         * Only this direction is mapped. A property never derives its attribute: a
+         * setter reflects through `reflectTo`, naming the attribute it writes.
+         * @param {string} attribute
+         * @returns {string}
+         */
+        static propertyOf(attribute) {
+            return attribute.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        }
         #augmentAndDefineElement(tag, klass) {
-            const { observed, attributes, template, templates, slots, mappers } = klass;
-            const observedNames = (observed ?? []).map((a) => a.split(':')[0]);
-            const attrToMapper = [...(attributes ?? []), ...(observed ?? [])].reduce((acc, a) => {
+            const { observed, attributes } = Registry.declarationsOf(klass);
+            const { template, templates, slots, mappers, config } = klass;
+            //a name a subclass re-declares takes the subclass's position, which is
+            //how a field whose value setter reads its own shape attributes declares
+            //that its value lands after them: the order the declarations compose in
+            //is the order the base applies them
+            const declaredNames = observed.map((a) => a.split(':')[0]);
+            const observedNames = [...new Set(declaredNames.reverse())].reverse();
+            const attrToMapper = [...attributes, ...observed].reduce((acc, a) => {
                 const [attr, maybeType] = a.split(':');
-                const type = maybeType?.trim() ?? 'string';
+                const type = maybeType ?? 'string';
                 if (!(type in this.#mappers) && !(type in (mappers ?? {}))) {
                     throw new Error(`unsupported attribute type: ${type}`);
                 }
-                acc[attr.trim()] = mappers?.[type] ?? this.#mappers[type];
+                acc[attr] = mappers?.[type] ?? this.#mappers[type];
                 return acc;
             }, {});
 
@@ -4529,43 +4668,97 @@ var ftl = (function (exports) {
             const nameToTemplate = Object.fromEntries(namesAndTemplates);
 
             klass.BITS = {
+                //the defining registry travels with the definition: an element resolves
+                //its templates and its components through the registry that defined it,
+                //not through whichever one a module happened to import
+                registry: this,
                 enqueue: (el) => this.#upgradeQueue.enqueue(el),
                 SLOTS: slots,
+                //the class's own constants, overlaid on its templates as `config`:
+                //read here with the rest of the declaration, so a page replacing them
+                //does it before configure() like every other definition-time choice
+                CONFIG: config,
                 OBSERVED: observedNames,
+                DECLARED: [...new Set([...observedNames, ...attributes.map((a) => a.split(':')[0])])],
                 ATTR_TO_MAPPER: attrToMapper,
+                //resolved once here rather than at every attribute write
+                ATTR_TO_PROPERTY: Object.fromEntries(observedNames.map((a) => [a, Registry.propertyOf(a)])),
                 TEMPLATES: nameToTemplate,
             };
             customElements.define(tag, klass);
         }
+        /**
+         * Merges one module under its name, its functions resolving as
+         * `#name:fn`; an empty name merges a whole map, whose keys resolve bare,
+         * as `#fn`.
+         * @param {string} name
+         * @param {object} value
+         */
         defineModule(name, value) {
             const module = name ? { [name]: value } : value;
             this.#modules = { ...this.#modules, ...module };
+            this.#rebind();
             return this;
         }
+        /**
+         * Replaces the whole module map.
+         * @param {object} ms
+         */
         defineModules(ms) {
             this.#modules = ms;
+            this.#rebind();
             return this;
         }
+        /**
+         * Registers a named component (a loader, a response mapper), fetched back
+         * through component().
+         * @param {string} name
+         * @param {*} value
+         */
         defineComponent(name, value) {
             this.#components[name] = value;
             return this;
         }
+        /**
+         * Replaces the data stack the templates evaluate over.
+         * @param {...any} data
+         */
         defineData(...data) {
             this.#data = data;
+            this.#rebind();
             return this;
         }
+        /**
+         * Appends to the data stack, the later entry winning a shared name.
+         * @param {...any} data
+         */
         defineOverlay(...data) {
             this.#data = [...this.#data, ...data];
+            this.#rebind();
             return this;
         }
+        /**
+         * Registers a custom attribute mapper type, available to every later
+         * `name:type` declaration.
+         * @param {string} k
+         * @param {{ unmarshal(str: string|null, name: string, el: Element): any, marshal(value: any, name: string, el: Element): string|null }} v
+         */
         defineMapper(k, v) {
             this.#mappers[k] = v;
             return this;
         }
+        /**
+         * Hands the registry over to the plugin's configure.
+         * @param {{ configure(registry: Registry): void }} p
+         */
         plugin(p) {
             p.configure(this);
             return this;
         }
+        /**
+         * Defines every element deferred so far; from then on, defineElement takes
+         * effect immediately.
+         */
         configure() {
             for (const [tag, klass] of Object.entries(this.#tagToClass)) {
                 this.#augmentAndDefineElement(tag, klass);
@@ -4574,15 +4767,42 @@ var ftl = (function (exports) {
             this.#configured = true;
             return this;
         }
-        get upgrades() {
-            return this.#upgradeQueue.entries;
+        /**
+         * Waits for the queued upgrades the filter accepts, rejecting with the first
+         * that failed: the rejecting barrier Rendering is a facade over.
+         * @param {(el: Element) => boolean} accept
+         */
+        settle(accept) {
+            return this.#upgradeQueue.upgraded(accept);
+        }
+        /** The pending upgrade of one element, undefined when it is not queued. */
+        whenUpgraded(el) {
+            return this.#upgradeQueue.whenUpgraded(el);
         }
-        context() {
-            return { modules: this.#modules, data: this.#data };
+        /** The elements whose upgrade is still pending, in queue order. */
+        pending() {
+            return this.#upgradeQueue.pending();
         }
+        /**
+         * Waits for the page's readiness: the same moment the ftl:ready event is
+         * dispatched at, resolving immediately when that moment already passed.
+         * @returns {Promise<void>}
+         */
+        ready() {
+            return this.#upgradeQueue.ready();
+        }
+        #rebind() {
+            this.#evaluator = new ExpressionEvaluator(this.#modules, this.#data);
+        }
+        /**
+         * The scope every template on this registry renders in: the modules and the
+         * data stack, as one value. Replaced whenever either is defined, so a holder
+         * of an older one keeps rendering against what it was handed.
+         */
         evaluator() {
-            return new ExpressionEvaluator(this.#modules, this.#data);
+            return this.#evaluator;
         }
+        /** The component registered under the name, undefined when none is. */
         component(name) {
             return this.#components[name];
         }
@@ -4590,49 +4810,35 @@ var ftl = (function (exports) {
 
     const registry = new Registry();
 
+    /** The Template factories, each bound to the page registry's scope. */
+    /** The Template factories bound to the page's own registry: the same four sources, with its modules and data already applied. */
     class Templates {
         static fromHtml(html) {
-            const { modules, data } = registry.context();
-            return Template.fromHtml(html, modules, ...data);
+            return Template.fromHtml(html).withEvaluator(registry.evaluator());
         }
         static fromSelector(selector) {
-            const { modules, data } = registry.context();
-            return Template.fromSelector(selector, modules, ...data);
+            return Template.fromSelector(selector).withEvaluator(registry.evaluator());
         }
         static fromTemplate(templateEl) {
-            const { modules, data } = registry.context();
-            return Template.fromTemplate(templateEl, modules, ...data);
+            return Template.fromTemplate(templateEl).withEvaluator(registry.evaluator());
         }
         static fromFragment(fragment) {
-            const { modules, data } = registry.context();
-            return Template.fromFragment(fragment, modules, ...data);
+            return Template.fromFragment(fragment).withEvaluator(registry.evaluator());
         }
     }
 
     /**
-     * Waits for the queued upgrades matching the filter, including the ones enqueued while
-     * waiting: a component is only queued once its parent connects it, so a single pass
-     * would miss everything nested.
-     * @param {(el: Element) => boolean} accept
+     * Awaitable rendering barriers over the registry's upgrade queue. These are
+     * the rejecting waits: a failed upgrade among the awaited components rejects
+     * the wait, where registry.ready() only ever means the queue drained and
+     * leaves a failed component to its own unhandled-rejection report.
      */
-    const settle = async (accept) => {
-        for (;;) {
-            const pending = Array.from(registry.upgrades)
-                .filter(([child]) => accept(child))
-                .map(([, promise]) => promise);
-            if (pending.length === 0) {
-                return;
-            }
-            await Promise.all(pending);
-        }
-    };
-
     class Rendering {
-        static async waitFor(el) {
-            await settle((child) => el.contains(child));
+        static waitFor(el) {
+            return registry.settle((child) => el.contains(child));
         }
-        static async waitForChildren(el) {
-            await settle((child) => el !== child && el.contains(child));
+        static waitForChildren(el) {
+            return registry.settle((child) => el !== child && el.contains(child));
         }
     }
 
@@ -4644,122 +4850,422 @@ var ftl = (function (exports) {
      * @property {(val: any, name: string, el: Element) => string|null} marshal
      */
 
-
     class ParsedElement extends HTMLElement {
         static BITS = {
+            //an element the registry never defined still answers the page's own
+            registry,
             enqueue: (el) => {},
             SLOTS: false,
+            /** @type {object|undefined} */
+            CONFIG: undefined,
+            /** @type {string[]} */
             OBSERVED: [],
+            /** @type {string[]} */
+            DECLARED: [],
             /** @type {Record<string, Mapper>} */
             ATTR_TO_MAPPER: {},
+            /** @type {Record<string, string>} */
+            ATTR_TO_PROPERTY: {},
             TEMPLATES: {},
         };
         static get observedAttributes() {
             return this.BITS.OBSERVED;
         }
+        constructor() {
+            super();
+            this.internals = this.attachInternals();
+        }
+        /**
+         * The platform's window into the element's own state. The base attaches it
+         * for every element, so a subclass never calls attachInternals itself: the
+         * platform allows it once, and a second call throws. Form association is a
+         * property of the definition rather than of who attached, so a subclass
+         * declaring `static formAssociated` still gets the form apis here.
+         *
+         * A subclass must not redeclare it: a class field with no initializer
+         * assigns undefined after super() returns, which would wipe it.
+         */
+        internals;
         #parsed = false;
-        #reflecting = 0;
+        #started = false;
+        /** the attributes whose own reflection is in flight */
+        #reflecting = new Set();
+        /** the observed snapshot between the upgrade's start and its render's end */
+        #pending = /** @type {{ [k: string]: any } | null} */ (null);
+        /** the configuration tier, read once at the upgrade and kept for the element's life */
+        #frozen = /** @type {{ [k: string]: any }} */ ({});
         #bits() {
             return /** @type {typeof ParsedElement} */ (this.constructor).BITS;
         }
+        #mapper(attr) {
+            const mapper = this.#bits().ATTR_TO_MAPPER[attr];
+            if (!mapper) {
+                //an attribute the class never declared has no type to read it as:
+                //say so rather than dying on the missing mapper. Content this
+                //element does not own, such as a custom loader's own configuration,
+                //is read with getAttribute, the platform's own answer
+                throw new Error(
+                    `${this.constructor.name} declares no attribute '${attr}': declare it in static observed or static attributes, or read it with getAttribute`,
+                );
+            }
+            return mapper;
+        }
         unmarshal(attr, str) {
-            return this.#bits().ATTR_TO_MAPPER[attr].unmarshal(str, attr, this);
+            return this.#mapper(attr).unmarshal(str, attr, this);
         }
         marshal(attr, value) {
-            return this.#bits().ATTR_TO_MAPPER[attr].marshal(value, attr, this);
+            return this.#mapper(attr).marshal(value, attr, this);
         }
         /**
          * @param {string} [name] - The name of the template target, defaults to 'default'
          */
+        /** The registry that defined this element, the page's own for an undefined one. */
+        get _registry() {
+            return this.#bits().registry;
+        }
+        /**
+         * The component registered under the name on this element's registry, the
+         * one every ful loader and mapper resolves through.
+         * @param {string} name
+         */
+        component(name) {
+            return this.#bits().registry.component(name);
+        }
         template(name) {
-            const { modules, data } = registry.context();
-            let t = this.#bits().TEMPLATES[name ?? 'default'].withData(data).withModules(modules);
-            for (const k of ['l10n', 'config']) {
-                const v = this.constructor[k];
-                if (v) {
-                    t = t.withOverlay({ [k]: v });
-                }
+            const target = this.#bits().TEMPLATES[name ?? 'default'];
+            if (!target) {
+                throw new Error(`no template named '${name ?? 'default'}' on ${this.constructor.name}`);
             }
-            return t;
+            const t = target.withEvaluator(this.#bits().registry.evaluator());
+            const config = this.#bits().CONFIG;
+            return config ? t.withOverlay({ config }) : t;
         }
         connectedCallback() {
-            if (this.#parsed) {
+            if (this.#started) {
                 return;
             }
             this.#bits().enqueue(this);
         }
         attributeChangedCallback(attr, oldValue, newValue) {
-            if (!this.#parsed || oldValue === newValue) {
+            if (oldValue === newValue) {
                 return;
             }
-            if (this.#reflecting > 0) {
+            //the mute is the attribute being reflected, not the element: a component
+            //that legitimately changes another observed attribute while one reflects
+            //is a change like any other, and used to be swallowed
+            if (this.#reflecting.has(attr)) {
                 return;
             }
-            this[attr] = this.unmarshal(attr, newValue);
-        }
-        #disabledBeforeParsed = null;
-        formDisabledCallback(disabled) {
+            //the properties go live only once the render is done: before that, an
+            //attribute write lands in the observed snapshot and the base applies it
+            //with the rest of the declared state
             if (!this.#parsed) {
-                this.#disabledBeforeParsed = disabled;
+                if (this.#pending !== null && attr in this.#pending) {
+                    this.#pending[attr] = this.unmarshal(attr, newValue);
+                }
                 return;
             }
-            Reflect.set(this, 'disabled', disabled);
-            if (disabled) {
-                this.#unclaimFormDisabled();
-            }
-        }
-        //a disabled ancestor fieldset already matches the element through :disabled, and
-        //an attribute of its own would keep the element disabled once the fieldset is
-        //re-enabled, as formDisabledCallback(false) is only delivered on an actual state
-        //change. a claim of its own made while already disabled by ancestry is safe: the
-        //platform fires no callback for it, so it survives the fieldset being re-enabled
-        #unclaimFormDisabled() {
-            if (this.closest('fieldset:disabled')) {
-                this.removeAttribute('disabled');
-            }
+            this[this.#bits().ATTR_TO_PROPERTY[attr]] = this.unmarshal(attr, newValue);
         }
+        /**
+         * Upgrades once: reads the declared attributes, keeps the observed half open
+         * to writes made while the render is pending, applies them to the properties
+         * when the render returns, and only then lets an attribute write forward.
+         *
+         * An observed attribute drives the property the registry's `propertyOf`
+         * names, so a hyphenated attribute is authored with its dashes and read as
+         * a camelCase property. A single-word attribute is its own property name,
+         * which is what every observed attribute in the library is.
+         */
         async upgrade() {
-            if (this.#parsed) {
+            if (this.#started) {
                 return;
             }
-            this.#parsed = true;
+            this.#started = true;
             const slots = this.#bits().SLOTS ? LightSlots.from(this) : undefined;
-            const observed = Object.fromEntries(
-                this.#bits().OBSERVED.map((attribute) => [
+            //both tiers are read here: the observed ones forward to a property once
+            //the render is done, the rest are the element's configuration, read the
+            //one time and never again
+            const declared = Object.fromEntries(
+                this.#bits().DECLARED.map((attribute) => [
                     attribute,
                     this.unmarshal(attribute, this.getAttribute(attribute)),
                 ]),
             );
-            const disabled = this.#disabledBeforeParsed ?? false;
-            await this.render({ slots, observed, disabled });
-            if (disabled) {
-                this.#unclaimFormDisabled();
+            const observedNames = new Set(this.#bits().OBSERVED);
+            this.#frozen = Object.fromEntries(Object.entries(declared).filter(([name]) => !observedNames.has(name)));
+            this.#pending = declared;
+            try {
+                await this.render({ slots });
+                //the declared state reaches the properties once the dom the setters
+                //drive exists, in the order the registry composed the declarations:
+                //a base class's attributes before the subclass's own
+                const properties = this.#bits().ATTR_TO_PROPERTY;
+                for (const name of this.#bits().OBSERVED) {
+                    this[properties[name]] = declared[name];
+                }
+                //the properties go live once the render is done: from here on, an
+                //attribute write forwards to the property. A render that threw
+                //leaves it shut, so a later attribute write cannot reach setters
+                //that assume pieces the failed render never adopted
+                this.#parsed = true;
+                //the same moment, said to css. :defined is true from the constructor,
+                //which is before the dom exists, so a guard written against it reveals
+                //an element that has nothing in it yet
+                this.internals.states.add('rendered');
+            } finally {
+                this.#pending = null;
             }
         }
+        /**
+         * Renders the element from its slots alone: it builds the dom its setters
+         * drive, and the base applies the declared state onto the properties as
+         * soon as it returns. A render needing a declared value while it builds
+         * reads it through `declared(name)`. The slots are undefined for an element
+         * declaring no slots.
+         * @param {{ slots: any }} c
+         */
         render(c) {}
-        reflect(fn) {
-            ++this.#reflecting;
-            try {
-                fn();
-            } finally {
-                --this.#reflecting;
+        /**
+         * The declared value of an attribute, unmarshalled through its mapper.
+         *
+         * A `static attributes` name is the configuration tier: read once when the
+         * upgrade starts and answered unchanged for the element's life, so a later
+         * attribute write does not quietly change how the element behaves. An
+         * observed name answers the snapshot while the render is pending, kept
+         * open to attribute writes landing in that window, and the live attribute
+         * afterwards, the property being live by then.
+         *
+         * The snapshot exists rather than a read of the dom because an element may
+         * write its own observed attributes while it renders, whether a reflection
+         * or a value the platform normalizes on the way in, and what the author
+         * declared is what the base applies, not what the render left behind.
+         * @param {string} name
+         */
+        declared(name) {
+            if (name in this.#frozen) {
+                return this.#frozen[name];
+            }
+            if (this.#pending !== null && name in this.#pending) {
+                return this.#pending[name];
             }
+            return this.unmarshal(name, this.getAttribute(name));
         }
+        /** Whether the element's render completed: the moment its properties went live. */
+        get rendered() {
+            return this.#parsed;
+        }
+        /**
+         * Projects a property back onto its observed attribute, marshalled through
+         * the mapper the attribute was declared with: the one place a property
+         * reaches its attribute, so a setter never has to know how its own type
+         * serializes.
+         *
+         * A value the attribute already carries is not written at all, so reflecting
+         * what an attribute write just delivered ends there rather than looping, and
+         * only the attribute being written is muted while it happens.
+         * @param {string} attr
+         * @param {any} value
+         */
         reflectTo(attr, value) {
-            ++this.#reflecting;
+            const marshalled = this.marshal(attr, value);
+            if (marshalled === this.getAttribute(attr)) {
+                return;
+            }
+            this.#reflecting.add(attr);
             try {
-                Attributes.set(this, attr, this.marshal(attr, value));
+                Attributes.set(this, attr, marshalled);
             } finally {
-                --this.#reflecting;
+                this.#reflecting.delete(attr);
+            }
+        }
+    }
+
+    /**
+     * A flat translations map: dotted keys pointing to a message, or to a plural
+     * leaf carrying a CLDR plural category for each of its forms ('other' is
+     * required, the missing categories of a language fall back to it).
+     *
+     * @typedef {Record<string, string | Record<string, string>>} Messages
+     */
+
+    /**
+     * The receiver contract of the module functions: bound to a proxy over the
+     * data stack when called from a template, or to a plain object by Localization.of().
+     *
+     * @typedef {{ l10n?: Messages, locale?: string }} Receiver
+     */
+
+    const PLACEHOLDER = /\{(\w+)\}/g;
+    const POSITIONAL = /\{(\d+)\}/g;
+    /** @param {any} v @returns {v is Record<string, string>} */
+    const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+    /** every l10n problem is reported once per session: a missing key in a row template must not flood the console */
+    const warned = new Set();
+    const warnOnce = (problem) => {
+        if (!warned.has(problem)) {
+            warned.add(problem);
+            console.warn(`l10n: ${problem}`);
+        }
+    };
+
+    const formatters = new BoundedCache(100);
+    /**
+     * Intl construction is the expensive part of formatting (locale parsing, CLDR
+     * lookups), while formatting on a built instance is near free: a list rendering
+     * a size per row must not rebuild a NumberFormat per cell, so instances are
+     * memoized by constructor, locale and options.
+     *
+     * @param {{ new (locale: string | undefined, options: any): any }} ctor
+     * @param {string | undefined} locale
+     * @param {any} [options]
+     */
+    const formatter = (ctor, locale, options) => {
+        const key = `${ctor.name}|${locale ?? ''}|${options === undefined ? '' : JSON.stringify(options)}`;
+        return formatters.getOrCompute(key, () => new ctor(locale, options));
+    };
+
+    /**
+     * The translations as a template module: `#l10n:t()` for messages, plus date,
+     * number and bytes formatting in the page's locale. The template form and the
+     * imperative `of()` facade both resolve through the registry's scope, so they
+     * always produce the same result for the same key.
+     */
+    class Localization {
+        /**
+         * Resolves a message from the translations and interpolates its arguments.
+         * A single plain object argument interpolates named placeholders
+         * ({name}); anything else interpolates positional ones ({0}).
+         * A plural leaf selects its form through Intl.PluralRules over the
+         * numeric {count} named argument.
+         *
+         * @param {string} key
+         * @param {...any} args
+         * @this {Receiver}
+         * @returns {string} the message, or the key itself when the translations do not carry it
+         */
+        static t(key, ...args) {
+            const messages = this.l10n ?? {};
+            let message = messages[key];
+            if (message === undefined) {
+                warnOnce(`missing message "${key}"`);
+                return key;
+            }
+            if (isPlainObject(message)) {
+                const named = args.length === 1 && isPlainObject(args[0]) ? args[0] : {};
+                if (typeof named.count !== 'number') {
+                    warnOnce(`plural message "${key}" needs a numeric {count}`);
+                    message = message.other;
+                } else {
+                    const locale = this.locale ?? navigator?.language ?? 'en';
+                    const category = formatter(Intl.PluralRules, locale).select(named.count);
+                    message = message[category] ?? message.other;
+                }
+            }
+            if (message === undefined || typeof message === 'object') {
+                warnOnce(`plural message "${key}" has no "other" form`);
+                return key;
+            }
+            if (args.length === 1 && isPlainObject(args[0])) {
+                const named = args[0];
+                return message.replace(PLACEHOLDER, (literal, name) => {
+                    if (!(name in named)) {
+                        warnOnce(`message "${key}" wants {${name}}`);
+                        return literal;
+                    }
+                    return String(named[name]);
+                });
             }
+            if (args.length > 0) {
+                return message.replace(POSITIONAL, (literal, index) => {
+                    const i = Number(index);
+                    if (i >= args.length) {
+                        warnOnce(`message "${key}" wants {${index}}`);
+                        return literal;
+                    }
+                    return String(args[i]);
+                });
+            }
+            return message;
+        }
+
+        /**
+         * Formats a date through Intl.DateTimeFormat in the receiver's locale.
+         *
+         * @param {Date | number} value
+         * @param {Intl.DateTimeFormatOptions} [options]
+         * @this {Receiver}
+         */
+        static date(value, options) {
+            return formatter(Intl.DateTimeFormat, this.locale, options).format(value);
+        }
+
+        /**
+         * Formats a number through Intl.NumberFormat in the receiver's locale.
+         *
+         * @param {number} value
+         * @param {Intl.NumberFormatOptions} [options]
+         * @this {Receiver}
+         */
+        static number(value, options) {
+            return formatter(Intl.NumberFormat, this.locale, options).format(value);
+        }
+
+        /**
+         * Formats a byte size with binary thresholds and literal unit suffixes:
+         * the digits honor the locale, the units are the near-universal KiB/MiB/GiB.
+         * A size exactly on a threshold takes the larger unit: 1024 is 1KiB.
+         *
+         * @param {number} value
+         * @this {Receiver}
+         */
+        static bytes(value) {
+            const format = formatter(Intl.NumberFormat, this.locale, { maximumFractionDigits: 2 }).format;
+            if (value >= 1024 * 1024 * 1024) {
+                return `${format(value / 1024 / 1024 / 1024)}GiB`;
+            }
+            if (value >= 1024 * 1024) {
+                return `${format(value / 1024 / 1024)}MiB`;
+            }
+            if (value >= 1024) {
+                return `${format(value / 1024)}KiB`;
+            }
+            return `${format(value)}B`;
+        }
+
+        /**
+         * An imperative facade over the module functions, resolving the translations
+         * and the locale from the registry overlays on every call.
+         *
+         * @param {{ locale?: string }} [overrides] an explicit locale, winning over the registry one
+         */
+        static of(overrides = {}) {
+            //resolved per call, not per facade: a module-scope `Localization.of()` is
+            //bound before the plugin configures. The registry's own evaluator does the
+            //lookup, so this cannot drift from what a template sees
+            const resolve = (prop) => registry.evaluator().resolve(prop);
+            /** @param {any} fn */
+            const bind =
+                (fn) =>
+                (...args) =>
+                    fn.apply({ l10n: resolve('l10n'), locale: overrides.locale ?? resolve('locale') }, args);
+            return {
+                t: bind(Localization.t),
+                date: bind(Localization.date),
+                number: bind(Localization.number),
+                bytes: bind(Localization.bytes),
+            };
         }
     }
 
     exports.Attributes = Attributes;
+    exports.BoundedCache = BoundedCache;
     exports.ExpressionEvaluator = ExpressionEvaluator;
     exports.Expressions = Expressions;
     exports.Fragments = Fragments;
     exports.LightSlots = LightSlots;
+    exports.Localization = Localization;
     exports.Nodes = Nodes;
     exports.ParsedElement = ParsedElement;
     exports.Registry = Registry;