@optionfactory/fml 8.0.3 → 9.0.0-rc10

package/dist/ftl.mjs

@@ -1,3 +1,43 @@
+/**
+ * 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'),
@@ -35,6 +75,16 @@ const nodes = {
 //
 // 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) {
@@ -219,22 +269,18 @@ function peg$parse(input, options) {
   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]/;
@@ -242,7 +288,7 @@ function peg$parse(input, options) {
   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);
@@ -273,40 +319,33 @@ function peg$parse(input, options) {
   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}  }
@@ -350,8 +389,8 @@ function peg$parse(input, options) {
   }
   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}; 
@@ -364,41 +403,29 @@ function peg$parse(input, options) {
     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);
@@ -406,11 +433,13 @@ function peg$parse(input, options) {
     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 }];
@@ -538,7 +567,7 @@ function peg$parse(input, options) {
   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) {
@@ -562,7 +591,7 @@ function peg$parse(input, options) {
   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) {
@@ -667,7 +696,7 @@ function peg$parse(input, options) {
   function peg$parseBeginNode() {
     let s0;
 
-    const key = peg$currPos * 40 + 2;
+    const key = peg$currPos * 38 + 2;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -692,7 +721,7 @@ function peg$parse(input, options) {
   function peg$parseEndNode() {
     let s0;
 
-    const key = peg$currPos * 40 + 3;
+    const key = peg$currPos * 38 + 3;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -717,7 +746,7 @@ function peg$parse(input, options) {
   function peg$parseBeginHtml() {
     let s0;
 
-    const key = peg$currPos * 40 + 4;
+    const key = peg$currPos * 38 + 4;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -742,7 +771,7 @@ function peg$parse(input, options) {
   function peg$parseEndHtml() {
     let s0;
 
-    const key = peg$currPos * 40 + 5;
+    const key = peg$currPos * 38 + 5;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -767,7 +796,7 @@ function peg$parse(input, options) {
   function peg$parseBeginText() {
     let s0;
 
-    const key = peg$currPos * 40 + 6;
+    const key = peg$currPos * 38 + 6;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -792,7 +821,7 @@ function peg$parse(input, options) {
   function peg$parseEndText() {
     let s0;
 
-    const key = peg$currPos * 40 + 7;
+    const key = peg$currPos * 38 + 7;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -815,9 +844,9 @@ function peg$parse(input, options) {
   }
 
   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) {
@@ -885,40 +914,46 @@ function peg$parse(input, options) {
       }
       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;
         }
       }
     }
@@ -982,40 +1017,46 @@ function peg$parse(input, options) {
           }
           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;
             }
           }
         }
@@ -1036,7 +1077,7 @@ function peg$parse(input, options) {
   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) {
@@ -1064,7 +1105,7 @@ function peg$parse(input, options) {
   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) {
@@ -1133,7 +1174,7 @@ function peg$parse(input, options) {
   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) {
@@ -1182,7 +1223,7 @@ function peg$parse(input, options) {
   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) {
@@ -1231,7 +1272,7 @@ function peg$parse(input, options) {
   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) {
@@ -1305,7 +1346,7 @@ function peg$parse(input, options) {
   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) {
@@ -1379,7 +1420,7 @@ function peg$parse(input, options) {
   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) {
@@ -1441,7 +1482,7 @@ function peg$parse(input, options) {
   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) {
@@ -1503,7 +1544,7 @@ function peg$parse(input, options) {
   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) {
@@ -1545,7 +1586,7 @@ function peg$parse(input, options) {
   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) {
@@ -1606,7 +1647,7 @@ function peg$parse(input, options) {
   function peg$parseAccessExpression() {
     let s0;
 
-    const key = peg$currPos * 40 + 19;
+    const key = peg$currPos * 38 + 19;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -1631,7 +1672,7 @@ function peg$parse(input, options) {
   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) {
@@ -1660,7 +1701,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$parse_();
-      s3 = peg$parseSymbol();
+      s3 = peg$parseWord();
       if (s3 !== peg$FAILED) {
         s0 = peg$f18(s1, s3);
       } else {
@@ -1685,7 +1726,7 @@ function peg$parse(input, options) {
   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) {
@@ -1753,7 +1794,7 @@ function peg$parse(input, options) {
   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) {
@@ -1874,7 +1915,7 @@ function peg$parse(input, options) {
   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) {
@@ -1922,7 +1963,7 @@ function peg$parse(input, options) {
       if (s0 === peg$FAILED) {
         s0 = peg$parseAnyLiteral();
         if (s0 === peg$FAILED) {
-          s0 = peg$parseSymbol();
+          s0 = peg$parseIdentifier();
         }
       }
     }
@@ -1935,7 +1976,7 @@ function peg$parse(input, options) {
   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) {
@@ -2052,7 +2093,7 @@ function peg$parse(input, options) {
   function peg$parseAnyLiteral() {
     let s0;
 
-    const key = peg$currPos * 40 + 25;
+    const key = peg$currPos * 38 + 25;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -2063,20 +2104,11 @@ function peg$parse(input, options) {
 
     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();
         }
       }
     }
@@ -2086,132 +2118,10 @@ function peg$parse(input, options) {
     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) {
@@ -2225,11 +2135,11 @@ function peg$parse(input, options) {
     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;
@@ -2241,7 +2151,7 @@ function peg$parse(input, options) {
       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) {
@@ -2251,7 +2161,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e37); }
+          if (peg$silentFails === 0) { peg$fail(peg$e30); }
         }
       }
     } else {
@@ -2273,7 +2183,7 @@ function peg$parse(input, options) {
           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);
@@ -2282,7 +2192,7 @@ function peg$parse(input, options) {
             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];
@@ -2316,7 +2226,7 @@ function peg$parse(input, options) {
           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) {
@@ -2326,7 +2236,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              if (peg$silentFails === 0) { peg$fail(peg$e30); }
             }
           }
         } else {
@@ -2357,13 +2267,13 @@ function peg$parse(input, options) {
       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 };
@@ -2374,7 +2284,7 @@ function peg$parse(input, options) {
   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) {
@@ -2386,11 +2296,11 @@ function peg$parse(input, options) {
     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;
@@ -2400,7 +2310,7 @@ function peg$parse(input, options) {
         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);
@@ -2409,19 +2319,19 @@ function peg$parse(input, options) {
           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;
@@ -2433,11 +2343,11 @@ function peg$parse(input, options) {
     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;
@@ -2447,7 +2357,7 @@ function peg$parse(input, options) {
           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);
@@ -2456,19 +2366,19 @@ function peg$parse(input, options) {
             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;
@@ -2480,11 +2390,11 @@ function peg$parse(input, options) {
       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 = [];
@@ -2500,14 +2410,14 @@ function peg$parse(input, options) {
             }
           }
           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;
@@ -2521,7 +2431,7 @@ function peg$parse(input, options) {
     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 };
@@ -2532,7 +2442,7 @@ function peg$parse(input, options) {
   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) {
@@ -2556,14 +2466,14 @@ function peg$parse(input, options) {
       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;
@@ -2579,7 +2489,7 @@ function peg$parse(input, options) {
     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 };
@@ -2590,7 +2500,7 @@ function peg$parse(input, options) {
   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) {
@@ -2609,7 +2519,7 @@ function peg$parse(input, options) {
       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) {
@@ -2619,7 +2529,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e47); }
+          if (peg$silentFails === 0) { peg$fail(peg$e40); }
         }
       }
     } else {
@@ -2648,7 +2558,7 @@ function peg$parse(input, options) {
           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;
@@ -2668,7 +2578,7 @@ function peg$parse(input, options) {
           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) {
@@ -2678,7 +2588,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e47); }
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
             }
           }
         } else {
@@ -2707,7 +2617,7 @@ function peg$parse(input, options) {
               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;
@@ -2722,7 +2632,7 @@ function peg$parse(input, options) {
       s1 = peg$FAILED;
     }
     if (s1 !== peg$FAILED) {
-      s1 = peg$f33(s1);
+      s1 = peg$f29(s1);
     }
     s0 = s1;
     if (s0 === peg$FAILED) {
@@ -2735,14 +2645,14 @@ function peg$parse(input, options) {
         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 };
@@ -2753,7 +2663,7 @@ function peg$parse(input, options) {
   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) {
@@ -2834,7 +2744,7 @@ function peg$parse(input, options) {
         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;
@@ -2846,7 +2756,7 @@ function peg$parse(input, options) {
     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 };
@@ -2857,7 +2767,7 @@ function peg$parse(input, options) {
   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) {
@@ -2998,14 +2908,14 @@ function peg$parse(input, options) {
         }
       }
       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;
@@ -3017,7 +2927,7 @@ function peg$parse(input, options) {
     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 };
@@ -3026,9 +2936,9 @@ function peg$parse(input, options) {
   }
 
   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) {
@@ -3040,53 +2950,15 @@ function peg$parse(input, options) {
     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;
@@ -3108,47 +2980,9 @@ function peg$parse(input, options) {
       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;
@@ -3160,7 +2994,7 @@ function peg$parse(input, options) {
     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 };
@@ -3168,10 +3002,10 @@ function peg$parse(input, options) {
     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) {
@@ -3180,55 +3014,74 @@ function peg$parse(input, options) {
       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 };
@@ -3239,7 +3092,7 @@ function peg$parse(input, options) {
   function peg$parseEqualityOp() {
     let s0;
 
-    const key = peg$currPos * 40 + 37;
+    const key = peg$currPos * 38 + 35;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -3248,20 +3101,20 @@ function peg$parse(input, options) {
       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); }
       }
     }
 
@@ -3273,7 +3126,7 @@ function peg$parse(input, options) {
   function peg$parseRelationalOp() {
     let s0;
 
-    const key = peg$currPos * 40 + 38;
+    const key = peg$currPos * 38 + 36;
     const cached = peg$resultsCache[key];
 
     if (cached) {
@@ -3282,36 +3135,36 @@ function peg$parse(input, options) {
       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); }
           }
         }
       }
@@ -3325,7 +3178,7 @@ function peg$parse(input, options) {
   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) {
@@ -3341,7 +3194,7 @@ function peg$parse(input, options) {
       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);
@@ -3350,7 +3203,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e61); }
+        if (peg$silentFails === 0) { peg$fail(peg$e54); }
       }
     }
     peg$silentFails--;
@@ -3394,6 +3247,34 @@ function peg$parse(input, options) {
   }
 }
 
+/**
+ * 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;
@@ -3402,25 +3283,29 @@ class EvaluatingVisitor {
         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;
@@ -3491,7 +3376,7 @@ class EvaluatingVisitor {
         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));
@@ -3504,14 +3389,14 @@ class EvaluatingVisitor {
         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];
@@ -3523,7 +3408,8 @@ class EvaluatingVisitor {
                 }
                 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);
@@ -3542,28 +3428,34 @@ class EvaluatingVisitor {
         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.
@@ -3573,18 +3465,11 @@ class Expressions {
      */
     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.
@@ -3610,6 +3495,12 @@ class Expressions {
     }
 }
 
+/**
+ * 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;
@@ -3627,17 +3518,25 @@ class ExpressionEvaluator {
             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.
@@ -3650,7 +3549,9 @@ class Fragments {
         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
      */
@@ -3693,6 +3594,7 @@ class Fragments {
     }
 }
 
+/** Attribute reads and writes where a nullish value removes the attribute instead of setting it to the string 'null'. */
 class Attributes {
     static id = 0;
     /**
@@ -3728,38 +3630,17 @@ class Attributes {
             .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
@@ -3775,6 +3656,12 @@ class Attributes {
     }
 }
 
+/**
+ * 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.
@@ -3782,12 +3669,19 @@ class LightSlots {
      * @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)];
             });
@@ -3806,13 +3700,14 @@ class LightSlots {
         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.
@@ -3828,26 +3723,78 @@ class Nodes {
         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 });
         });
     }
 
@@ -3882,6 +3829,11 @@ class Nodes {
     }
 }
 
+/**
+ * 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) {
@@ -3919,7 +3871,11 @@ class NodeOperations {
     }
 }
 
+/** 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',
@@ -3927,48 +3883,98 @@ class CommandsHandler {
         '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();
@@ -3993,34 +3999,20 @@ class CommandsHandler {
                 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;
         }
@@ -4029,8 +4021,8 @@ class CommandsHandler {
             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;
             }
@@ -4039,9 +4031,12 @@ class CommandsHandler {
                     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;
             }
@@ -4050,10 +4045,8 @@ class CommandsHandler {
     }
 }
 
-// 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.
@@ -4062,21 +4055,21 @@ const ATTRIBUTE_CACHE_MAX_SIZE = 1000;
  * @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.
@@ -4086,7 +4079,7 @@ class Template {
      * @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));
     }
 
     /**
@@ -4102,7 +4095,7 @@ class Template {
             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));
     }
 
     /**
@@ -4114,7 +4107,7 @@ class Template {
      */
     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));
     }
 
     /**
@@ -4125,42 +4118,33 @@ class Template {
      * @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;
+        this.#evaluator = evaluator;
     }
     /**
-     * Creates a new Template replacing the modules and dataStack from a context.
-     * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
+     * 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
      */
-    withContext({ modules, data }) {
-        return new Template(this.#fragment, modules, data);
-    }
-    /**
-     * Creates a new Template replacing the modules and dataStack from a registry.
-     * @param any registry
-     */
-    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.
@@ -4168,49 +4152,38 @@ class Template {
      * @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.
@@ -4224,10 +4197,10 @@ class Template {
                 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,
@@ -4238,9 +4211,9 @@ class Template {
                 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;
                 }
@@ -4251,9 +4224,11 @@ class Template {
                     }
                     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;
@@ -4264,24 +4239,31 @@ class Template {
                         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);
         }
     }
@@ -4300,7 +4282,7 @@ class Template {
         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) {
@@ -4310,7 +4292,7 @@ class Template {
         }
     }
     /**
-     * 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) {
@@ -4334,11 +4316,77 @@ class Template {
     }
 }
 
+/**
+ * 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');
@@ -4365,59 +4413,107 @@ class RenderError extends Error {
     }
 }
 
+/**
+ * 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;
@@ -4475,30 +4571,20 @@ class Registry {
                 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;
@@ -4507,16 +4593,69 @@ class Registry {
         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;
         }, {});
 
@@ -4526,43 +4665,97 @@ class Registry {
         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);
@@ -4571,15 +4764,42 @@ class Registry {
         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);
+    }
+    /** 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();
     }
-    context() {
-        return { modules: this.#modules, data: this.#data };
+    #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];
     }
@@ -4587,49 +4807,35 @@ class Registry {
 
 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));
     }
 }
 
@@ -4641,117 +4847,414 @@ class Rendering {
  * @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;
+        }
+        //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;
         }
-        if (this.#reflecting > 0) {
+        //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) {
+            if (this.#pending !== null && attr in this.#pending) {
+                this.#pending[attr] = this.unmarshal(attr, newValue);
+            }
             return;
         }
-        this[attr] = this.unmarshal(attr, newValue);
+        this[this.#bits().ATTR_TO_PROPERTY[attr]] = this.unmarshal(attr, newValue);
     }
     /**
-     * The disabled protocol follows the semantics of a native form control:
-     *
-     * - the `disabled` attribute on the host is the field's own claim, and nothing
-     *   but its author ever writes or removes it, in markup or through the property.
-     *   The framework never claims on the form's behalf, so there is nothing to
-     *   unclaim and nothing to lose: a field declared disabled inside a disabled
-     *   `<fieldset>` stays disabled when the fieldset comes back, exactly like a
-     *   native input keeps its attribute.
-     * - the effective state is the claim OR a disabled fieldset ancestry, which the
-     *   platform maintains on its own: `:disabled` matches both, a disabled field is
-     *   left out of the submitted values, and the inner native controls are reached
-     *   by the ancestry as descendants of the fieldset.
-     * - the `disabled` property reflects the claim only, like a native input's: a
-     *   field disabled by its ancestry reads `false` while `matches(':disabled')`
-     *   tells the effective state. Un-claiming inside a disabled fieldset cannot
-     *   enable the field.
-     * - the inner controls mirror the claim and nothing else: the ancestry state is
-     *   never written anywhere, so it can never go stale, and the browser composes
-     *   the two on its own when it disables and re-enables a fieldset's descendants.
+     * 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.
      *
-     * Because of this, formDisabledCallback carries nothing the framework needs to
-     * apply, and the protocol does not define it.
+     * 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)),
             ]),
         );
-        //the declared claim is what render receives: the ancestry state is not
-        //passed around, it is already where it needs to be
-        await this.render({ slots, observed, disabled: this.hasAttribute('disabled') });
-    }
-    render(c) {}
-    reflect(fn) {
-        ++this.#reflecting;
+        const observedNames = new Set(this.#bits().OBSERVED);
+        this.#frozen = Object.fromEntries(Object.entries(declared).filter(([name]) => !observedNames.has(name)));
+        this.#pending = declared;
         try {
-            fn();
+            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.#reflecting;
+            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) {}
+    /**
+     * 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);
         }
     }
 }
 
-export { Attributes, ExpressionEvaluator, Expressions, Fragments, LightSlots, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
+/**
+ * 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),
+        };
+    }
+}
+
+export { Attributes, BoundedCache, ExpressionEvaluator, Expressions, Fragments, LightSlots, Localization, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
 //# sourceMappingURL=ftl.mjs.map