@optionfactory/fml 9.0.0-rc3 → 9.0.0-rc31

package/dist/ftl.mjs

@@ -1,10 +1,6 @@
 /**
- * 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.
+ * A Map bounded by entry count, evicting the oldest entry when full. A hit does
+ * not refresh an entry: eviction follows insertion order, not use.
  */
 class BoundedCache {
     #max;
@@ -33,6 +29,7 @@ class BoundedCache {
         this.#entries.set(key, value);
         return value;
     }
+    /** @returns {number} the number of entries held */
     get size() {
         return this.#entries.size;
     }
@@ -71,14 +68,10 @@ const nodes = {
     },
 };
 
-// @generated by Peggy 5.1.0.
+// @generated by Peggy 5.1.1.
 //
 // 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],
@@ -141,10 +134,9 @@ class peg$SyntaxError extends SyntaxError {
       return s;
     }
 
-    function literalEscape(s) {
+    function escape(s, special) {
       return unicodeEscape(s
-        .replace(/\\/g, "\\\\")
-        .replace(/"/g,  "\\\"")
+        .replace(special, "\\$&")
         .replace(/\0/g, "\\0")
         .replace(/\t/g, "\\t")
         .replace(/\n/g, "\\n")
@@ -153,18 +145,12 @@ class peg$SyntaxError extends SyntaxError {
         .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x"  + hex(ch)));
     }
 
+    function literalEscape(s) {
+      return escape(s, /[\\"]/g);
+    }
+
     function classEscape(s) {
-      return unicodeEscape(s
-        .replace(/\\/g, "\\\\")
-        .replace(/\]/g, "\\]")
-        .replace(/\^/g, "\\^")
-        .replace(/-/g,  "\\-")
-        .replace(/\0/g, "\\0")
-        .replace(/\t/g, "\\t")
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/[\x00-\x0F]/g,          ch => "\\x0" + hex(ch))
-        .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x"  + hex(ch)));
+      return escape(s, /[\\\]^-]/g);
     }
 
     const DESCRIBE_EXPECTATION_FNS = {
@@ -282,14 +268,6 @@ function peg$parse(input, options) {
   const peg$c53 = "<=";
   const peg$c54 = "<";
 
-  const peg$r0 = /^[^\\{]/;
-  const peg$r1 = /^[0-9]/;
-  const peg$r2 = /^[^']/;
-  const peg$r3 = /^[^"]/;
-  const peg$r4 = /^[^\\`{]/;
-  const peg$r5 = /^[a-zA-Z$_]/;
-  const peg$r6 = /^[a-zA-Z$_0-9]/;
-  const peg$r7 = /^[ \t\n\r]/;
 
   const peg$e0 = peg$literalExpectation("{{{{", false);
   const peg$e1 = peg$literalExpectation("}}}}", false);
@@ -447,9 +425,10 @@ function peg$parse(input, options) {
   let peg$maxFailExpected = options.peg$maxFailExpected || [];
   let peg$silentFails = options.peg$silentFails | 0;
 
-  let peg$resultsCache = {};
+  let peg$resultsCache = new Map();
 
   let peg$result;
+  let peg$charCode;
 
   if (options.startRule) {
     if (!(options.startRule in peg$startRuleFunctions)) {
@@ -568,7 +547,7 @@ function peg$parse(input, options) {
     let s0, s1;
 
     const key = peg$currPos * 38 + 0;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -577,13 +556,13 @@ function peg$parse(input, options) {
     }
 
     s0 = [];
-    s1 = peg$parseTemplatedExpression();
-    while (s1 !== peg$FAILED) {
-      s0.push(s1);
+    for (;;) {
       s1 = peg$parseTemplatedExpression();
+      if (s1 === peg$FAILED) { break; }
+      s0.push(s1);
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -592,7 +571,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4;
 
     const key = peg$currPos * 38 + 1;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -688,7 +667,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -697,7 +676,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 2;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -713,7 +692,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e0); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -722,7 +701,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 3;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -738,7 +717,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e1); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -747,7 +726,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 4;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -763,7 +742,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e2); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -772,7 +751,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 5;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -788,7 +767,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e3); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -797,7 +776,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 6;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -813,7 +792,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e4); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -822,7 +801,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 7;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -838,7 +817,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e5); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -847,7 +826,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4, s5, s6;
 
     const key = peg$currPos * 38 + 8;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -857,211 +836,104 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = [];
-    s2 = peg$currPos;
-    s3 = [];
-    s4 = input.charAt(peg$currPos);
-    if (peg$r0.test(s4)) {
-      peg$currPos++;
-    } else {
-      s4 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e6); }
-    }
-    if (s4 !== peg$FAILED) {
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
+    for (;;) {
+      s2 = peg$currPos;
+      s3 = [];
+      for (;;) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r0.test(s4)) {
+        if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 92 || peg$charCode === 123)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$e6); }
         }
+        if (s4 === peg$FAILED) { break; }
+        s3.push(s4);
       }
-    } else {
-      s3 = peg$FAILED;
-    }
-    if (s3 !== peg$FAILED) {
-      s2 = input.substring(s2, peg$currPos);
-    } else {
-      s2 = s3;
-    }
-    if (s2 === peg$FAILED) {
-      s2 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 92) {
-        s3 = peg$c7;
-        peg$currPos++;
-      } else {
+      if (s3.length < 1) {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e7); }
       }
       if (s3 !== peg$FAILED) {
-        if (input.length > peg$currPos) {
-          s4 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e8); }
-        }
-        if (s4 !== peg$FAILED) {
-          s2 = peg$f4(s4);
-        } else {
-          peg$currPos = s2;
-          s2 = peg$FAILED;
-        }
+        s2 = input.substring(s2, peg$currPos);
       } else {
-        peg$currPos = s2;
-        s2 = peg$FAILED;
+        s2 = s3;
       }
       if (s2 === peg$FAILED) {
         s2 = peg$currPos;
-        s3 = peg$currPos;
-        if (input.charCodeAt(peg$currPos) === 123) {
-          s4 = peg$c9;
+        if (input.charCodeAt(peg$currPos) === 92) {
+          s3 = peg$c7;
           peg$currPos++;
         } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e9); }
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e7); }
         }
-        if (s4 !== peg$FAILED) {
-          s5 = peg$currPos;
-          peg$silentFails++;
-          if (input.charCodeAt(peg$currPos) === 123) {
-            s6 = peg$c9;
+        if (s3 !== peg$FAILED) {
+          if (input.length > peg$currPos) {
+            s4 = input.charAt(peg$currPos);
             peg$currPos++;
           } else {
-            s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e9); }
-          }
-          peg$silentFails--;
-          if (s6 === peg$FAILED) {
-            s5 = undefined;
-          } else {
-            peg$currPos = s5;
-            s5 = peg$FAILED;
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e8); }
           }
-          if (s5 !== peg$FAILED) {
-            s4 = [s4, s5];
-            s3 = s4;
+          if (s4 !== peg$FAILED) {
+            s2 = peg$f4(s4);
           } else {
-            peg$currPos = s3;
-            s3 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-        if (s3 !== peg$FAILED) {
-          s2 = input.substring(s2, peg$currPos);
-        } else {
-          s2 = s3;
-        }
-      }
-    }
-    if (s2 !== peg$FAILED) {
-      while (s2 !== peg$FAILED) {
-        s1.push(s2);
-        s2 = peg$currPos;
-        s3 = [];
-        s4 = input.charAt(peg$currPos);
-        if (peg$r0.test(s4)) {
-          peg$currPos++;
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e6); }
-        }
-        if (s4 !== peg$FAILED) {
-          while (s4 !== peg$FAILED) {
-            s3.push(s4);
-            s4 = input.charAt(peg$currPos);
-            if (peg$r0.test(s4)) {
-              peg$currPos++;
-            } else {
-              s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e6); }
-            }
+            peg$currPos = s2;
+            s2 = peg$FAILED;
           }
         } else {
-          s3 = peg$FAILED;
-        }
-        if (s3 !== peg$FAILED) {
-          s2 = input.substring(s2, peg$currPos);
-        } else {
-          s2 = s3;
+          peg$currPos = s2;
+          s2 = peg$FAILED;
         }
         if (s2 === peg$FAILED) {
           s2 = peg$currPos;
-          if (input.charCodeAt(peg$currPos) === 92) {
-            s3 = peg$c7;
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 123) {
+            s4 = peg$c9;
             peg$currPos++;
           } else {
-            s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e7); }
-          }
-          if (s3 !== peg$FAILED) {
-            if (input.length > peg$currPos) {
-              s4 = input.charAt(peg$currPos);
-              peg$currPos++;
-            } else {
-              s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e8); }
-            }
-            if (s4 !== peg$FAILED) {
-              s2 = peg$f4(s4);
-            } else {
-              peg$currPos = s2;
-              s2 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s2;
-            s2 = peg$FAILED;
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e9); }
           }
-          if (s2 === peg$FAILED) {
-            s2 = peg$currPos;
-            s3 = peg$currPos;
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 123) {
-              s4 = peg$c9;
+              s6 = peg$c9;
               peg$currPos++;
             } else {
-              s4 = peg$FAILED;
+              s6 = peg$FAILED;
               if (peg$silentFails === 0) { peg$fail(peg$e9); }
             }
-            if (s4 !== peg$FAILED) {
-              s5 = peg$currPos;
-              peg$silentFails++;
-              if (input.charCodeAt(peg$currPos) === 123) {
-                s6 = peg$c9;
-                peg$currPos++;
-              } else {
-                s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e9); }
-              }
-              peg$silentFails--;
-              if (s6 === peg$FAILED) {
-                s5 = undefined;
-              } else {
-                peg$currPos = s5;
-                s5 = peg$FAILED;
-              }
-              if (s5 !== peg$FAILED) {
-                s4 = [s4, s5];
-                s3 = s4;
-              } else {
-                peg$currPos = s3;
-                s3 = peg$FAILED;
-              }
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = undefined;
             } else {
-              peg$currPos = s3;
-              s3 = peg$FAILED;
+              peg$currPos = s5;
+              s5 = peg$FAILED;
             }
-            if (s3 !== peg$FAILED) {
-              s2 = input.substring(s2, peg$currPos);
+            if (s5 !== peg$FAILED) {
+              s4 = [s4, s5];
+              s3 = s4;
             } else {
-              s2 = s3;
+              peg$currPos = s3;
+              s3 = peg$FAILED;
             }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          if (s3 !== peg$FAILED) {
+            s2 = input.substring(s2, peg$currPos);
+          } else {
+            s2 = s3;
           }
         }
       }
-    } else {
+      if (s2 === peg$FAILED) { break; }
+      s1.push(s2);
+    }
+    if (s1.length < 1) {
       s1 = peg$FAILED;
     }
     if (s1 !== peg$FAILED) {
@@ -1069,7 +941,7 @@ function peg$parse(input, options) {
     }
     s0 = s1;
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1078,7 +950,7 @@ function peg$parse(input, options) {
     let s0, s2;
 
     const key = peg$currPos * 38 + 9;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1097,7 +969,7 @@ function peg$parse(input, options) {
       s0 = peg$FAILED;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1106,7 +978,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5, s7, s9;
 
     const key = peg$currPos * 38 + 10;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1166,7 +1038,7 @@ function peg$parse(input, options) {
       s0 = peg$parseElvisExpression();
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1175,7 +1047,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5;
 
     const key = peg$currPos * 38 + 11;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1215,7 +1087,7 @@ function peg$parse(input, options) {
       s0 = peg$parseNullCoalescingExpression();
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1224,7 +1096,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5;
 
     const key = peg$currPos * 38 + 12;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1264,7 +1136,7 @@ function peg$parse(input, options) {
       s0 = peg$parseOrExpression();
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1273,7 +1145,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s5, s7;
 
     const key = peg$currPos * 38 + 13;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1285,30 +1157,7 @@ function peg$parse(input, options) {
     s1 = peg$parseAndExpression();
     if (s1 !== peg$FAILED) {
       s2 = [];
-      s3 = peg$currPos;
-      peg$parse_();
-      if (input.substr(peg$currPos, 2) === peg$c22) {
-        s5 = peg$c22;
-        peg$currPos += 2;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e14); }
-      }
-      if (s5 !== peg$FAILED) {
-        peg$parse_();
-        s7 = peg$parseAndExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = s7;
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      for (;;) {
         s3 = peg$currPos;
         peg$parse_();
         if (input.substr(peg$currPos, 2) === peg$c22) {
@@ -1331,6 +1180,8 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+        if (s3 === peg$FAILED) { break; }
+        s2.push(s3);
       }
       s0 = peg$f10(s1, s2);
     } else {
@@ -1338,7 +1189,7 @@ function peg$parse(input, options) {
       s0 = peg$FAILED;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1347,7 +1198,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s5, s7;
 
     const key = peg$currPos * 38 + 14;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1359,30 +1210,7 @@ function peg$parse(input, options) {
     s1 = peg$parseEqExpression();
     if (s1 !== peg$FAILED) {
       s2 = [];
-      s3 = peg$currPos;
-      peg$parse_();
-      if (input.substr(peg$currPos, 2) === peg$c24) {
-        s5 = peg$c24;
-        peg$currPos += 2;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e15); }
-      }
-      if (s5 !== peg$FAILED) {
-        peg$parse_();
-        s7 = peg$parseEqExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = s7;
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      for (;;) {
         s3 = peg$currPos;
         peg$parse_();
         if (input.substr(peg$currPos, 2) === peg$c24) {
@@ -1405,6 +1233,8 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+        if (s3 === peg$FAILED) { break; }
+        s2.push(s3);
       }
       s0 = peg$f11(s1, s2);
     } else {
@@ -1412,7 +1242,7 @@ function peg$parse(input, options) {
       s0 = peg$FAILED;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1421,7 +1251,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s5, s7;
 
     const key = peg$currPos * 38 + 15;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1433,24 +1263,7 @@ function peg$parse(input, options) {
     s1 = peg$parseRelExpression();
     if (s1 !== peg$FAILED) {
       s2 = [];
-      s3 = peg$currPos;
-      peg$parse_();
-      s5 = peg$parseEqualityOp();
-      if (s5 !== peg$FAILED) {
-        peg$parse_();
-        s7 = peg$parseRelExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = peg$f12(s1, s5, s7);
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      for (;;) {
         s3 = peg$currPos;
         peg$parse_();
         s5 = peg$parseEqualityOp();
@@ -1467,6 +1280,8 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+        if (s3 === peg$FAILED) { break; }
+        s2.push(s3);
       }
       s0 = peg$f13(s1, s2);
     } else {
@@ -1474,7 +1289,7 @@ function peg$parse(input, options) {
       s0 = peg$FAILED;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1483,7 +1298,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s5, s7;
 
     const key = peg$currPos * 38 + 16;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1495,24 +1310,7 @@ function peg$parse(input, options) {
     s1 = peg$parseNotExpression();
     if (s1 !== peg$FAILED) {
       s2 = [];
-      s3 = peg$currPos;
-      peg$parse_();
-      s5 = peg$parseRelationalOp();
-      if (s5 !== peg$FAILED) {
-        peg$parse_();
-        s7 = peg$parseNotExpression();
-        if (s7 !== peg$FAILED) {
-          s3 = peg$f14(s1, s5, s7);
-        } else {
-          peg$currPos = s3;
-          s3 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      for (;;) {
         s3 = peg$currPos;
         peg$parse_();
         s5 = peg$parseRelationalOp();
@@ -1529,6 +1327,8 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+        if (s3 === peg$FAILED) { break; }
+        s2.push(s3);
       }
       s0 = peg$f15(s1, s2);
     } else {
@@ -1536,7 +1336,7 @@ function peg$parse(input, options) {
       s0 = peg$FAILED;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1545,7 +1345,7 @@ function peg$parse(input, options) {
     let s0, s1, s3;
 
     const key = peg$currPos * 38 + 17;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1578,7 +1378,7 @@ function peg$parse(input, options) {
       s0 = peg$parseAccess();
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1587,7 +1387,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s4, s5;
 
     const key = peg$currPos * 38 + 18;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1600,29 +1400,20 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       peg$parse_();
       s3 = [];
-      s4 = peg$currPos;
-      s5 = peg$parseAccessExpression();
-      if (s5 !== peg$FAILED) {
-        peg$parse_();
-        s4 = s5;
-      } else {
-        peg$currPos = s4;
-        s4 = peg$FAILED;
-      }
-      if (s4 !== peg$FAILED) {
-        while (s4 !== peg$FAILED) {
-          s3.push(s4);
-          s4 = peg$currPos;
-          s5 = peg$parseAccessExpression();
-          if (s5 !== peg$FAILED) {
-            peg$parse_();
-            s4 = s5;
-          } else {
-            peg$currPos = s4;
-            s4 = peg$FAILED;
-          }
+      for (;;) {
+        s4 = peg$currPos;
+        s5 = peg$parseAccessExpression();
+        if (s5 !== peg$FAILED) {
+          peg$parse_();
+          s4 = s5;
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
         }
-      } else {
+        if (s4 === peg$FAILED) { break; }
+        s3.push(s4);
+      }
+      if (s3.length < 1) {
         s3 = peg$FAILED;
       }
       if (s3 !== peg$FAILED) {
@@ -1639,7 +1430,7 @@ function peg$parse(input, options) {
       s0 = peg$parseGroupingExpression();
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1648,7 +1439,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 19;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1664,7 +1455,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1673,7 +1464,7 @@ function peg$parse(input, options) {
     let s0, s1, s3;
 
     const key = peg$currPos * 38 + 20;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1718,7 +1509,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e17); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1727,7 +1518,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s4, s6;
 
     const key = peg$currPos * 38 + 21;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1786,7 +1577,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e20); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1795,7 +1586,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s4, s5, s6, s7, s9;
 
     const key = peg$currPos * 38 + 22;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1837,30 +1628,7 @@ function peg$parse(input, options) {
         s4 = null;
       }
       s5 = [];
-      s6 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s7 = peg$c34;
-        peg$currPos++;
-      } else {
-        s7 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
-      }
-      if (s7 !== peg$FAILED) {
-        peg$parse_();
-        s9 = peg$parseTernaryExpression();
-        if (s9 !== peg$FAILED) {
-          peg$parse_();
-          s6 = s9;
-        } else {
-          peg$currPos = s6;
-          s6 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s6;
-        s6 = peg$FAILED;
-      }
-      while (s6 !== peg$FAILED) {
-        s5.push(s6);
+      for (;;) {
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 44) {
           s7 = peg$c34;
@@ -1883,6 +1651,8 @@ function peg$parse(input, options) {
           peg$currPos = s6;
           s6 = peg$FAILED;
         }
+        if (s6 === peg$FAILED) { break; }
+        s5.push(s6);
       }
       if (input.charCodeAt(peg$currPos) === 41) {
         s6 = peg$c36;
@@ -1907,7 +1677,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e23); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1916,7 +1686,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5;
 
     const key = peg$currPos * 38 + 23;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -1968,7 +1738,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -1977,7 +1747,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s4, s5, s6, s7, s9;
 
     const key = peg$currPos * 38 + 24;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2011,30 +1781,7 @@ function peg$parse(input, options) {
           s4 = null;
         }
         s5 = [];
-        s6 = peg$currPos;
-        if (input.charCodeAt(peg$currPos) === 44) {
-          s7 = peg$c34;
-          peg$currPos++;
-        } else {
-          s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e25); }
-        }
-        if (s7 !== peg$FAILED) {
-          peg$parse_();
-          s9 = peg$parseTernaryExpression();
-          if (s9 !== peg$FAILED) {
-            peg$parse_();
-            s6 = s9;
-          } else {
-            peg$currPos = s6;
-            s6 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s6;
-          s6 = peg$FAILED;
-        }
-        while (s6 !== peg$FAILED) {
-          s5.push(s6);
+        for (;;) {
           s6 = peg$currPos;
           if (input.charCodeAt(peg$currPos) === 44) {
             s7 = peg$c34;
@@ -2057,6 +1804,8 @@ function peg$parse(input, options) {
             peg$currPos = s6;
             s6 = peg$FAILED;
           }
+          if (s6 === peg$FAILED) { break; }
+          s5.push(s6);
         }
         if (input.charCodeAt(peg$currPos) === 41) {
           s6 = peg$c36;
@@ -2085,7 +1834,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e27); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2094,7 +1843,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 25;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2113,7 +1862,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2122,7 +1871,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
     const key = peg$currPos * 38 + 26;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2146,25 +1895,18 @@ function peg$parse(input, options) {
     }
     s4 = peg$currPos;
     s5 = [];
-    s6 = input.charAt(peg$currPos);
-    if (peg$r1.test(s6)) {
-      peg$currPos++;
-    } else {
-      s6 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e30); }
-    }
-    if (s6 !== peg$FAILED) {
-      while (s6 !== peg$FAILED) {
-        s5.push(s6);
-        s6 = input.charAt(peg$currPos);
-        if (peg$r1.test(s6)) {
-          peg$currPos++;
-        } else {
-          s6 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e30); }
-        }
+    for (;;) {
+      s6 = input.charAt(peg$currPos);
+      if ((peg$charCode = s6.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
+        peg$currPos++;
+      } else {
+        s6 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e30); }
       }
-    } else {
+      if (s6 === peg$FAILED) { break; }
+      s5.push(s6);
+    }
+    if (s5.length < 1) {
       s5 = peg$FAILED;
     }
     if (s5 !== peg$FAILED) {
@@ -2178,22 +1920,16 @@ function peg$parse(input, options) {
       }
       if (s7 !== peg$FAILED) {
         s8 = [];
-        s9 = input.charAt(peg$currPos);
-        if (peg$r1.test(s9)) {
-          peg$currPos++;
-        } else {
-          s9 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e30); }
-        }
-        while (s9 !== peg$FAILED) {
-          s8.push(s9);
+        for (;;) {
           s9 = input.charAt(peg$currPos);
-          if (peg$r1.test(s9)) {
+          if ((peg$charCode = s9.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
             peg$currPos++;
           } else {
             s9 = peg$FAILED;
             if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
+          if (s9 === peg$FAILED) { break; }
+          s8.push(s9);
         }
         s7 = [s7, s8];
         s6 = s7;
@@ -2221,25 +1957,18 @@ function peg$parse(input, options) {
       }
       if (s5 !== peg$FAILED) {
         s6 = [];
-        s7 = input.charAt(peg$currPos);
-        if (peg$r1.test(s7)) {
-          peg$currPos++;
-        } else {
-          s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e30); }
-        }
-        if (s7 !== peg$FAILED) {
-          while (s7 !== peg$FAILED) {
-            s6.push(s7);
-            s7 = input.charAt(peg$currPos);
-            if (peg$r1.test(s7)) {
-              peg$currPos++;
-            } else {
-              s7 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e30); }
-            }
+        for (;;) {
+          s7 = input.charAt(peg$currPos);
+          if ((peg$charCode = s7.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
           }
-        } else {
+          if (s7 === peg$FAILED) { break; }
+          s6.push(s7);
+        }
+        if (s6.length < 1) {
           s6 = peg$FAILED;
         }
         if (s6 !== peg$FAILED) {
@@ -2276,7 +2005,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e28); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2285,7 +2014,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4;
 
     const key = peg$currPos * 38 + 27;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2305,22 +2034,16 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
       s3 = [];
-      s4 = input.charAt(peg$currPos);
-      if (peg$r2.test(s4)) {
-        peg$currPos++;
-      } else {
-        s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e33); }
-      }
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
+      for (;;) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r2.test(s4)) {
+        if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 39)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$e33); }
         }
+        if (s4 === peg$FAILED) { break; }
+        s3.push(s4);
       }
       s2 = input.substring(s2, peg$currPos);
       if (input.charCodeAt(peg$currPos) === 39) {
@@ -2352,22 +2075,16 @@ function peg$parse(input, options) {
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         s3 = [];
-        s4 = input.charAt(peg$currPos);
-        if (peg$r3.test(s4)) {
-          peg$currPos++;
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e35); }
-        }
-        while (s4 !== peg$FAILED) {
-          s3.push(s4);
+        for (;;) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r3.test(s4)) {
+          if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 34)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) { peg$fail(peg$e35); }
           }
+          if (s4 === peg$FAILED) { break; }
+          s3.push(s4);
         }
         s2 = input.substring(s2, peg$currPos);
         if (input.charCodeAt(peg$currPos) === 34) {
@@ -2398,16 +2115,13 @@ function peg$parse(input, options) {
         }
         if (s1 !== peg$FAILED) {
           s2 = [];
-          s3 = peg$parseTemplateStringExpression();
-          if (s3 === peg$FAILED) {
-            s3 = peg$parseTemplateStringLiteral();
-          }
-          while (s3 !== peg$FAILED) {
-            s2.push(s3);
+          for (;;) {
             s3 = peg$parseTemplateStringExpression();
             if (s3 === peg$FAILED) {
               s3 = peg$parseTemplateStringLiteral();
             }
+            if (s3 === peg$FAILED) { break; }
+            s2.push(s3);
           }
           if (input.charCodeAt(peg$currPos) === 96) {
             s3 = peg$c42;
@@ -2434,7 +2148,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e31); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2443,7 +2157,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5;
 
     const key = peg$currPos * 38 + 28;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2492,7 +2206,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e37); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2501,134 +2215,71 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4;
 
     const key = peg$currPos * 38 + 29;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
 
       return cached.result;
     }
-
-    peg$silentFails++;
-    s0 = peg$currPos;
-    s1 = [];
-    s2 = peg$currPos;
-    s3 = [];
-    s4 = input.charAt(peg$currPos);
-    if (peg$r4.test(s4)) {
-      peg$currPos++;
-    } else {
-      s4 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e40); }
-    }
-    if (s4 !== peg$FAILED) {
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
-        s4 = input.charAt(peg$currPos);
-        if (peg$r4.test(s4)) {
-          peg$currPos++;
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e40); }
-        }
-      }
-    } else {
-      s3 = peg$FAILED;
-    }
-    if (s3 !== peg$FAILED) {
-      s2 = input.substring(s2, peg$currPos);
-    } else {
-      s2 = s3;
-    }
-    if (s2 === peg$FAILED) {
-      s2 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 92) {
-        s3 = peg$c7;
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e7); }
-      }
-      if (s3 !== peg$FAILED) {
-        if (input.length > peg$currPos) {
-          s4 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e8); }
-        }
-        if (s4 !== peg$FAILED) {
-          s2 = peg$f28(s4);
-        } else {
-          peg$currPos = s2;
-          s2 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s2;
-        s2 = peg$FAILED;
-      }
-    }
-    if (s2 !== peg$FAILED) {
-      while (s2 !== peg$FAILED) {
-        s1.push(s2);
-        s2 = peg$currPos;
-        s3 = [];
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    for (;;) {
+      s2 = peg$currPos;
+      s3 = [];
+      for (;;) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r4.test(s4)) {
+        if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 92 || peg$charCode === 96 || peg$charCode === 123)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$e40); }
         }
-        if (s4 !== peg$FAILED) {
-          while (s4 !== peg$FAILED) {
-            s3.push(s4);
-            s4 = input.charAt(peg$currPos);
-            if (peg$r4.test(s4)) {
-              peg$currPos++;
-            } else {
-              s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e40); }
-            }
-          }
+        if (s4 === peg$FAILED) { break; }
+        s3.push(s4);
+      }
+      if (s3.length < 1) {
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s2 = input.substring(s2, peg$currPos);
+      } else {
+        s2 = s3;
+      }
+      if (s2 === peg$FAILED) {
+        s2 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 92) {
+          s3 = peg$c7;
+          peg$currPos++;
         } else {
           s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e7); }
         }
         if (s3 !== peg$FAILED) {
-          s2 = input.substring(s2, peg$currPos);
-        } else {
-          s2 = s3;
-        }
-        if (s2 === peg$FAILED) {
-          s2 = peg$currPos;
-          if (input.charCodeAt(peg$currPos) === 92) {
-            s3 = peg$c7;
+          if (input.length > peg$currPos) {
+            s4 = input.charAt(peg$currPos);
             peg$currPos++;
           } else {
-            s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e7); }
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e8); }
           }
-          if (s3 !== peg$FAILED) {
-            if (input.length > peg$currPos) {
-              s4 = input.charAt(peg$currPos);
-              peg$currPos++;
-            } else {
-              s4 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e8); }
-            }
-            if (s4 !== peg$FAILED) {
-              s2 = peg$f28(s4);
-            } else {
-              peg$currPos = s2;
-              s2 = peg$FAILED;
-            }
+          if (s4 !== peg$FAILED) {
+            s2 = peg$f28(s4);
           } else {
             peg$currPos = s2;
             s2 = peg$FAILED;
           }
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
         }
       }
-    } else {
+      if (s2 === peg$FAILED) { break; }
+      s1.push(s2);
+    }
+    if (s1.length < 1) {
       s1 = peg$FAILED;
     }
     if (s1 !== peg$FAILED) {
@@ -2655,7 +2306,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e39); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2664,7 +2315,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s5, s6, s7, s9;
 
     const key = peg$currPos * 38 + 30;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2689,30 +2340,7 @@ function peg$parse(input, options) {
       }
       peg$parse_();
       s5 = [];
-      s6 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s7 = peg$c34;
-        peg$currPos++;
-      } else {
-        s7 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
-      }
-      if (s7 !== peg$FAILED) {
-        peg$parse_();
-        s9 = peg$parseTernaryExpression();
-        if (s9 !== peg$FAILED) {
-          peg$parse_();
-          s6 = s9;
-        } else {
-          peg$currPos = s6;
-          s6 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s6;
-        s6 = peg$FAILED;
-      }
-      while (s6 !== peg$FAILED) {
-        s5.push(s6);
+      for (;;) {
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 44) {
           s7 = peg$c34;
@@ -2735,6 +2363,8 @@ function peg$parse(input, options) {
           peg$currPos = s6;
           s6 = peg$FAILED;
         }
+        if (s6 === peg$FAILED) { break; }
+        s5.push(s6);
       }
       if (input.charCodeAt(peg$currPos) === 93) {
         s6 = peg$c31;
@@ -2759,7 +2389,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e41); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2768,7 +2398,7 @@ function peg$parse(input, options) {
     let s0, s1, s3, s4, s5, s6, s7, s8, s9, s11, s13;
 
     const key = peg$currPos * 38 + 31;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2820,50 +2450,7 @@ function peg$parse(input, options) {
       }
       s4 = peg$parse_();
       s5 = [];
-      s6 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 44) {
-        s7 = peg$c34;
-        peg$currPos++;
-      } else {
-        s7 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e25); }
-      }
-      if (s7 !== peg$FAILED) {
-        s8 = peg$parse_();
-        s9 = peg$parseStringLiteral();
-        if (s9 !== peg$FAILED) {
-          peg$parse_();
-          if (input.charCodeAt(peg$currPos) === 58) {
-            s11 = peg$c15;
-            peg$currPos++;
-          } else {
-            s11 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e11); }
-          }
-          if (s11 !== peg$FAILED) {
-            peg$parse_();
-            s13 = peg$parseTernaryExpression();
-            if (s13 !== peg$FAILED) {
-              peg$parse_();
-              s6 = [ s9, s13 ];
-            } else {
-              peg$currPos = s6;
-              s6 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s6;
-            s6 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s6;
-          s6 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s6;
-        s6 = peg$FAILED;
-      }
-      while (s6 !== peg$FAILED) {
-        s5.push(s6);
+      for (;;) {
         s6 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 44) {
           s7 = peg$c34;
@@ -2906,6 +2493,8 @@ function peg$parse(input, options) {
           peg$currPos = s6;
           s6 = peg$FAILED;
         }
+        if (s6 === peg$FAILED) { break; }
+        s5.push(s6);
       }
       if (input.charCodeAt(peg$currPos) === 125) {
         s6 = peg$c43;
@@ -2930,7 +2519,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e42); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -2939,7 +2528,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4;
 
     const key = peg$currPos * 38 + 32;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -2997,7 +2586,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e43); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3006,7 +2595,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3, s4;
 
     const key = peg$currPos * 38 + 33;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -3017,7 +2606,7 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$currPos;
     s2 = input.charAt(peg$currPos);
-    if (peg$r5.test(s2)) {
+    if ((peg$charCode = s2.charCodeAt(0), (peg$charCode >= 97 && peg$charCode <= 122) || (peg$charCode >= 65 && peg$charCode <= 90) || peg$charCode === 36 || peg$charCode === 95)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
@@ -3025,22 +2614,16 @@ function peg$parse(input, options) {
     }
     if (s2 !== peg$FAILED) {
       s3 = [];
-      s4 = input.charAt(peg$currPos);
-      if (peg$r6.test(s4)) {
-        peg$currPos++;
-      } else {
-        s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e46); }
-      }
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
+      for (;;) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r6.test(s4)) {
+        if ((peg$charCode = s4.charCodeAt(0), (peg$charCode >= 97 && peg$charCode <= 122) || (peg$charCode >= 65 && peg$charCode <= 90) || peg$charCode === 36 || peg$charCode === 95 || (peg$charCode >= 48 && peg$charCode <= 57))) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$e46); }
         }
+        if (s4 === peg$FAILED) { break; }
+        s3.push(s4);
       }
       s2 = [s2, s3];
       s1 = s2;
@@ -3054,7 +2637,7 @@ function peg$parse(input, options) {
       s0 = s1;
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3063,7 +2646,7 @@ function peg$parse(input, options) {
     let s0, s1;
 
     const key = peg$currPos * 38 + 34;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -3084,7 +2667,7 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e47); }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3093,7 +2676,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 35;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -3118,7 +2701,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3127,7 +2710,7 @@ function peg$parse(input, options) {
     let s0;
 
     const key = peg$currPos * 38 + 36;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -3170,7 +2753,7 @@ function peg$parse(input, options) {
       }
     }
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3179,7 +2762,7 @@ function peg$parse(input, options) {
     let s0, s1;
 
     const key = peg$currPos * 38 + 37;
-    const cached = peg$resultsCache[key];
+    const cached = peg$resultsCache.get(key);
 
     if (cached) {
       peg$currPos = cached.nextPos;
@@ -3189,26 +2772,20 @@ function peg$parse(input, options) {
 
     peg$silentFails++;
     s0 = [];
-    s1 = input.charAt(peg$currPos);
-    if (peg$r7.test(s1)) {
-      peg$currPos++;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e54); }
-    }
-    while (s1 !== peg$FAILED) {
-      s0.push(s1);
+    for (;;) {
       s1 = input.charAt(peg$currPos);
-      if (peg$r7.test(s1)) {
+      if ((peg$charCode = s1.charCodeAt(0), peg$charCode === 32 || peg$charCode === 9 || peg$charCode === 10 || peg$charCode === 13)) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
         if (peg$silentFails === 0) { peg$fail(peg$e54); }
       }
+      if (s1 === peg$FAILED) { break; }
+      s0.push(s1);
     }
     peg$silentFails--;
 
-    peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+    peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
 
     return s0;
   }
@@ -3250,10 +2827,10 @@ 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.
+ * like an object one.
  * @param {any[]} dataStack
  * @param {string|symbol} prop
+ * @returns {any} undefined when no overlay carries the name
  */
 const resolveInStack = (dataStack, prop) => {
     if (prop === 'self') {
@@ -3270,6 +2847,8 @@ const resolveInStack = (dataStack, prop) => {
     return undefined;
 };
 
+const BOUND = Symbol('BOUND');
+
 /**
  * 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
@@ -3278,9 +2857,11 @@ const resolveInStack = (dataStack, prop) => {
 class EvaluatingVisitor {
     #modules;
     #dataStack;
-    constructor(modules, dataStack) {
+    #bound;
+    constructor(modules, dataStack, bound) {
         this.#modules = modules;
         this.#dataStack = dataStack;
+        this.#bound = bound ?? dataStack.length;
     }
     #resolve(prop) {
         return resolveInStack(this.#dataStack, prop);
@@ -3304,8 +2885,9 @@ class EvaluatingVisitor {
     #cached_resolve_proxy;
     #resolve_proxy() {
         if (!this.#cached_resolve_proxy) {
+            const bound = (name) => resolveInStack(this.#dataStack.slice(0, this.#bound), name);
             this.#cached_resolve_proxy = new Proxy(this.#dataStack, {
-                get: (target, prop) => this.#resolve(prop),
+                get: (target, prop) => (prop === BOUND ? bound : this.#resolve(prop)),
             });
         }
         return this.#cached_resolve_proxy;
@@ -3317,8 +2899,7 @@ class EvaluatingVisitor {
         return this.visit(node.lhs) || this.visit(node.rhs);
     }
     [nodes.nullc](node) {
-        const lhs = this.visit(node.lhs);
-        return lhs !== null && lhs !== undefined ? lhs : this.visit(node.rhs);
+        return this.visit(node.lhs) ?? this.visit(node.rhs);
     }
     [nodes.not](node) {
         return !this.visit(node.expr);
@@ -3385,8 +2966,7 @@ class EvaluatingVisitor {
         return this.visit(node.cond) ? this.visit(node.ifTrue) : this.visit(node.ifFalse);
     }
     [nodes.elv](node) {
-        const cond = this.visit(node.cond);
-        return cond ? cond : this.visit(node.ifFalse);
+        return this.visit(node.cond) || this.visit(node.ifFalse);
     }
     [nodes.access](node) {
         let prev;
@@ -3452,16 +3032,33 @@ class EvaluatingVisitor {
  * spliced into the expression text.
  */
 class Expressions {
+    /** Parses the whole text as one expression: `user.name`. */
     static MODE_EXPRESSION = Symbol('MODE_EXPRESSION');
+    /**
+     * Parses text with interpolations, `Hello {{ user.name }}`, evaluating to
+     * its parts: `{ type, value }` for each literal run and each `{{ }}` (text),
+     * `{{{ }}}` (html) or `{{{{ }}}}` (node) interpolation, in order.
+     */
     static MODE_TEMPLATED = Symbol('MODE_TEMPLATED');
+    /**
+     * The key under which the receiver of a module function answers a lookup
+     * against the bound data alone: `this[Expressions.BOUND](name)` resolves
+     * the name in the layers the scope was created with (a registry's data,
+     * the data handed to a Template factory) and never in an overlay pushed
+     * afterwards, by `data-tpl-each`, `data-tpl-with` or `withOverlay`. It is
+     * how a module reads what the page configured without the rendered data
+     * being able to supply or replace it. No name on the data stack reaches it.
+     */
+    static BOUND = BOUND;
 
     static #astCache = new BoundedCache(1000);
 
     /**
-     * Parses an expression.
+     * Parses an expression, caching the ast by mode and text.
      * @param {string} expression
-     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
-     * @returns the ast
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode] MODE_EXPRESSION when omitted
+     * @returns {any} the ast
+     * @throws a peggy syntax error when the text does not parse
      */
     static parse(expression, mode) {
         const key = mode?.toString() + expression;
@@ -3472,26 +3069,28 @@ class Expressions {
         );
     }
     /**
-     * Evaluates an expression.
+     * Evaluates a parsed ast against the modules and the data stack.
      * @param {{[k: string]: any } | null | undefined } modules
-     * @param {any[]} dataStack
-     * @param {any} ast
-     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
-     * @returns the result
+     * @param {any[]} dataStack innermost overlay last
+     * @param {any} ast what `parse` answered
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode] the mode it was parsed in
+     * @param {number} [bound] how many layers, from the outermost, are the bound data; all of them when omitted
+     * @returns {any} the value, or the list of parts in MODE_TEMPLATED
      */
-    static evaluate(modules, dataStack, ast, mode) {
-        return new EvaluatingVisitor(modules, dataStack).visitRoot(ast, mode === Expressions.MODE_TEMPLATED);
+    static evaluate(modules, dataStack, ast, mode, bound) {
+        return new EvaluatingVisitor(modules, dataStack, bound).visitRoot(ast, mode === Expressions.MODE_TEMPLATED);
     }
     /**
      * Parses and evaluates an expression.
      * @param {{ [x: string]: any; } | null | undefined} modules
-     * @param {any[]} dataStack
+     * @param {any[]} dataStack innermost overlay last
      * @param {string} expression
-     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
-     * @returns the result
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode] MODE_EXPRESSION when omitted
+     * @param {number} [bound] how many layers, from the outermost, are the bound data; all of them when omitted
+     * @returns {any} the value, or the list of parts in MODE_TEMPLATED
      */
-    static interpret(modules, dataStack, expression, mode) {
-        return Expressions.evaluate(modules, dataStack, Expressions.parse(expression, mode), mode);
+    static interpret(modules, dataStack, expression, mode, bound) {
+        return Expressions.evaluate(modules, dataStack, Expressions.parse(expression, mode), mode, bound);
     }
 }
 
@@ -3500,48 +3099,89 @@ class Expressions {
  * 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.
+ *
+ * The layers an evaluator is created with are its bound data; the overlays
+ * pushed afterwards are not. A bare identifier resolves against both, while a
+ * module function can ask for the bound data alone through `Expressions.BOUND`.
  */
 class ExpressionEvaluator {
     #modules;
     #dataStack;
-    constructor(modules, dataStack) {
+    #bound;
+    /**
+     * @param {{ [k: string]: any } | null | undefined} modules
+     * @param {any[]} dataStack innermost overlay last
+     * @param {number} [bound] how many layers, from the outermost, are the bound data; all of them when omitted
+     */
+    constructor(modules, dataStack, bound) {
         this.#modules = modules;
         this.#dataStack = dataStack;
+        this.#bound = bound ?? dataStack.length;
     }
+    /**
+     * A new evaluator with one more module: `#name:fn()` resolves into it, and an
+     * empty name merges a whole map whose functions resolve bare, as `#fn()`.
+     * @param {string} name
+     * @param {object} value
+     * @returns {ExpressionEvaluator}
+     */
     withModule(name, value) {
         const module = name ? { [name]: value } : value;
-        return new ExpressionEvaluator({ ...this.#modules, ...module }, this.#dataStack);
+        return new ExpressionEvaluator({ ...this.#modules, ...module }, this.#dataStack, this.#bound);
     }
+    /**
+     * A new evaluator with the data pushed as the innermost overlays, the last
+     * one winning a shared name. The bound data stays what it was.
+     * @param {...any} data
+     * @returns {ExpressionEvaluator}
+     */
     withOverlay(...data) {
         return new ExpressionEvaluator(
             this.#modules,
             data.length === 0 ? this.#dataStack : [...this.#dataStack, ...data],
+            this.#bound,
         );
     }
     /**
      * 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
+     * @returns {any} undefined when no overlay carries the name
      */
     resolve(name) {
         return resolveInStack(this.#dataStack, name);
     }
-    /** Evaluates an expression against this scope. */
+    /**
+     * Evaluates an expression against this scope.
+     * @param {string} expression
+     * @returns {any}
+     */
     evaluateExpression(expression) {
-        return Expressions.interpret(this.#modules, this.#dataStack, expression, Expressions.MODE_EXPRESSION);
+        return Expressions.interpret(
+            this.#modules,
+            this.#dataStack,
+            expression,
+            Expressions.MODE_EXPRESSION,
+            this.#bound,
+        );
     }
-    /** Evaluates a templated text, the `{{ }}` form, against this scope. */
+    /**
+     * Evaluates a templated text, the `{{ }}` form, against this scope.
+     * @param {string} text
+     * @returns {{ type: symbol, value: any }[]} its parts, as MODE_TEMPLATED describes
+     */
     evaluateTemplated(text) {
-        return Expressions.interpret(this.#modules, this.#dataStack, text, Expressions.MODE_TEMPLATED);
+        return Expressions.interpret(this.#modules, this.#dataStack, text, Expressions.MODE_TEMPLATED, this.#bound);
     }
 }
 
-/** Creates and inspects the DocumentFragments a Template renders into. */
+/** Creates, serializes and inspects DocumentFragments. */
 class Fragments {
     /**
-     * Creates a DocumentFragment from an string.
-     * @param  {...string} html
-     * @returns {DocumentFragment} the fragment
+     * Parses html into a DocumentFragment adopted by the document, each piece
+     * trimmed and the pieces joined.
+     * @param {...string} html
+     * @returns {DocumentFragment}
      */
     static fromHtml(...html) {
         const el = document.createElement('template');
@@ -3549,11 +3189,11 @@ class Fragments {
         return document.adoptNode(el.content);
     }
     /**
-     * Creates a string representation (HTML) of a DocumentFragment, consuming it:
-     * the nodes are moved out, not copied, and the fragment is left empty. Pass
+     * Serializes a fragment, or a single node, to html, consuming it: the nodes
+     * are moved out, not copied, and a fragment is left empty. Pass
      * `fragment.cloneNode(true)` to keep the original usable.
-     * @param {DocumentFragment} fragment
-     * @returns {string} the html
+     * @param {DocumentFragment|Node} fragment
+     * @returns {string}
      */
     static toHtml(fragment) {
         var el = document.createElement('template');
@@ -3561,17 +3201,17 @@ class Fragments {
         return el.innerHTML;
     }
     /**
-     * Checks if a fragment contains only blank text nodes
+     * Whether a fragment holds no element and no text but whitespace.
      * @param {DocumentFragment} fragment
-     * @returns {boolean} true if the fragment is blank
+     * @returns {boolean}
      */
     static isBlank(fragment) {
         return fragment.childElementCount === 0 && fragment.textContent.trim() === '';
     }
     /**
-     * Creates a DocumentFragment from nodes.
-     * @param  {...Node} nodes
-     * @returns {DocumentFragment} the fragment
+     * Moves the nodes, in order, into a new DocumentFragment.
+     * @param {...Node} nodes
+     * @returns {DocumentFragment}
      */
     static from(...nodes) {
         const fragment = new DocumentFragment();
@@ -3581,9 +3221,10 @@ class Fragments {
         return fragment;
     }
     /**
-     * Creates a DocumentFragment from childNodes of an element.
+     * Moves the children of a node into a new DocumentFragment, leaving the
+     * node empty.
      * @param {Node} el
-     * @returns {DocumentFragment} the fragment
+     * @returns {DocumentFragment}
      */
     static fromChildNodes(el) {
         const fragment = new DocumentFragment();
@@ -3594,23 +3235,23 @@ class Fragments {
     }
 }
 
-/** Attribute reads and writes where a nullish value removes the attribute instead of setting it to the string 'null'. */
+/** Attribute helpers: unique ids, defaults, prefixed forwarding, and writes where a nullish value removes the attribute. */
 class Attributes {
     static id = 0;
     /**
-     * Creates a unique id with the given prefix.
+     * A page-unique id under the prefix, as `prefix-n`.
      * @param {string} prefix
-     * @returns
+     * @returns {string}
      */
     static uid(prefix) {
         return `${prefix}-${++Attributes.id}`;
     }
     /**
-     * Sets an attribute if not present.
+     * Sets an attribute when the element does not carry it.
      * @param {Element} el
      * @param {string} k
      * @param {string} v
-     * @returns
+     * @returns {string|null} the attribute's value afterwards
      */
     static defaultValue(el, k, v) {
         if (!el.hasAttribute(k)) {
@@ -3619,7 +3260,9 @@ class Attributes {
         return el.getAttribute(k);
     }
     /**
-     * Forwards prefixed attributes from an element to another (removing the prefix).
+     * Copies every attribute whose name starts with the prefix onto another
+     * element, under the name without the prefix. `<prefix>class` adds its
+     * classes to the target's instead of replacing them.
      * @param {string} prefix
      * @param {Element} from
      * @param {Element} to
@@ -3642,7 +3285,7 @@ class Attributes {
             });
     }
     /**
-     * Sets the value of an attribute. nullish values remove the attribute.
+     * Sets an attribute, or removes it when the value is nullish.
      * @param {Element} el
      * @param {string} attr
      * @param {string | null | undefined} value
@@ -3664,13 +3307,14 @@ class Attributes {
  */
 class LightSlots {
     /**
-     * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
+     * Takes an element's children apart into slots, leaving the element empty.
+     * A named child is removed and contributes what `slotFromNode` answers;
+     * children sharing a name are gathered in order. A child with an empty
+     * `slot` belongs to the default slot, in document order among the rest.
      * @param {Element} el
-     * @returns the slots
+     * @returns {Record<string, DocumentFragment>} the slots by name, `default` always present
      */
     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');
@@ -3685,7 +3329,7 @@ class LightSlots {
                 el.removeAttribute('slot');
                 return [slot, LightSlots.slotFromNode(el)];
             });
-        const slots = {};
+        const slots = Object.create(null);
         slots.default = new DocumentFragment();
         slots.default.append(...el.childNodes);
         for (const [name, el] of namedSlots) {
@@ -3696,6 +3340,12 @@ class LightSlots {
         }
         return slots;
     }
+    /**
+     * What a slotted node contributes: a template's content, the parsed markup
+     * of a `<script type="text/html">`, or the node itself.
+     * @param {Element} el
+     * @returns {Element|DocumentFragment}
+     */
     static slotFromNode(el) {
         if (el instanceof HTMLTemplateElement) {
             return document.adoptNode(el.content);
@@ -3707,12 +3357,13 @@ class LightSlots {
     }
 }
 
-/** Waits for the parser and for the document, for elements that upgrade before their own markup is complete. */
+/** Waits on the parser and the document, and queries an element's own children. */
 class Nodes {
     /**
-     * Checks if an element is already parsed.
+     * Whether the parser has moved past the element: the element, or one of
+     * its ancestors, has a next sibling.
      * @param {Element} el
-     * @returns
+     * @returns {boolean}
      */
     static isParsed(el) {
         for (let c = /** @type {Node | null} */ (el); c; c = c.parentNode) {
@@ -3724,13 +3375,12 @@ class Nodes {
     }
 
     /**
-     * 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.
+     * Waits for the document's DOMContentLoaded. Resolves at once when that
+     * moment already passed, and for a document with no view, which receives
+     * no events. Never resolves early for a document still running its
+     * deferred scripts.
+     * @param {Document} doc
+     * @returns {Promise<void>}
      */
     static waitDomContentLoaded(doc) {
         if (doc.readyState === 'loading') {
@@ -3743,7 +3393,13 @@ class Nodes {
         }
         const win = doc.defaultView;
         if (win === null) {
-            //a viewless document can receive no event at all
+            return Promise.resolve();
+        }
+        // interactive spans both the deferred scripts and the time between DOMContentLoaded and load
+        const [navigation] = /** @type {PerformanceNavigationTiming[]} */ (
+            win.performance?.getEntriesByType('navigation') ?? []
+        );
+        if (navigation?.domContentLoadedEventStart > 0) {
             return Promise.resolve();
         }
         return new Promise((resolve) => {
@@ -3762,22 +3418,12 @@ class Nodes {
      * 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>}
+     * that is already parsed, or once the parser has finished the document.
+     * @param {Element} el
+     * @returns {Promise<Element>} the element
      */
     static waitParsed(el) {
-        if (Nodes.isParsed(el)) {
+        if (Nodes.isParsed(el) || el.ownerDocument.readyState !== 'loading') {
             return Promise.resolve(el);
         }
         return new Promise((resolve) => {
@@ -3799,10 +3445,10 @@ class Nodes {
     }
 
     /**
-     * Returns the first child of the element element (if exists) matching the selector.
-     * @param {Element} el
+     * The first child element matching the selector, descendants excluded.
+     * @param {Element|DocumentFragment} el
      * @param {string} selector
-     * @returns
+     * @returns {Element|null}
      */
     static queryChildren(el, selector) {
         for (const c of el.children) {
@@ -3813,10 +3459,10 @@ class Nodes {
         return null;
     }
     /**
-     * Returns all children of the element matching the selector.
-     * @param {Element} el
+     * Every child element matching the selector, descendants excluded.
+     * @param {Element|DocumentFragment} el
      * @param {string} selector
-     * @returns
+     * @returns {Element[]}
      */
     static queryChildrenAll(el, selector) {
         const r = [];
@@ -3873,9 +3519,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)
+    /**
+     * The order the commands run in on one element, each seeing the node as the
+     * ones before left it: tplIf gates before tplWith and tplEach push their
+     * overlay, tplWhen gates after, inside the scope that overlay opened.
+     */
     static ORDERED_COMMANDS = [
         'tplIf',
         'tplWith',
@@ -3886,8 +3534,7 @@ class CommandsHandler {
         'tplRemove',
         'tplVerbatim',
     ];
-    //same body as tplWhen: the two differ only in ORDERED_COMMANDS position,
-    //if evaluates in the outer scope, before with/each
+    /** Removes the node when the expression is falsy, evaluated before tplWith and tplEach open their overlay. */
     static tplIf(node, expression, ops, evaluator) {
         const accept = evaluator.evaluateExpression(expression);
         if (!accept) {
@@ -3902,49 +3549,37 @@ class CommandsHandler {
             .render();
         ops.replace(node, newNode);
     }
+    /**
+     * Renders the node once per entry, in place of the node. A Map iterates as
+     * `{ key, value }` entries in its own order, a plain object as `{ key, value }`
+     * entries in `Object.entries` order, and any other iterable as itself; a
+     * value that is none of these throws. Each render sees its entry under
+     * `data-tpl-var`, or as the whole overlay without one. `data-tpl-stat` names
+     * an overlay beneath the entry carrying `index`, `count`, `size`, `first`,
+     * `last`, `even` and `odd`, so an entry property of the same name wins; the
+     * size, and so `last`, is null for a collection that knows neither its
+     * `length` nor its `size`, which is never consumed to learn it.
+     */
     static tplEach(node, expression, ops, evaluator) {
         const varName = ops.popData(node, 'tplVar');
         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 proto =
+            evaluated === null || typeof evaluated !== 'object' ? undefined : Object.getPrototypeOf(evaluated);
+        const plain = !evaluated?.[Symbol.iterator] && (proto === Object.prototype || proto === null);
+        const dict = plain ? Object.entries(evaluated) : null;
+        const keyed = evaluated instanceof Map ? [...evaluated] : dict;
         const entries = keyed === null ? evaluated : keyed.map(([key, value]) => ({ key, value }));
         if (!entries?.[Symbol.iterator]) {
             throw new Error(`Expected an iterable got '${evaluated}'`);
         }
-        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;
+        const measured = statName ? entries : null;
+        const counted = typeof measured?.length === 'number' ? measured.length : measured?.size;
+        const size = typeof counted === 'number' ? counted : null;
         let index = 0;
         for (const v of entries) {
+            const item = varName ? { [varName]: v } : v;
             const stat = {
                 index,
                 count: index + 1,
@@ -3954,16 +3589,13 @@ class CommandsHandler {
                 even: index % 2 === 0,
                 odd: index % 2 === 1,
             };
-            ops.prepend(
-                node,
-                template.withOverlay({ [statName]: stat }, varName ? { [varName]: v } : v).render(),
-            );
+            const layers = statName ? [{ [statName]: stat }, item] : [item];
+            ops.prepend(node, template.withOverlay(...layers).render());
             ++index;
         }
         ops.remove(node);
     }
-    //same body as tplIf: the two differ only in ORDERED_COMMANDS position,
-    //when evaluates after with/each, in the scope their overlay opened
+    /** Removes the node when the expression is falsy, evaluated in the overlay tplWith or tplEach opened. */
     static tplWhen(node, expression, ops, evaluator) {
         const accept = evaluator.evaluateExpression(expression);
         if (!accept) {
@@ -3977,12 +3609,8 @@ class CommandsHandler {
     static tplRemove(node, value, ops, evaluator) {
         switch (value.toLowerCase()) {
             case 'tag': {
-                const fragment = new DocumentFragment();
-                while (node.firstChild) {
-                    fragment.appendChild(node.firstChild);
-                }
+                const fragment = Fragments.fromChildNodes(node);
                 if ('tplVerbatim' in node.dataset) {
-                    //we are removing the parent element so we have to handle the lower priority commands
                     ops.popData(node, 'tplVerbatim');
                     ops.replace(node, fragment);
                 } else {
@@ -4018,6 +3646,9 @@ class CommandsHandler {
         }
         const tuples = Array.isArray(attributesAndValues[0]) ? attributesAndValues : [attributesAndValues];
         tuples.forEach(([k, v]) => {
+            if (v === null || v === undefined) {
+                return;
+            }
             node.setAttribute(k, v);
         });
     }
@@ -4045,12 +3676,10 @@ class CommandsHandler {
     }
 }
 
-// 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.
- * Uses a cache lookup to avoid repetitive regex/string splitting.
+ * The attribute a `tpl` dataset key targets: `tplAriaLabel` is `aria-label`.
  * @param {string} dataSetKey
  * @returns {string}
  */
@@ -4072,38 +3701,40 @@ function toAttr(dataSetKey) {
  */
 class Template {
     /**
-     * Creates a template from a string.
+     * Creates a template from html.
      * @param {string} html
      * @param {{ [k: string] : any }?} [modules]
-     * @param {...*} data
-     * @returns the template
+     * @param {...*} data the data stack, innermost last
+     * @returns {Template}
      */
     static fromHtml(html, modules, ...data) {
         return new Template(Fragments.fromHtml(html), new ExpressionEvaluator(modules, data));
     }
 
     /**
-     * Creates a template from the content of the first template element matching the selector.
+     * Creates a template from the content of the first element matching the
+     * selector, which is adopted: the template element is left empty.
      * @param {string} selector for an HTMLTemplateElement
      * @param {{ [k: string] : any }?} [modules]
-     * @param {...*} data
-     * @returns the template
+     * @param {...*} data the data stack, innermost last
+     * @returns {Template}
+     * @throws when the selector matches no template element
      */
     static fromSelector(selector, modules, ...data) {
         const templateEl = document.querySelector(selector);
         if (!(templateEl instanceof HTMLTemplateElement)) {
             throw new Error('template selector does not match any template tag');
         }
-        const fragment = document.adoptNode(templateEl.content);
-        return new Template(fragment, new ExpressionEvaluator(modules, data));
+        return Template.fromTemplate(templateEl, modules, ...data);
     }
 
     /**
-     * Creates a template from the content of an HTMLTemplateElement.
+     * Creates a template from the content of a template element, which is
+     * adopted: the template element is left empty.
      * @param {HTMLTemplateElement} templateEl
      * @param {{ [k: string] : any }?} [modules]
-     * @param {...*} data
-     * @returns the template
+     * @param {...*} data the data stack, innermost last
+     * @returns {Template}
      */
     static fromTemplate(templateEl, modules, ...data) {
         const fragment = document.adoptNode(templateEl.content);
@@ -4111,11 +3742,12 @@ class Template {
     }
 
     /**
-     * Creates a template from a DocumentFragment.
+     * Creates a template over a fragment, which is imported afresh on every
+     * render and never modified.
      * @param {DocumentFragment} fragment
      * @param { { [k: string] : any }? } [modules]
-     * @param {...*} data
-     * @returns the template
+     * @param {...*} data the data stack, innermost last
+     * @returns {Template}
      */
     static fromFragment(fragment, modules, ...data) {
         return new Template(fragment, new ExpressionEvaluator(modules, data));
@@ -4135,28 +3767,32 @@ class Template {
      * 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
+     * @returns {Template}
      */
     withEvaluator(evaluator) {
         return new Template(this.#fragment, evaluator);
     }
     /**
-     * Creates a new Template replacing the fragment.
+     * Creates a new Template over another fragment, in the same scope.
      * @param {DocumentFragment} fragment
+     * @returns {Template}
      */
     withFragment(fragment) {
         return new Template(fragment, this.#evaluator);
     }
     /**
-     * Creates a new Template with a new module added.
+     * Creates a new Template with a module added, as `ExpressionEvaluator.withModule` does.
      * @param {string?} name
      * @param {{[k: string]: any}} value
+     * @returns {Template}
      */
     withModule(name, value) {
         return new Template(this.#fragment, this.#evaluator.withModule(name, value));
     }
     /**
-     * Creates a new Template with new a data overlay added to the stack.
+     * Creates a new Template with the data pushed as the innermost overlays.
      * @param {...*} data
+     * @returns {Template}
      */
     withOverlay(...data) {
         return new Template(this.#fragment, this.#evaluator.withOverlay(...data));
@@ -4165,7 +3801,7 @@ class Template {
      * Evaluates an expression in this template's scope, widened by the overlays.
      * @param {string} expression
      * @param {...*} data
-     * @returns the evaluated expression result
+     * @returns {any}
      */
     evaluateExpression(expression, ...data) {
         return this.#evaluator.withOverlay(...data).evaluateExpression(expression);
@@ -4174,33 +3810,29 @@ class Template {
      * Evaluates a templated text, the `{{ }}` form, in this template's scope.
      * @param {string} text
      * @param {...*} data
-     * @returns the parts the text evaluates to
+     * @returns {{ type: symbol, value: any }[]} the parts, as `Expressions.MODE_TEMPLATED` describes
      */
     evaluateTemplated(text, ...data) {
         return this.#evaluator.withOverlay(...data).evaluateTemplated(text);
     }
     /**
-     * Returns an expression evaluator with bound modules and dataStack.
+     * The scope this template renders in.
+     * @returns {ExpressionEvaluator}
      */
     evaluator() {
         return this.#evaluator;
     }
     /**
-     * Renders the template.
-     * @returns a DocumentFragment
+     * Renders the template into a new fragment, applying the `data-tpl-*`
+     * commands and bindings and the `{{ }}` interpolations.
+     * @returns {DocumentFragment}
+     * @throws {RenderError} naming the node and the directive that failed
      */
     render() {
         try {
             const ops = new NodeOperations();
             const imported = document.importNode(this.#fragment, true);
-            const fragment =
-                imported.nodeType === Node.DOCUMENT_FRAGMENT_NODE
-                    ? imported
-                    : (() => {
-                          const d = new DocumentFragment();
-                          d.appendChild(imported);
-                          return d;
-                      })();
+            const fragment = imported.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? imported : Fragments.from(imported);
             const iterator = document.createNodeIterator(
                 fragment,
                 NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
@@ -4226,8 +3858,6 @@ class Template {
                     try {
                         CommandsHandler[command](el, value, ops, this.#evaluator);
                     } catch (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)) {
@@ -4250,17 +3880,13 @@ class Template {
                             el.setAttribute(attributeName, evaluated);
                         }
                     } catch (ex) {
-                        throw RenderError.wrap(`Error evaluating data-tpl-${toAttr(dataSetKey)}="${expression}"`, el, ex);
+                        throw RenderError.wrap(`Error evaluating data-tpl-${attributeName}="${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;
             }
@@ -4268,22 +3894,26 @@ class Template {
         }
     }
     /**
-     * Renders this template on the Element (replacing children).
+     * Renders this template into the element, replacing its children.
      * @param {Element} el
+     * @throws {RenderError}
      */
     renderTo(el) {
         el.replaceChildren(this.render());
     }
     /**
-     * Renders this template appending the resulting fragment to the Element.
+     * Renders this template and appends the result to the element.
      * @param {Element} el
+     * @throws {RenderError}
      */
     appendTo(el) {
         el.appendChild(this.render());
     }
     /**
-     * Renders this template on the first Element matching the selector (replacing children), if exists.
+     * Renders this template into the first element matching the selector,
+     * replacing its children; does nothing when none matches.
      * @param {string} selector
+     * @throws {RenderError}
      */
     renderToSelector(selector) {
         const el = document.querySelector(selector);
@@ -4292,8 +3922,10 @@ class Template {
         }
     }
     /**
-     * Renders this template appending the resulting fragment to the Element matching the selector, if exists.
+     * Renders this template and appends the result to the first element
+     * matching the selector; does nothing when none matches.
      * @param {string} selector
+     * @throws {RenderError}
      */
     appendToSelector(selector) {
         const el = document.querySelector(selector);
@@ -4317,30 +3949,26 @@ 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.
+ * A render failure, one frame per nesting level, chained through `cause` from
+ * the outermost frame down to the error that failed the expression. A frame's
+ * message names what was being evaluated and the node's open tag, with the
+ * attributes it still carries: the directive being evaluated is already off
+ * the tag. The subtree is not in the message; `html` serializes it on demand.
  */
 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.
-     */
+    /** How many frames a chain keeps: a deeper nesting drops the outermost ones and marks the chain `truncated`. */
     static FRAMES = 3;
     #node;
     #depth;
-    /** true when the budget dropped the outer frames of this chain */
+    /** Whether the chain dropped outer frames to stay within FRAMES. */
     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.
+     * Frames a failure, unless the chain already holds FRAMES frames: then the
+     * cause is returned as it is, marked `truncated`.
+     * @param {string} message
+     * @param {Node} nodeOrFragment the node that failed
+     * @param {any} cause
+     * @returns {RenderError}
      */
     static wrap(message, nodeOrFragment, cause) {
         if (cause instanceof RenderError && cause.depth >= RenderError.FRAMES) {
@@ -4349,27 +3977,44 @@ class RenderError extends Error {
         }
         return new RenderError(message, nodeOrFragment, cause);
     }
+    /**
+     * @param {string} message
+     * @param {Node} nodeOrFragment the node that failed
+     * @param {any} cause
+     */
     constructor(message, nodeOrFragment, cause) {
         super(`${message} in \`${RenderError.describe(nodeOrFragment)}\``, { cause });
         this.name = 'RenderError';
         this.#node = nodeOrFragment;
         this.#depth = (cause instanceof RenderError ? cause.depth : 0) + 1;
     }
-    /** How many frames this chain carries, this one included. */
+    /**
+     * How many frames this chain carries, this one included.
+     * @returns {number}
+     */
     get depth() {
         return this.#depth;
     }
-    /** The node the render failed on, live: it keeps its place in the fragment being built. */
+    /**
+     * The node the render failed on, live in the fragment being built.
+     * @returns {Node}
+     */
     get node() {
         return this.#node;
     }
-    /** The node's markup, serialized when asked for rather than on every failure. */
+    /**
+     * The failed node's markup, whitespace trimmed, serialized on each read.
+     * @returns {string}
+     */
     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.
+     * by its source, a fragment by the open tags of the elements it holds, cut
+     * at 120 characters.
+     * @param {Node} nodeOrFragment
+     * @returns {string}
      */
     static describe(nodeOrFragment) {
         if (nodeOrFragment.nodeType === Node.TEXT_NODE) {
@@ -4388,10 +4033,13 @@ class RenderError extends Error {
     static #ellipsize(text) {
         return text.length > 120 ? `${text.slice(0, 120)}…` : text;
     }
+    /**
+     * A node's markup with its whitespace-only text dropped and the rest trimmed.
+     * @param {Node} nodeOrFragment left untouched: a clone is serialized
+     * @returns {string}
+     */
     static stringify(nodeOrFragment) {
-        const t = document.createElement('template');
-        t.content.appendChild(RenderError.#cleanup(nodeOrFragment.cloneNode(true)));
-        return t.innerHTML;
+        return Fragments.toHtml(RenderError.#cleanup(nodeOrFragment.cloneNode(true)));
     }
     static #cleanup(node) {
         if (node.nodeType === Node.TEXT_NODE) {
@@ -4413,31 +4061,28 @@ 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;
     });
+    #configured = /** @type {PromiseWithResolvers<void>} */ (Promise.withResolvers());
     constructor() {
-        Nodes.waitDomContentLoaded(document).then(() => {
+        Promise.all([Nodes.waitDomContentLoaded(document), this.#configured.promise]).then(() => {
             this.#start();
         });
     }
-    /**
-     * 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;
     }
+    /**
+     * Marks the registry as configured: until then nothing is defined, so an
+     * empty queue says nothing about the page and readiness is held back.
+     */
+    configured() {
+        this.#configured.resolve();
+    }
     async #start() {
         await this.settled();
         document.dispatchEvent(
@@ -4450,13 +4095,8 @@ class UpgradeQueue {
     }
     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;
         }
-        //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()
         );
@@ -4468,11 +4108,6 @@ class UpgradeQueue {
             });
         this.#q.set(el, { upgrade, finished });
     }
-    /**
-     * 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 #drain(accept, pick) {
         for (;;) {
             const pending = Array.from(this.#q)
@@ -4485,22 +4120,28 @@ class UpgradeQueue {
         }
     }
     /**
-     * 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.
+     * Waits for the whole queue to drain, the upgrades enqueued meanwhile included.
+     * Never rejects: a failed upgrade counts as drained.
+     * @returns {Promise<void>}
      */
     settled() {
-        return this.#drain(() => true, (entry) => entry.finished);
+        return this.#drain(
+            () => true,
+            (entry) => entry.finished,
+        );
     }
-    /** Waits for the accepted upgrades, rejecting with the first that failed. */
+    /**
+     * Waits for the accepted upgrades, the ones enqueued meanwhile included,
+     * rejecting with the first that failed.
+     * @param {(el: Element) => boolean} accept
+     * @returns {Promise<void>}
+     */
     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());
     }
@@ -4511,8 +4152,8 @@ class UpgradeQueue {
  * 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.
+ * separate instance with its own upgrade queue, which dispatches its own
+ * ftl:ready on the document, while Rendering waits on the singleton alone.
  */
 class Registry {
     #tagToClass = {};
@@ -4581,9 +4222,12 @@ class Registry {
      * 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.
+     * matters. The element resolves its templates and components through this
+     * registry, whichever one a module imports, and its `static config` is read
+     * here, so a page replacing it does so before the definition.
      * @param {string} tag
      * @param {*} klass a ParsedElement subclass
+     * @returns {Registry} this registry
      */
     defineElement(tag, klass) {
         if (!this.#configured) {
@@ -4601,13 +4245,8 @@ class Registry {
      * 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.
+     * The observed attributes are applied in the composed order, a re-declared
+     * name taking the position of its last declaration.
      * @param {*} klass a ParsedElement subclass
      * @returns {{ observed: string[], attributes: string[] }}
      */
@@ -4623,14 +4262,7 @@ class Registry {
      * 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.
+     * reaches `dataset.clearInvalidOnChange`.
      *
      * Only this direction is mapped. A property never derives its attribute: a
      * setter reflects through `reflectTo`, naming the attribute it writes.
@@ -4643,10 +4275,6 @@ class Registry {
     #augmentAndDefineElement(tag, klass) {
         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) => {
@@ -4665,20 +4293,13 @@ 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,
         };
@@ -4690,6 +4311,7 @@ class Registry {
      * as `#fn`.
      * @param {string} name
      * @param {object} value
+     * @returns {Registry} this registry
      */
     defineModule(name, value) {
         const module = name ? { [name]: value } : value;
@@ -4700,6 +4322,7 @@ class Registry {
     /**
      * Replaces the whole module map.
      * @param {object} ms
+     * @returns {Registry} this registry
      */
     defineModules(ms) {
         this.#modules = ms;
@@ -4711,6 +4334,7 @@ class Registry {
      * through component().
      * @param {string} name
      * @param {*} value
+     * @returns {Registry} this registry
      */
     defineComponent(name, value) {
         this.#components[name] = value;
@@ -4719,6 +4343,7 @@ class Registry {
     /**
      * Replaces the data stack the templates evaluate over.
      * @param {...any} data
+     * @returns {Registry} this registry
      */
     defineData(...data) {
         this.#data = data;
@@ -4728,6 +4353,7 @@ class Registry {
     /**
      * Appends to the data stack, the later entry winning a shared name.
      * @param {...any} data
+     * @returns {Registry} this registry
      */
     defineOverlay(...data) {
         this.#data = [...this.#data, ...data];
@@ -4739,6 +4365,7 @@ class Registry {
      * `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
+     * @returns {Registry} this registry
      */
     defineMapper(k, v) {
         this.#mappers[k] = v;
@@ -4747,6 +4374,7 @@ class Registry {
     /**
      * Hands the registry over to the plugin's configure.
      * @param {{ configure(registry: Registry): void }} p
+     * @returns {Registry} this registry
      */
     plugin(p) {
         p.configure(this);
@@ -4754,7 +4382,10 @@ class Registry {
     }
     /**
      * Defines every element deferred so far; from then on, defineElement takes
-     * effect immediately.
+     * effect immediately. Readiness waits for the first call: a page that
+     * configures late (translations fetched first) gets its ftl:ready once the
+     * elements this defines have upgraded, not at DOMContentLoaded.
+     * @returns {Registry} this registry
      */
     configure() {
         for (const [tag, klass] of Object.entries(this.#tagToClass)) {
@@ -4762,27 +4393,43 @@ class Registry {
             delete this.#tagToClass[tag];
         }
         this.#configured = true;
+        this.#upgradeQueue.configured();
         return this;
     }
     /**
      * Waits for the queued upgrades the filter accepts, rejecting with the first
-     * that failed: the rejecting barrier Rendering is a facade over.
+     * that failed, the upgrades enqueued meanwhile included: the rejecting
+     * barrier Rendering is a facade over.
      * @param {(el: Element) => boolean} accept
+     * @returns {Promise<void>}
      */
     settle(accept) {
         return this.#upgradeQueue.upgraded(accept);
     }
-    /** The pending upgrade of one element, undefined when it is not queued. */
+    /**
+     * The pending upgrade of one element: resolving when it has rendered,
+     * rejecting with what its upgrade threw.
+     * @param {Element} el
+     * @returns {Promise<void>|undefined} undefined when the element is not queued
+     */
     whenUpgraded(el) {
         return this.#upgradeQueue.whenUpgraded(el);
     }
-    /** The elements whose upgrade is still pending, in queue order. */
+    /**
+     * The elements whose upgrade is still pending, in queue order.
+     * @returns {Element[]}
+     */
     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.
+     * Waits for this registry's readiness: resolves right after its ftl:ready
+     * event is dispatched on the document, and immediately when that already
+     * happened. The event is dispatched once DOMContentLoaded has passed,
+     * configure() has been called and the queue has drained, so a registry
+     * that is never configured is never ready. Never rejects: a failed
+     * upgrade counts as settled, and its rejection is left unhandled so it
+     * still reaches the console and the page's error reporting.
      * @returns {Promise<void>}
      */
     ready() {
@@ -4795,11 +4442,16 @@ class Registry {
      * 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.
+     * @returns {ExpressionEvaluator}
      */
     evaluator() {
         return this.#evaluator;
     }
-    /** The component registered under the name, undefined when none is. */
+    /**
+     * The component registered under the name.
+     * @param {string} name
+     * @returns {any} undefined when none is
+     */
     component(name) {
         return this.#components[name];
     }
@@ -4807,33 +4459,59 @@ 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 {
+    /**
+     * @param {string} html
+     * @returns {Template}
+     */
     static fromHtml(html) {
         return Template.fromHtml(html).withEvaluator(registry.evaluator());
     }
+    /**
+     * @param {string} selector for an HTMLTemplateElement
+     * @returns {Template}
+     */
     static fromSelector(selector) {
         return Template.fromSelector(selector).withEvaluator(registry.evaluator());
     }
+    /**
+     * @param {HTMLTemplateElement} templateEl consumed: its content is adopted
+     * @returns {Template}
+     */
     static fromTemplate(templateEl) {
         return Template.fromTemplate(templateEl).withEvaluator(registry.evaluator());
     }
+    /**
+     * @param {DocumentFragment} fragment
+     * @returns {Template}
+     */
     static fromFragment(fragment) {
         return Template.fromFragment(fragment).withEvaluator(registry.evaluator());
     }
 }
 
 /**
- * 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.
+ * Waits for elements queued on the page's `registry` to render. Unlike
+ * `registry.ready()`, these reject when an awaited upgrade fails. An element
+ * defined by another Registry is awaited through that registry instead.
  */
 class Rendering {
+    /**
+     * Waits for the element and its descendants, the ones their own renders
+     * enqueue included.
+     * @param {Element} el
+     * @returns {Promise<void>} rejecting with the first upgrade that failed
+     */
     static waitFor(el) {
         return registry.settle((child) => el.contains(child));
     }
+    /**
+     * Waits for the element's descendants, the element itself excluded: what a
+     * component awaits from inside its own render.
+     * @param {Element} el
+     * @returns {Promise<void>} rejecting with the first upgrade that failed
+     */
     static waitForChildren(el) {
         return registry.settle((child) => el !== child && el.contains(child));
     }
@@ -4847,9 +4525,15 @@ class Rendering {
  * @property {(val: any, name: string, el: Element) => string|null} marshal
  */
 
+/**
+ * The base of every fml element. A subclass declares its attributes, slots and
+ * templates in statics and builds its dom in `render`; the base reads the light
+ * slots, reads the declared attributes through their mappers, renders once, and
+ * then forwards observed attribute writes to the matching properties. An element
+ * resolves templates and components through the registry that defined it.
+ */
 class ParsedElement extends HTMLElement {
     static BITS = {
-        //an element the registry never defined still answers the page's own
         registry,
         enqueue: (el) => {},
         SLOTS: false,
@@ -4873,14 +4557,12 @@ class ParsedElement extends HTMLElement {
         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.
+     * The element's ElementInternals, attached by the base for every element: a
+     * subclass never calls attachInternals itself, since a second call throws.
+     * A subclass declaring `static formAssociated` gets the form apis here.
+     * A subclass must not redeclare the field: a class field without an
+     * initializer assigns undefined after super() returns, wiping it.
+     * @type {ElementInternals}
      */
     internals;
     #parsed = false;
@@ -4897,26 +4579,36 @@ class ParsedElement extends HTMLElement {
     #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;
     }
+    /**
+     * Reads an attribute value through the mapper it was declared with.
+     * @param {string} attr
+     * @param {string|null} str
+     * @returns {any}
+     * @throws when the class declares no such attribute; read undeclared ones with getAttribute
+     */
     unmarshal(attr, str) {
         return this.#mapper(attr).unmarshal(str, attr, this);
     }
+    /**
+     * Writes a value as the attribute string its declared mapper produces.
+     * @param {string} attr
+     * @param {any} value
+     * @returns {string|null} null for a value that removes the attribute
+     * @throws when the class declares no such attribute
+     */
     marshal(attr, value) {
         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.
+     * @returns {typeof registry}
      */
-    /** The registry that defined this element, the page's own for an undefined one. */
     get _registry() {
         return this.#bits().registry;
     }
@@ -4924,10 +4616,18 @@ class ParsedElement extends HTMLElement {
      * The component registered under the name on this element's registry, the
      * one every ful loader and mapper resolves through.
      * @param {string} name
+     * @returns {any} undefined when none is registered
      */
     component(name) {
         return this.#bits().registry.component(name);
     }
+    /**
+     * One of the class's templates, bound to its registry's scope with the
+     * class's `static config` overlaid as `config`.
+     * @param {string} [name] 'default', the `static template`, when omitted
+     * @returns {Template}
+     * @throws when the class declares no template of that name
+     */
     template(name) {
         const target = this.#bits().TEMPLATES[name ?? 'default'];
         if (!target) {
@@ -4947,15 +4647,9 @@ class ParsedElement extends HTMLElement {
         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;
         }
-        //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);
@@ -4965,14 +4659,18 @@ class ParsedElement extends HTMLElement {
         this[this.#bits().ATTR_TO_PROPERTY[attr]] = this.unmarshal(attr, newValue);
     }
     /**
-     * Upgrades once: reads the declared attributes, keeps the observed half open
-     * to writes made while the render is pending, applies them to the properties
-     * when the render returns, and only then lets an attribute write forward.
+     * Upgrades once, however often the element is connected: reads the declared
+     * attributes, keeps the observed ones open to writes made while the render is
+     * pending, renders, then applies the observed values to their properties in
+     * the order the registry composed them, a base class's before a subclass's.
+     * Only then do attribute writes forward to properties, and the element gains
+     * the `rendered` custom state. A render that throws leaves the forwarding
+     * shut and the state unset.
      *
      * 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.
+     * a camelCase property.
+     * @returns {Promise<void>} rejecting with what the render threw
      */
     async upgrade() {
         if (this.#started) {
@@ -4980,9 +4678,6 @@ class ParsedElement extends HTMLElement {
         }
         this.#started = true;
         const slots = this.#bits().SLOTS ? LightSlots.from(this) : undefined;
-        //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,
@@ -4994,21 +4689,11 @@ class ParsedElement extends HTMLElement {
         this.#pending = declared;
         try {
             await this.render({ slots });
-            //the declared state reaches the properties once the dom the setters
-            //drive exists, in the order the registry composed the declarations:
-            //a base class's attributes before the subclass's own
             const properties = this.#bits().ATTR_TO_PROPERTY;
             for (const name of this.#bits().OBSERVED) {
                 this[properties[name]] = declared[name];
             }
-            //the properties go live once the render is done: from here on, an
-            //attribute write forwards to the property. A render that threw
-            //leaves it shut, so a later attribute write cannot reach setters
-            //that assume pieces the failed render never adopted
             this.#parsed = true;
-            //the same moment, said to css. :defined is true from the constructor,
-            //which is before the dom exists, so a guard written against it reveals
-            //an element that has nothing in it yet
             this.internals.states.add('rendered');
         } finally {
             this.#pending = null;
@@ -5019,8 +4704,9 @@ class ParsedElement extends HTMLElement {
      * 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
+     * declaring no slots. It may be async; the upgrade awaits it.
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} c
+     * @returns {void | Promise<void>}
      */
     render(c) {}
     /**
@@ -5032,12 +4718,9 @@ class ParsedElement extends HTMLElement {
      * 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
+     * @returns {any}
+     * @throws when the class declares no such attribute
      */
     declared(name) {
         if (name in this.#frozen) {
@@ -5048,15 +4731,18 @@ class ParsedElement extends HTMLElement {
         }
         return this.unmarshal(name, this.getAttribute(name));
     }
-    /** Whether the element's render completed: the moment its properties went live. */
+    /**
+     * Whether the element's render completed: the moment its properties went
+     * live, which css reads as `:state(rendered)`. Unlike `:defined`, which holds
+     * from the constructor, it is false until the dom exists.
+     * @returns {boolean}
+     */
     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.
+     * the mapper the attribute was declared with.
      *
      * 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
@@ -5087,18 +4773,37 @@ class ParsedElement extends HTMLElement {
  */
 
 /**
- * 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().
+ * The receiver contract of the module functions: a plain object carrying the
+ * translations and the locale, as Localization.of() binds them, or the proxy
+ * over the data stack a template calls them with.
  *
  * @typedef {{ l10n?: Messages, locale?: string }} Receiver
  */
 
+/**
+ * The translations or the locale of a receiver. From a template they are read
+ * from the bound data alone (the registry's overlays, or the data handed to
+ * the Template factory): the rows and responses a render pushes on top are
+ * what arrives later, and must not supply or replace the page's own messages.
+ * @param {any} receiver
+ * @param {'l10n' | 'locale'} name
+ * @returns {any}
+ */
+const configured = (receiver, name) => {
+    const bound = receiver[Expressions.BOUND];
+    return typeof bound === 'function' ? bound(name) : receiver[name];
+};
+
 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);
+const isPlainObject = (v) =>
+    typeof v === 'object' && v !== null && [Object.prototype, null].includes(Object.getPrototypeOf(v));
+
+/** @param {any} problem @returns {string|undefined} the reason, unless it is missing or blank */
+const reasonOf = (problem) =>
+    typeof problem?.reason === 'string' && problem.reason.trim() !== '' ? problem.reason : undefined;
 
-/** 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)) {
@@ -5109,11 +4814,7 @@ const warnOnce = (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.
- *
+ * An Intl instance, memoized by constructor, locale and options.
  * @param {{ new (locale: string | undefined, options: any): any }} ctor
  * @param {string | undefined} locale
  * @param {any} [options]
@@ -5127,35 +4828,40 @@ const formatter = (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.
+ * always produce the same result for the same key. A template reads `l10n`
+ * and `locale` from its bound data only, the most recent layer winning: an
+ * overlay pushed while rendering (a row, a response) never reaches them.
  */
 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 single plain object argument (an object literal, or one with a null
+     * prototype) 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
+     * Each problem (a missing key, placeholder or plural form) is warned once
+     * per page.
+     *
      * @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];
+        const messages = configured(this, 'l10n') ?? {};
+        let message = Object.hasOwn(messages, key) ? messages[key] : undefined;
         if (message === undefined) {
             warnOnce(`missing message "${key}"`);
             return key;
         }
+        const named = args.length === 1 && isPlainObject(args[0]) ? args[0] : null;
         if (isPlainObject(message)) {
-            const named = args.length === 1 && isPlainObject(args[0]) ? args[0] : {};
-            if (typeof named.count !== 'number') {
+            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 locale = configured(this, 'locale') ?? navigator?.language ?? 'en';
                 const category = formatter(Intl.PluralRules, locale).select(named.count);
                 message = message[category] ?? message.other;
             }
@@ -5164,10 +4870,9 @@ class Localization {
             warnOnce(`plural message "${key}" has no "other" form`);
             return key;
         }
-        if (args.length === 1 && isPlainObject(args[0])) {
-            const named = args[0];
+        if (named) {
             return message.replace(PLACEHOLDER, (literal, name) => {
-                if (!(name in named)) {
+                if (!Object.hasOwn(named, name)) {
                     warnOnce(`message "${key}" wants {${name}}`);
                     return literal;
                 }
@@ -5193,9 +4898,10 @@ class Localization {
      * @param {Date | number} value
      * @param {Intl.DateTimeFormatOptions} [options]
      * @this {Receiver}
+     * @returns {string}
      */
     static date(value, options) {
-        return formatter(Intl.DateTimeFormat, this.locale, options).format(value);
+        return formatter(Intl.DateTimeFormat, configured(this, 'locale'), options).format(value);
     }
 
     /**
@@ -5204,9 +4910,10 @@ class Localization {
      * @param {number} value
      * @param {Intl.NumberFormatOptions} [options]
      * @this {Receiver}
+     * @returns {string}
      */
     static number(value, options) {
-        return formatter(Intl.NumberFormat, this.locale, options).format(value);
+        return formatter(Intl.NumberFormat, configured(this, 'locale'), options).format(value);
     }
 
     /**
@@ -5216,9 +4923,10 @@ class Localization {
      *
      * @param {number} value
      * @this {Receiver}
+     * @returns {string}
      */
     static bytes(value) {
-        const format = formatter(Intl.NumberFormat, this.locale, { maximumFractionDigits: 2 }).format;
+        const format = formatter(Intl.NumberFormat, configured(this, 'locale'), { maximumFractionDigits: 2 }).format;
         if (value >= 1024 * 1024 * 1024) {
             return `${format(value / 1024 / 1024 / 1024)}GiB`;
         }
@@ -5231,16 +4939,37 @@ class Localization {
         return `${format(value)}B`;
     }
 
+    /**
+     * What went wrong, as text for the reader. A value carrying a non-empty
+     * `problems` array reads as their reasons, one per line, a blank or missing
+     * reason reading as the `failure.no-reason` message. Any other value with a
+     * `message` reads as that message; anything else as its string form, and
+     * null or undefined as the empty string.
+     *
+     * @param {any} value what was thrown or rejected with
+     * @this {Receiver}
+     * @returns {string}
+     */
+    static failure(value) {
+        if (Array.isArray(value?.problems) && value.problems.length > 0) {
+            return value.problems.map((p) => reasonOf(p) ?? Localization.t.call(this, 'failure.no-reason')).join('\n');
+        }
+        if (value?.message !== undefined) {
+            return String(value.message);
+        }
+        return value == null ? '' : String(value);
+    }
+
     /**
      * An imperative facade over the module functions, resolving the translations
-     * and the locale from the registry overlays on every call.
+     * and the locale from the registry overlays on every call, the same lookup a
+     * template makes: a facade taken at module scope, before the plugin
+     * configures, still sees the translations.
      *
      * @param {{ locale?: string }} [overrides] an explicit locale, winning over the registry one
+     * @returns {{ t: (key: string, ...args: any[]) => string, date: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string, number: (value: number, options?: Intl.NumberFormatOptions) => string, bytes: (value: number) => string, failure: (value: any) => string }}
      */
     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 =
@@ -5252,6 +4981,7 @@ class Localization {
             date: bind(Localization.date),
             number: bind(Localization.number),
             bytes: bind(Localization.bytes),
+            failure: bind(Localization.failure),
         };
     }
 }