jssm 5.158.2 → 5.159.1

package/dist/fence/fence.js

@@ -359,10 +359,20 @@ function peg$parse(input, options) {
             node.loc = location();
         }
         return node;
-    }, peg$c1235 = "milliseconds", peg$c1236 = peg$literalExpectation("milliseconds", false), peg$c1237 = function () { return 1; }, peg$c1238 = "millisecond", peg$c1239 = peg$literalExpectation("millisecond", false), peg$c1240 = "msecs", peg$c1241 = peg$literalExpectation("msecs", false), peg$c1242 = "msec", peg$c1243 = peg$literalExpectation("msec", false), peg$c1244 = "ms", peg$c1245 = peg$literalExpectation("ms", false), peg$c1246 = "seconds", peg$c1247 = peg$literalExpectation("seconds", false), peg$c1248 = function () { return 1000; }, peg$c1249 = "second", peg$c1250 = peg$literalExpectation("second", false), peg$c1251 = "secs", peg$c1252 = peg$literalExpectation("secs", false), peg$c1253 = "sec", peg$c1254 = peg$literalExpectation("sec", false), peg$c1255 = "s", peg$c1256 = peg$literalExpectation("s", false), peg$c1257 = "minutes", peg$c1258 = peg$literalExpectation("minutes", false), peg$c1259 = function () { return 1000 * 60; }, peg$c1260 = "minute", peg$c1261 = peg$literalExpectation("minute", false), peg$c1262 = "mins", peg$c1263 = peg$literalExpectation("mins", false), peg$c1264 = "min", peg$c1265 = peg$literalExpectation("min", false), peg$c1266 = "m", peg$c1267 = peg$literalExpectation("m", false), peg$c1268 = "hours", peg$c1269 = peg$literalExpectation("hours", false), peg$c1270 = function () { return 1000 * 60 * 60; }, peg$c1271 = "hour", peg$c1272 = peg$literalExpectation("hour", false), peg$c1273 = "hrs", peg$c1274 = peg$literalExpectation("hrs", false), peg$c1275 = "hr", peg$c1276 = peg$literalExpectation("hr", false), peg$c1277 = "h", peg$c1278 = peg$literalExpectation("h", false), peg$c1279 = "days", peg$c1280 = peg$literalExpectation("days", false), peg$c1281 = function () { return 1000 * 60 * 60 * 24; }, peg$c1282 = "day", peg$c1283 = peg$literalExpectation("day", false), peg$c1284 = "d", peg$c1285 = peg$literalExpectation("d", false), peg$c1286 = "weeks", peg$c1287 = peg$literalExpectation("weeks", false), peg$c1288 = function () { return 1000 * 60 * 60 * 24 * 7; }, peg$c1289 = "week", peg$c1290 = peg$literalExpectation("week", false), peg$c1291 = "wks", peg$c1292 = peg$literalExpectation("wks", false), peg$c1293 = "wk", peg$c1294 = peg$literalExpectation("wk", false), peg$c1295 = "w", peg$c1296 = peg$literalExpectation("w", false), peg$c1297 = "after", peg$c1298 = peg$literalExpectation("after", false), peg$c1299 = function (value, timescale) { return value * (timescale || 1000); }, peg$c1300 = function (names) { return names.map(i => i[0]); }, peg$c1301 = peg$otherExpectation("group reference"), peg$c1302 = "&", peg$c1303 = peg$literalExpectation("&", false), peg$c1304 = function (name) { return { key: 'group_ref', name }; }, peg$c1305 = "...", peg$c1306 = peg$literalExpectation("...", false), peg$c1307 = function (name) { return { kind: 'group', name, mode: 'spread' }; }, peg$c1308 = function (name) { return { kind: 'group', name, mode: 'nest' }; }, peg$c1309 = function (name) { return { kind: 'state', name }; }, peg$c1310 = function (members) {
+    }, peg$c1235 = "milliseconds", peg$c1236 = peg$literalExpectation("milliseconds", false), peg$c1237 = function () { return 1; }, peg$c1238 = "millisecond", peg$c1239 = peg$literalExpectation("millisecond", false), peg$c1240 = "msecs", peg$c1241 = peg$literalExpectation("msecs", false), peg$c1242 = "msec", peg$c1243 = peg$literalExpectation("msec", false), peg$c1244 = "ms", peg$c1245 = peg$literalExpectation("ms", false), peg$c1246 = "seconds", peg$c1247 = peg$literalExpectation("seconds", false), peg$c1248 = function () { return 1000; }, peg$c1249 = "second", peg$c1250 = peg$literalExpectation("second", false), peg$c1251 = "secs", peg$c1252 = peg$literalExpectation("secs", false), peg$c1253 = "sec", peg$c1254 = peg$literalExpectation("sec", false), peg$c1255 = "s", peg$c1256 = peg$literalExpectation("s", false), peg$c1257 = "minutes", peg$c1258 = peg$literalExpectation("minutes", false), peg$c1259 = function () { return 1000 * 60; }, peg$c1260 = "minute", peg$c1261 = peg$literalExpectation("minute", false), peg$c1262 = "mins", peg$c1263 = peg$literalExpectation("mins", false), peg$c1264 = "min", peg$c1265 = peg$literalExpectation("min", false), peg$c1266 = "m", peg$c1267 = peg$literalExpectation("m", false), peg$c1268 = "hours", peg$c1269 = peg$literalExpectation("hours", false), peg$c1270 = function () { return 1000 * 60 * 60; }, peg$c1271 = "hour", peg$c1272 = peg$literalExpectation("hour", false), peg$c1273 = "hrs", peg$c1274 = peg$literalExpectation("hrs", false), peg$c1275 = "hr", peg$c1276 = peg$literalExpectation("hr", false), peg$c1277 = "h", peg$c1278 = peg$literalExpectation("h", false), peg$c1279 = "days", peg$c1280 = peg$literalExpectation("days", false), peg$c1281 = function () { return 1000 * 60 * 60 * 24; }, peg$c1282 = "day", peg$c1283 = peg$literalExpectation("day", false), peg$c1284 = "d", peg$c1285 = peg$literalExpectation("d", false), peg$c1286 = "weeks", peg$c1287 = peg$literalExpectation("weeks", false), peg$c1288 = function () { return 1000 * 60 * 60 * 24 * 7; }, peg$c1289 = "week", peg$c1290 = peg$literalExpectation("week", false), peg$c1291 = "wks", peg$c1292 = peg$literalExpectation("wks", false), peg$c1293 = "wk", peg$c1294 = peg$literalExpectation("wk", false), peg$c1295 = "w", peg$c1296 = peg$literalExpectation("w", false), peg$c1297 = "after", peg$c1298 = peg$literalExpectation("after", false), peg$c1299 = function (value, timescale) { return value * (timescale || 1000); }, peg$c1300 = function (names) { return names.map(i => i[0]); }, peg$c1301 = peg$otherExpectation("group reference"), peg$c1302 = "&", peg$c1303 = peg$literalExpectation("&", false), peg$c1304 = function (name) { return { key: 'group_ref', name }; }, peg$c1305 = "...", peg$c1306 = peg$literalExpectation("...", false), peg$c1307 = function (name) { const m = { kind: 'group', name, mode: 'spread' }; if (options.locations) {
+        m.__loc = location();
+    } return m; }, peg$c1308 = function (name) { const m = { kind: 'group', name, mode: 'nest' }; if (options.locations) {
+        m.__loc = location();
+    } return m; }, peg$c1309 = function (name) { const m = { kind: 'state', name }; if (options.locations) {
+        m.__loc = location();
+    } return m; }, peg$c1310 = function (members) {
         const items = members.map(m => m[0]);
         const has_group = items.some(m => m.kind === 'group');
-        return has_group ? items : items.map(m => m.name);
+        const collapsed = has_group ? items : items.map(m => m.name);
+        if (options.locations) {
+            collapsed.__member_locs = items.map((m) => m.__loc);
+        }
+        return collapsed;
     }, peg$c1311 = "+|", peg$c1312 = peg$literalExpectation("+|", false), peg$c1313 = function (n) {
         const node = { key: 'stripe', value: parseInt(n, 10) };
         if (options.locations) {
@@ -812,69 +822,96 @@ function peg$parse(input, options) {
         const node = { key: 'named_list', name, value };
         if (options.locations) {
             node.loc = location();
+            node.value_locs = value.__member_locs;
+            delete value.__member_locs;
+        }
+        return node;
+    }, peg$c1549 = function (name, value) {
+        const node = { key: 'named_list', name, value: value.name };
+        if (options.locations) {
+            node.loc = location();
+            node.value_locs = [value.__loc];
         }
         return node;
-    }, peg$c1549 = peg$otherExpectation("hook event (enter/exit)"), peg$c1550 = "enter", peg$c1551 = peg$literalExpectation("enter", false), peg$c1552 = "exit", peg$c1553 = peg$literalExpectation("exit", false), peg$c1554 = peg$otherExpectation("hook declaration"), peg$c1555 = "on", peg$c1556 = peg$literalExpectation("on", false), peg$c1557 = "do", peg$c1558 = peg$literalExpectation("do", false), peg$c1559 = function (event, subject, action) {
+    }, peg$c1550 = function (name) {
+        const m = { name };
+        if (options.locations) {
+            m.__loc = location();
+        }
+        return m;
+    }, peg$c1551 = peg$otherExpectation("hook event (enter/exit)"), peg$c1552 = "enter", peg$c1553 = peg$literalExpectation("enter", false), peg$c1554 = "exit", peg$c1555 = peg$literalExpectation("exit", false), peg$c1556 = peg$otherExpectation("hook declaration"), peg$c1557 = "on", peg$c1558 = peg$literalExpectation("on", false), peg$c1559 = "do", peg$c1560 = peg$literalExpectation("do", false), peg$c1561 = function (event, subject, action) {
         const node = { key: 'hook_decl', event, subject, action };
+        if (subject.key === 'hook_state_subject') {
+            node.subject = subject.name;
+            if (options.locations) {
+                node.subject_loc = subject.__loc;
+            }
+        }
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1560 = function (name, default_value) {
+    }, peg$c1562 = function (name) {
+        const m = { key: 'hook_state_subject', name };
+        if (options.locations) {
+            m.__loc = location();
+        }
+        return m;
+    }, peg$c1563 = function (name, default_value) {
         const node = { key: 'property_definition', name, default_value, required: true };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1561 = function (name) {
+    }, peg$c1564 = function (name) {
         const node = { key: 'property_definition', name, required: true };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1562 = function (name, default_value) {
+    }, peg$c1565 = function (name, default_value) {
         const node = { key: 'property_definition', name, default_value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1563 = function (name) {
+    }, peg$c1566 = function (name) {
         const node = { key: 'property_definition', name };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1564 = "arrange", peg$c1565 = peg$literalExpectation("arrange", false), peg$c1566 = function (value) {
+    }, peg$c1567 = "arrange", peg$c1568 = peg$literalExpectation("arrange", false), peg$c1569 = function (value) {
         const node = { key: 'arrange_declaration', value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1567 = "arrange-start", peg$c1568 = peg$literalExpectation("arrange-start", false), peg$c1569 = function (value) {
+    }, peg$c1570 = "arrange-start", peg$c1571 = peg$literalExpectation("arrange-start", false), peg$c1572 = function (value) {
         const node = { key: 'arrange_start_declaration', value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1570 = "arrange-end", peg$c1571 = peg$literalExpectation("arrange-end", false), peg$c1572 = function (value) {
+    }, peg$c1573 = "arrange-end", peg$c1574 = peg$literalExpectation("arrange-end", false), peg$c1575 = function (value) {
         const node = { key: 'arrange_end_declaration', value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1573 = peg$otherExpectation("oarrange declaration"), peg$c1574 = "oarrange", peg$c1575 = peg$literalExpectation("oarrange", false), peg$c1576 = function (value) {
+    }, peg$c1576 = peg$otherExpectation("oarrange declaration"), peg$c1577 = "oarrange", peg$c1578 = peg$literalExpectation("oarrange", false), peg$c1579 = function (value) {
         const node = { key: 'oarrange_declaration', value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1577 = peg$otherExpectation("farrange declaration"), peg$c1578 = "farrange", peg$c1579 = peg$literalExpectation("farrange", false), peg$c1580 = function (value) {
+    }, peg$c1580 = peg$otherExpectation("farrange declaration"), peg$c1581 = "farrange", peg$c1582 = peg$literalExpectation("farrange", false), peg$c1583 = function (value) {
         const node = { key: 'farrange_declaration', value };
         if (options.locations) {
             node.loc = location();
         }
         return node;
-    }, peg$c1581 = peg$otherExpectation("arrange declaration"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
+    }, peg$c1584 = peg$otherExpectation("arrange declaration"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
     if ("startRule" in options) {
         if (!(options.startRule in peg$startRuleFunctions)) {
             throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -19498,7 +19535,7 @@ function peg$parse(input, options) {
                                         s7 = null;
                                     }
                                     if (s7 !== peg$FAILED) {
-                                        s8 = peg$parseLabel();
+                                        s8 = peg$parseGroupAliasMember();
                                         if (s8 !== peg$FAILED) {
                                             s9 = peg$parseWS();
                                             if (s9 === peg$FAILED) {
@@ -19522,7 +19559,7 @@ function peg$parse(input, options) {
                                                     }
                                                     if (s11 !== peg$FAILED) {
                                                         peg$savedPos = s0;
-                                                        s1 = peg$c1548(s4, s8);
+                                                        s1 = peg$c1549(s4, s8);
                                                         s0 = s1;
                                                     }
                                                     else {
@@ -19582,35 +19619,46 @@ function peg$parse(input, options) {
         }
         return s0;
     }
+    function peg$parseGroupAliasMember() {
+        var s0, s1;
+        s0 = peg$currPos;
+        s1 = peg$parseLabel();
+        if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1550(s1);
+        }
+        s0 = s1;
+        return s0;
+    }
     function peg$parseHookEvent() {
         var s0;
         peg$silentFails++;
-        if (input.substr(peg$currPos, 5) === peg$c1550) {
-            s0 = peg$c1550;
+        if (input.substr(peg$currPos, 5) === peg$c1552) {
+            s0 = peg$c1552;
             peg$currPos += 5;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1551);
+                peg$fail(peg$c1553);
             }
         }
         if (s0 === peg$FAILED) {
-            if (input.substr(peg$currPos, 4) === peg$c1552) {
-                s0 = peg$c1552;
+            if (input.substr(peg$currPos, 4) === peg$c1554) {
+                s0 = peg$c1554;
                 peg$currPos += 4;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                    peg$fail(peg$c1553);
+                    peg$fail(peg$c1555);
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1549);
+                peg$fail(peg$c1551);
             }
         }
         return s0;
@@ -19624,14 +19672,14 @@ function peg$parse(input, options) {
             s1 = null;
         }
         if (s1 !== peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c1555) {
-                s2 = peg$c1555;
+            if (input.substr(peg$currPos, 2) === peg$c1557) {
+                s2 = peg$c1557;
                 peg$currPos += 2;
             }
             else {
                 s2 = peg$FAILED;
                 if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                    peg$fail(peg$c1556);
+                    peg$fail(peg$c1558);
                 }
             }
             if (s2 !== peg$FAILED) {
@@ -19643,19 +19691,19 @@ function peg$parse(input, options) {
                         if (s5 !== peg$FAILED) {
                             s6 = peg$parseGroupRef();
                             if (s6 === peg$FAILED) {
-                                s6 = peg$parseLabel();
+                                s6 = peg$parseHookStateSubject();
                             }
                             if (s6 !== peg$FAILED) {
                                 s7 = peg$parseWS();
                                 if (s7 !== peg$FAILED) {
-                                    if (input.substr(peg$currPos, 2) === peg$c1557) {
-                                        s8 = peg$c1557;
+                                    if (input.substr(peg$currPos, 2) === peg$c1559) {
+                                        s8 = peg$c1559;
                                         peg$currPos += 2;
                                     }
                                     else {
                                         s8 = peg$FAILED;
                                         if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                                            peg$fail(peg$c1558);
+                                            peg$fail(peg$c1560);
                                         }
                                     }
                                     if (s8 !== peg$FAILED) {
@@ -19685,7 +19733,7 @@ function peg$parse(input, options) {
                                                         }
                                                         if (s13 !== peg$FAILED) {
                                                             peg$savedPos = s0;
-                                                            s1 = peg$c1559(s4, s6, s10);
+                                                            s1 = peg$c1561(s4, s6, s10);
                                                             s0 = s1;
                                                         }
                                                         else {
@@ -19756,11 +19804,22 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1554);
+                peg$fail(peg$c1556);
             }
         }
         return s0;
     }
+    function peg$parseHookStateSubject() {
+        var s0, s1;
+        s0 = peg$currPos;
+        s1 = peg$parseLabel();
+        if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1562(s1);
+        }
+        s0 = s1;
+        return s0;
+    }
     function peg$parseMachineProperty() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
         s0 = peg$currPos;
@@ -19836,7 +19895,7 @@ function peg$parse(input, options) {
                                                         }
                                                         if (s13 !== peg$FAILED) {
                                                             peg$savedPos = s0;
-                                                            s1 = peg$c1560(s4, s8);
+                                                            s1 = peg$c1563(s4, s8);
                                                             s0 = s1;
                                                         }
                                                         else {
@@ -19960,7 +20019,7 @@ function peg$parse(input, options) {
                                             }
                                             if (s9 !== peg$FAILED) {
                                                 peg$savedPos = s0;
-                                                s1 = peg$c1561(s4);
+                                                s1 = peg$c1564(s4);
                                                 s0 = s1;
                                             }
                                             else {
@@ -20068,7 +20127,7 @@ function peg$parse(input, options) {
                                                         }
                                                         if (s11 !== peg$FAILED) {
                                                             peg$savedPos = s0;
-                                                            s1 = peg$c1562(s4, s8);
+                                                            s1 = peg$c1565(s4, s8);
                                                             s0 = s1;
                                                         }
                                                         else {
@@ -20169,7 +20228,7 @@ function peg$parse(input, options) {
                                             }
                                             if (s7 !== peg$FAILED) {
                                                 peg$savedPos = s0;
-                                                s1 = peg$c1563(s4);
+                                                s1 = peg$c1566(s4);
                                                 s0 = s1;
                                             }
                                             else {
@@ -20214,14 +20273,14 @@ function peg$parse(input, options) {
     function peg$parseRegularArrangeDeclaration() {
         var s0, s1, s2, s3, s4, s5, s6;
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 7) === peg$c1564) {
-            s1 = peg$c1564;
+        if (input.substr(peg$currPos, 7) === peg$c1567) {
+            s1 = peg$c1567;
             peg$currPos += 7;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1565);
+                peg$fail(peg$c1568);
             }
         }
         if (s1 !== peg$FAILED) {
@@ -20254,7 +20313,7 @@ function peg$parse(input, options) {
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s1 = peg$c1566(s3);
+                                s1 = peg$c1569(s3);
                                 s0 = s1;
                             }
                             else {
@@ -20291,14 +20350,14 @@ function peg$parse(input, options) {
     function peg$parseArrangeStartDeclaration() {
         var s0, s1, s2, s3, s4, s5, s6;
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 13) === peg$c1567) {
-            s1 = peg$c1567;
+        if (input.substr(peg$currPos, 13) === peg$c1570) {
+            s1 = peg$c1570;
             peg$currPos += 13;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1568);
+                peg$fail(peg$c1571);
             }
         }
         if (s1 !== peg$FAILED) {
@@ -20331,7 +20390,7 @@ function peg$parse(input, options) {
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s1 = peg$c1569(s3);
+                                s1 = peg$c1572(s3);
                                 s0 = s1;
                             }
                             else {
@@ -20368,14 +20427,14 @@ function peg$parse(input, options) {
     function peg$parseArrangeEndDeclaration() {
         var s0, s1, s2, s3, s4, s5, s6;
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 11) === peg$c1570) {
-            s1 = peg$c1570;
+        if (input.substr(peg$currPos, 11) === peg$c1573) {
+            s1 = peg$c1573;
             peg$currPos += 11;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1571);
+                peg$fail(peg$c1574);
             }
         }
         if (s1 !== peg$FAILED) {
@@ -20408,7 +20467,7 @@ function peg$parse(input, options) {
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s1 = peg$c1572(s3);
+                                s1 = peg$c1575(s3);
                                 s0 = s1;
                             }
                             else {
@@ -20446,14 +20505,14 @@ function peg$parse(input, options) {
         var s0, s1, s2, s3, s4, s5, s6;
         peg$silentFails++;
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 8) === peg$c1574) {
-            s1 = peg$c1574;
+        if (input.substr(peg$currPos, 8) === peg$c1577) {
+            s1 = peg$c1577;
             peg$currPos += 8;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1575);
+                peg$fail(peg$c1578);
             }
         }
         if (s1 !== peg$FAILED) {
@@ -20486,7 +20545,7 @@ function peg$parse(input, options) {
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s1 = peg$c1576(s3);
+                                s1 = peg$c1579(s3);
                                 s0 = s1;
                             }
                             else {
@@ -20522,7 +20581,7 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1573);
+                peg$fail(peg$c1576);
             }
         }
         return s0;
@@ -20531,14 +20590,14 @@ function peg$parse(input, options) {
         var s0, s1, s2, s3, s4, s5, s6;
         peg$silentFails++;
         s0 = peg$currPos;
-        if (input.substr(peg$currPos, 8) === peg$c1578) {
-            s1 = peg$c1578;
+        if (input.substr(peg$currPos, 8) === peg$c1581) {
+            s1 = peg$c1581;
             peg$currPos += 8;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1579);
+                peg$fail(peg$c1582);
             }
         }
         if (s1 !== peg$FAILED) {
@@ -20571,7 +20630,7 @@ function peg$parse(input, options) {
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s0;
-                                s1 = peg$c1580(s3);
+                                s1 = peg$c1583(s3);
                                 s0 = s1;
                             }
                             else {
@@ -20607,7 +20666,7 @@ function peg$parse(input, options) {
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1577);
+                peg$fail(peg$c1580);
             }
         }
         return s0;
@@ -20631,7 +20690,7 @@ function peg$parse(input, options) {
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c1581);
+                peg$fail(peg$c1584);
             }
         }
         return s0;
@@ -23625,7 +23684,8 @@ var constants = /*#__PURE__*/Object.freeze({
 const HEX8 = /^#[0-9a-f]{8}$/i;
 /** AST keys that hold source locations, not child nodes to recurse into. */
 const LOC_KEYS = new Set(['loc', 'value_loc', 'name_loc', 'from_loc', 'to_loc',
-    'r_action_loc', 'l_action_loc']);
+    'r_action_loc', 'l_action_loc', 'value_locs',
+    'subject_loc', '__loc']);
 /** State-declaration item keys whose value is an enum lacking a value-precise loc. */
 const ENUM_VALUE_KEYS = new Set(['shape']);
 /** Locate a value substring inside a node's full-statement `loc` span. The
@@ -23662,6 +23722,31 @@ function collect(node, text, out) {
     if (ENUM_VALUE_KEYS.has(n.key) && typeof n.value === 'string' && n.loc && !n.value_loc) {
         out.push(Object.assign(Object.assign({}, valueSpanWithin(text, n.loc, n.value)), { kind: 'enum' }));
     }
+    // group declarations (`&G : [a b c];` / `&G : a;`): every plain member is a
+    // state reference. The grammar supplies value_locs parallel to value, so
+    // positions come from the parser, never from text search. Nest/spread
+    // entries (`&child` / `...&child`) are group references, not states, and
+    // the group's own NAME is deliberately not a state span either.
+    if (n.key === 'named_list') {
+        const members = Array.isArray(n.value) ? n.value : [n.value];
+        members.forEach((member, i) => {
+            const m = member;
+            const name = typeof m === 'string' ? m
+                : m.kind === 'state' ? m.name
+                    : null;
+            if (name !== null) {
+                const at = n.value_locs[i];
+                out.push({ from: at.start.offset, to: at.end.offset, kind: 'state', value: name });
+            }
+        });
+    }
+    // hook declarations (`on enter x do 'act';`): a plain-label subject is a
+    // state reference and carries a grammar-supplied subject_loc. Group-ref
+    // subjects (`on exit &G …`) are group references, not states — no
+    // subject_loc, no span.
+    if (n.key === 'hook_decl' && n.subject_loc) {
+        out.push({ from: n.subject_loc.start.offset, to: n.subject_loc.end.offset, kind: 'state', value: n.subject });
+    }
     for (const key of Object.keys(n)) {
         if (!LOC_KEYS.has(key)) {
             collect(n[key], text, out);
@@ -23669,11 +23754,21 @@ function collect(node, text, out) {
     }
 }
 /**
- * Collect color / state / shape-enum semantic spans from `text`.
+ * Collect color / state / shape-enum semantic spans from `text`. State spans
+ * cover transition endpoints, state-declaration subjects, group-list members
+ * (`&G : [a b c];` — but not the group's own name, nor `&`/`...&` nested
+ * group references), and plain-label hook subjects (`on enter x do 'act';` —
+ * but not `&group` subjects). Every state span's `value` is the parser's
+ * resolved name (unquoted, unescaped), while `from`/`to` cover the source
+ * spelling including any quotes.
  *
  * @example
  *   fslSemanticSpans('state s : { color: crimson; };')
  *     .find(s => s.kind === 'color')?.value;   // => '#dc143cff'
+ *
+ * @example
+ *   fslSemanticSpans('&G : [a b];\na -> b;')
+ *     .filter(s => s.kind === 'state').length;   // => 4 (two members + two endpoints)
  */
 function fslSemanticSpans(text) {
     let tree;
@@ -23694,7 +23789,7 @@ function fslSemanticSpans(text) {
  *  Useful for runtime diagnostics and for embedding in serialized machine
  *  snapshots so that deserializers can detect version-skew.
  */
-const version = "5.158.2";
+const version = "5.159.1";
 
 /**
  *  The FSL Markdown fence convention parser — pure, host-agnostic logic that
@@ -29379,6 +29474,26 @@ function vc(col) {
 function doublequote(txt) {
     return txt.replace(/"/g, '\\"');
 }
+/**
+ *  Reverse {@link doublequote}: turn DOT's `\"` escape back into the literal
+ *  `"` that graphviz renders into SVG `<text>` content.  Used by
+ *  {@link state_svg_label_texts} to reconstruct a node's on-screen label from
+ *  the DOT label it was handed, so the fence renderer keys against exactly what
+ *  was drawn.
+ *
+ *  ```typescript
+ *  undoublequote('a\\"b');  // 'a"b'
+ *  undoublequote('safe');   // 'safe'
+ *  ```
+ *
+ *  @param txt A DOT-escaped attribute string (as produced by `doublequote`).
+ *  @returns The string with every `\"` collapsed back to `"`.
+ *
+ *  @internal
+ */
+function undoublequote(txt) {
+    return txt.replace(/\\"/g, '"');
+}
 /**
  *  Convert a state name into a URL-friendly slug suitable for use as the
  *  body of a dot/SVG node identifier.  The transformation is:
@@ -30262,6 +30377,71 @@ function node_block_for(u_jssm, l_states, state_index, state_kinds, hide_labels,
     const { clusters, ungrouped_nodes } = groups_to_subgraph_string(u_jssm, l_states, state_index, state_kinds, hide_labels);
     return `${clusters}${(clusters && ungrouped_nodes) ? ' ' : ''}${ungrouped_nodes}`;
 }
+/**
+ *  The per-state group-chip map that {@link node_block_for} appends to labels
+ *  in a given render mode.  Mirrors that function's mode dispatch and calls the
+ *  very same chip sources — {@link chips_for_all_groups} for `'chips'`,
+ *  {@link plan_cluster_groups} (with identical inputs) for `'cluster'` — so a
+ *  reconstructed label can never disagree with the one graphviz was handed.
+ *  `'off'`, and any machine that declares no groups, yields an empty map.
+ *
+ *  @internal
+ */
+function chips_for_render_mode(u_jssm, l_states, mode) {
+    if ((mode === 'off') || (u_jssm.groups().length === 0)) {
+        return new Map();
+    }
+    if (mode === 'chips') {
+        return chips_for_all_groups(u_jssm, l_states);
+    }
+    const order = u_jssm.groups();
+    const parents = group_parent_map(u_jssm._group_registry, order);
+    return plan_cluster_groups(u_jssm, l_states, order, parents).chips;
+}
+/**
+ *  The exact text graphviz places in each state's SVG `<text>` element(s) when
+ *  a machine is rendered via {@link machine_to_dot} / {@link fsl_to_svg_string}:
+ *  the state's display text plus any group chips the node builder appends, with
+ *  DOT's `\"` escaping undone (SVG carries the literal character).  A label that
+ *  wraps across lines becomes several `<text>` elements; this returns the lines
+ *  joined by `\n`, exactly how {@link extract_state_fills} reads them back — so
+ *  the derived key and the extracted key meet at the same string.
+ *
+ *  This is the single source of truth the static fence renderer keys its
+ *  highlight and recolor lookups against, so those lookups can never drift from
+ *  what was actually drawn — plain labels, group chips, and multi-line wraps
+ *  alike.  It is built by running the node builder's own
+ *  `label_with_chips(doublequote(display_text), chips)` and inverting the one
+ *  escaping step, so it follows any change to the label format for free.
+ *
+ *  @param u_jssm The machine being rendered.
+ *  @param opts Render flags; only `render_groups` affects the label text
+ *  (default `'cluster'`, matching `fsl_to_svg_string`).
+ *  @returns A map from each state name to its rendered SVG label text.
+ *
+ *  ```typescript
+ *  import { sm } from 'jssm';
+ *  import { state_svg_label_texts } from 'jssm/viz';
+ *
+ *  // a state in two groups renders a chip suffix in its node label
+ *  state_svg_label_texts(sm`&g1 : [a b]; &g2 : [a]; a -> b;`).get('a');  // 'a [g1]'
+ *  state_svg_label_texts(sm`a -> b;`).get('a');                          // 'a'
+ *  ```
+ *
+ *  @see extract_state_fills
+ */
+function state_svg_label_texts(u_jssm, opts = {}) {
+    var _a, _b;
+    const l_states = u_jssm.states();
+    const mode = (_a = opts.render_groups) !== null && _a !== void 0 ? _a : 'cluster';
+    const chips = chips_for_render_mode(u_jssm, l_states, mode);
+    const out = new Map();
+    for (const s of l_states) {
+        const dot_label = label_with_chips(doublequote(u_jssm.display_text(s)), (_b = chips.get(s)) !== null && _b !== void 0 ? _b : []);
+        out.set(s, undoublequote(dot_label));
+    }
+    return out;
+}
 /**
  *  Render a {@link jssm.Machine} as a graphviz dot string.
  *
@@ -30378,6 +30558,17 @@ async function fsl_to_svg_string(fsl, opts = {}) {
     return dot_to_svg(fsl_to_dot(fsl, opts), opts);
 }
 
+/**
+ * The render targets supported in v1, in canonical order (the CLI `--target`
+ * enum and `--help` list order).  This tuple is the single runtime source of
+ * truth: both the {@link RenderTarget} type and the `fsl-render` CLI's
+ * `--target` enum derive from it, so a new target is declared in exactly one
+ * place.  Future targets (mermaid, plantuml, scxml, ascii, fsl) land here in
+ * v0.2+.
+ *
+ * @example
+ * RENDER_TARGETS.includes('gif' as RenderTarget);  // true
+ */
 /**
  * Base error class for render-time failures.
  */
@@ -31235,8 +31426,22 @@ function xml_unescape(s) {
 }
 /** Match one graphviz node group; capture [1] the group body. @internal */
 const NODE_GROUP_RE = /<g[^>]*\bclass="node"[^>]*>([\s\S]*?)<\/g>/g;
-const TEXT_RE = /<text[^>]*>([\s\S]*?)<\/text>/;
+const TEXT_RE_G = /<text[^>]*>([\s\S]*?)<\/text>/g;
 const SHAPE_FILL_RE = /(<(?:ellipse|polygon|path)\b[^>]*\bfill=")([^"]*)(")/;
+/**
+ *  The state key for one node group: the XML-unescaped content of *every* one
+ *  of its `<text>` elements, joined by `\n`.  Graphviz splits a label that
+ *  wraps across lines into one `<text>` per line, so reading only the first
+ *  would key on a truncated string; joining the lines with `\n` reconstructs
+ *  the machine's display text exactly (matching `state_svg_label_texts`).
+ *  Returns `null` for a node group carrying no `<text>` element at all.
+ *
+ *  @internal
+ */
+function node_label_text(body) {
+    const lines = [...body.matchAll(TEXT_RE_G)].map(m => xml_unescape(m[1]));
+    return lines.length === 0 ? null : lines.join('\n');
+}
 /**
  *  Read each state's current fill color out of a graphviz-rendered machine
  *  SVG, keyed by state name.  States whose shape carries no `fill` attribute
@@ -31253,13 +31458,10 @@ function extract_state_fills(svg) {
     const out = new Map();
     for (const group of svg.matchAll(NODE_GROUP_RE)) {
         const body = group[1];
-        const text = body.match(TEXT_RE);
+        const label = node_label_text(body);
         const shape = body.match(SHAPE_FILL_RE);
-        if (shape !== null && text !== null) {
-            const state_name = xml_unescape(text[1]);
-            if (state_name) {
-                out.set(state_name, shape[2]);
-            }
+        if (shape !== null && label !== null && label !== '') {
+            out.set(label, shape[2]);
         }
     }
     return out;
@@ -31284,11 +31486,11 @@ function patch_state_fill(svg, state, fill) {
         if (done) {
             return whole;
         }
-        const text = body.match(TEXT_RE);
-        if (text === null) {
+        const label = node_label_text(body);
+        if (label === null) {
             return whole;
         }
-        if (xml_unescape(text[1]) !== state) {
+        if (label !== state) {
             return whole;
         }
         // Function-form replacements: `fill` is caller-supplied and may itself
@@ -48763,7 +48965,8 @@ function quantize(rgba, max_colors = 256) {
         throw new JssmError(undefined, 'quantize: max_colors must be 2..256');
     }
     const pixel_count = rgba.length / 4;
-    // composite over white, build histogram of packed rgb keys
+    // composite over white, build histogram of packed rgb keys (packed[] retained
+    // so the per-pixel index step below need not recompute the keys)
     const packed = new Uint32Array(pixel_count);
     const histogram = new Map();
     for (let i = 0; i < pixel_count; ++i) {
@@ -48771,6 +48974,48 @@ function quantize(rgba, max_colors = 256) {
         packed[i] = key;
         histogram.set(key, ((_a = histogram.get(key)) !== null && _a !== void 0 ? _a : 0) + 1);
     }
+    const { palette, palette_count, index_of } = palette_from_histogram(histogram, max_colors);
+    const indices = new Uint8Array(pixel_count);
+    for (let i = 0; i < pixel_count; ++i) {
+        indices[i] = index_of.get(packed[i]);
+    }
+    return { palette, palette_count, indices };
+}
+/**
+ *  Accumulate one RGBA frame's composited-over-white colors into a shared
+ *  packed-rgb histogram, so an animation's union palette can be built by
+ *  streaming frame-by-frame instead of concatenating every frame's pixels into
+ *  one buffer first.  Iterating frames in order reproduces the exact key/count
+ *  sequence a concatenated buffer would yield, so the resulting palette is
+ *  byte-identical to quantizing the concatenation.
+ *
+ *  @param rgba - Straight RGBA bytes; length must be a multiple of 4.
+ *  @param histogram - Packed 0xRRGGBB key → count, mutated in place.
+ *
+ *  @example
+ *  const h = new Map<number, number>();
+ *  accumulate_histogram(new Uint8Array([255,0,0,255]), h);  // h: { 0xff0000 => 1 }
+ *
+ *  @internal
+ */
+function accumulate_histogram(rgba, histogram) {
+    var _a;
+    const pixel_count = rgba.length / 4;
+    for (let i = 0; i < pixel_count; ++i) {
+        const key = packed_over_white(rgba, i);
+        histogram.set(key, ((_a = histogram.get(key)) !== null && _a !== void 0 ? _a : 0) + 1);
+    }
+}
+/**
+ *  Derive a color palette from a packed-rgb histogram: when the histogram holds
+ *  `max_colors` or fewer distinct colors they are preserved exactly (in
+ *  insertion order); otherwise a median-cut partition supplies the palette.
+ *  Returned alongside the palette is `index_of`, mapping each source color key
+ *  to its palette slot, so callers can translate their own pixels.
+ *
+ *  @internal
+ */
+function palette_from_histogram(histogram, max_colors) {
     const distinct = [...histogram.keys()];
     if (distinct.length <= max_colors) {
         const index_of = new Map();
@@ -48781,13 +49026,9 @@ function quantize(rgba, max_colors = 256) {
             palette[i * 3 + 1] = (key >> 8) & 0xff;
             palette[i * 3 + 2] = key & 0xff;
         });
-        const indices = new Uint8Array(pixel_count);
-        for (let i = 0; i < pixel_count; ++i) {
-            indices[i] = index_of.get(packed[i]);
-        }
-        return { palette, palette_count: distinct.length, indices };
+        return { palette, palette_count: distinct.length, index_of };
     }
-    return median_cut(packed, histogram, max_colors);
+    return median_cut_palette(histogram, max_colors);
 }
 /** Channel extractors for packed 0xRRGGBB keys. @internal */
 const CHANNELS = [
@@ -48796,13 +49037,15 @@ const CHANNELS = [
     key => key & 0xff,
 ];
 /**
- *  Median-cut quantization over a pre-built histogram.  Splits the box with
- *  the widest channel range at its count-weighted median until `max_colors`
- *  boxes exist, then averages each box into a palette entry.
+ *  Median-cut palette over a pre-built histogram.  Splits the box with the
+ *  widest channel range at its count-weighted median until `max_colors` boxes
+ *  exist, then averages each box into a palette entry.  Returns the palette and
+ *  the color→slot map only; per-pixel indices are the caller's concern (the
+ *  animation encoder maps each frame separately, so it never needs them here).
  *
  *  @internal
  */
-function median_cut(packed, histogram, max_colors) {
+function median_cut_palette(histogram, max_colors) {
     const boxes = [[...histogram.keys()]];
     while (boxes.length < max_colors) {
         // pick the box with the widest single-channel range
@@ -48859,11 +49102,7 @@ function median_cut(packed, histogram, max_colors) {
         palette[bi * 3 + 1] = Math.round(g / n);
         palette[bi * 3 + 2] = Math.round(b / n);
     });
-    const indices = new Uint8Array(packed.length);
-    for (let i = 0; i < packed.length; ++i) {
-        indices[i] = index_of.get(packed[i]);
-    }
-    return { palette, palette_count: boxes.length, indices };
+    return { palette, palette_count: boxes.length, index_of };
 }
 /**
  *  GIF-variant LZW compression: emits a leading clear code, grows code width
@@ -48941,8 +49180,9 @@ function lzw_encode(indices, min_code_size) {
  *  @param frames - At least one frame; all with identical width/height and
  *  `rgba.length === 4 · width · height`.
  *
- *  @throws {JssmError} on zero frames, mismatched dimensions, or an rgba
- *  buffer whose length contradicts its stated dimensions.
+ *  @throws {JssmError} on zero frames, a zero-width or zero-height frame,
+ *  mismatched dimensions, or an rgba buffer whose length contradicts its
+ *  stated dimensions.
  *
  *  @example
  *  const red = { rgba: new Uint8Array([255,0,0,255]), width: 1, height: 1 };
@@ -48955,6 +49195,12 @@ function encode_gif(frames, opts = {}) {
         throw new JssmError(undefined, 'encode_gif: at least one frame is required');
     }
     const { width, height } = frames[0];
+    if (width === 0 || height === 0) {
+        // A 0×0 (or 0×h / w×0) frame passes the `4·w·h === rgba.length` check with
+        // an empty buffer, then reaches lzw_encode where `indices[0]!` coerces
+        // undefined into a bogus code 0 — a silently-corrupt GIF. Fail loudly here.
+        throw new JssmError(undefined, `encode_gif: frame dimensions must be non-zero (got ${width}x${height})`);
+    }
     for (const f of frames) {
         if (f.width !== width || f.height !== height) {
             throw new JssmError(undefined, `encode_gif: frame dimensions differ (${f.width}x${f.height} vs ${width}x${height})`);
@@ -48965,25 +49211,30 @@ function encode_gif(frames, opts = {}) {
     }
     const delay_cs = (_a = opts.delay_cs) !== null && _a !== void 0 ? _a : 70;
     const loop = (_b = opts.loop) !== null && _b !== void 0 ? _b : 0;
-    // global palette from all frames combined; when few distinct colors exist, preserve all exactly
-    const combined = new Uint8Array(frames.reduce((sum, f) => sum + f.rgba.length, 0));
-    let pos = 0;
+    // Global palette over the UNION of every frame, built by streaming each
+    // frame's histogram rather than concatenating all frames into one buffer
+    // first (64 frames × w×h×4 can reach hundreds of MB on a big machine).
+    // Frames are visited in order, so the key/count sequence — and therefore the
+    // palette — is byte-identical to quantizing the concatenation.
+    const union_histogram = new Map();
     for (const f of frames) {
-        combined.set(f.rgba, pos);
-        pos += f.rgba.length;
+        accumulate_histogram(f.rgba, union_histogram);
     }
-    const quantized = quantize(combined, 256);
-    const gct_bits = Math.max(1, Math.ceil(Math.log2(Math.max(2, quantized.palette_count))));
+    const { palette, palette_count } = palette_from_histogram(union_histogram, 256);
+    const gct_bits = Math.max(1, Math.ceil(Math.log2(Math.max(2, palette_count))));
     const gct_size = 1 << gct_bits;
     const min_code_size = Math.max(2, gct_bits);
-    /** Map a frame's pixels to nearest entries of the union-quantized global palette. @internal */
+    // One nearest-color cache for the whole encode: the global palette is
+    // identical across frames, so a color's best index never changes frame to
+    // frame — rebuilding the cache per frame only re-did the same work.
+    const palette_cache = new Map();
+    /** Map a frame's pixels to nearest entries of the union global palette. @internal */
     const map_to_palette = (rgba) => {
         const n = rgba.length / 4;
         const out = new Uint8Array(n);
-        const cache = new Map();
         for (let i = 0; i < n; ++i) {
             const key = packed_over_white(rgba, i);
-            const hit = cache.get(key);
+            const hit = palette_cache.get(key);
             if (hit !== undefined) {
                 out[i] = hit;
                 continue;
@@ -48992,67 +49243,83 @@ function encode_gif(frames, opts = {}) {
             const g = (key >> 8) & 0xff;
             const b = key & 0xff;
             let best = 0, best_d = Infinity;
-            for (let p = 0; p < quantized.palette_count; ++p) {
-                const dr = r - quantized.palette[p * 3];
-                const dg = g - quantized.palette[p * 3 + 1];
-                const db = b - quantized.palette[p * 3 + 2];
+            for (let p = 0; p < palette_count; ++p) {
+                const dr = r - palette[p * 3];
+                const dg = g - palette[p * 3 + 1];
+                const db = b - palette[p * 3 + 2];
                 const d = dr * dr + dg * dg + db * db;
                 if (d < best_d) {
                     best_d = d;
                     best = p;
                 }
             }
-            cache.set(key, best);
+            palette_cache.set(key, best);
             out[i] = best;
         }
         return out;
     };
-    const bytes = [];
-    const push_u16 = (v) => { bytes.push(v & 0xff, (v >> 8) & 0xff); };
+    // Output accumulates into a growable Uint8Array (doubling on demand) rather
+    // than a boxed-integer number[]; the final GIF is `out.subarray(0, len)`.
+    let out = new Uint8Array(1024);
+    let len = 0;
+    const need = (extra) => {
+        if (len + extra > out.length) {
+            const bigger = new Uint8Array(Math.max(out.length * 2, len + extra));
+            bigger.set(out.subarray(0, len));
+            out = bigger;
+        }
+    };
+    const push = (...vals) => {
+        need(vals.length);
+        for (let k = 0; k < vals.length; ++k) {
+            out[len++] = vals[k] & 0xff;
+        }
+    };
+    const push_u16 = (v) => { push(v & 0xff, (v >> 8) & 0xff); };
     // header + logical screen descriptor
-    bytes.push(0x47, 0x49, 0x46, 0x38, 0x39, 0x61); // "GIF89a"
+    push(0x47, 0x49, 0x46, 0x38, 0x39, 0x61); // "GIF89a"
     push_u16(width);
     push_u16(height);
-    bytes.push(0x80 | 0x70 | (gct_bits - 1)); // GCT present, color res 8-bit, size
-    bytes.push(0, 0); // background index, aspect
+    push(0x80 | 0x70 | (gct_bits - 1)); // GCT present, color res 8-bit, size
+    push(0, 0); // background index, aspect
     // global color table, padded to 2^gct_bits entries
     for (let p = 0; p < gct_size; ++p) {
-        if (p < quantized.palette_count) {
-            bytes.push(quantized.palette[p * 3], quantized.palette[p * 3 + 1], quantized.palette[p * 3 + 2]);
+        if (p < palette_count) {
+            push(palette[p * 3], palette[p * 3 + 1], palette[p * 3 + 2]);
         }
         else {
-            bytes.push(0, 0, 0);
+            push(0, 0, 0);
         }
     }
     // Netscape looping extension
-    bytes.push(0x21, 0xFF, 0x0B);
-    bytes.push(...'NETSCAPE2.0'.split('').map(c => c.charCodeAt(0)));
-    bytes.push(0x03, 0x01);
+    push(0x21, 0xFF, 0x0B);
+    push(...'NETSCAPE2.0'.split('').map(c => c.charCodeAt(0)));
+    push(0x03, 0x01);
     push_u16(loop);
-    bytes.push(0x00);
+    push(0x00);
     for (let fi = 0; fi < frames.length; ++fi) {
         // graphics control extension: disposal 1 (leave in place), no transparency
-        bytes.push(0x21, 0xF9, 0x04, 0x04);
+        push(0x21, 0xF9, 0x04, 0x04);
         push_u16(delay_cs);
-        bytes.push(0x00, 0x00);
+        push(0x00, 0x00);
         // image descriptor: full frame, no local color table
-        bytes.push(0x2C);
+        push(0x2C);
         push_u16(0);
         push_u16(0);
         push_u16(width);
         push_u16(height);
-        bytes.push(0x00);
+        push(0x00);
         const indices = map_to_palette(frames[fi].rgba);
-        const packed = lzw_encode(indices, min_code_size);
-        bytes.push(min_code_size);
-        for (let at = 0; at < packed.length; at += 255) {
-            const chunk = packed.slice(at, at + 255);
-            bytes.push(chunk.length, ...chunk);
+        const packed_lzw = lzw_encode(indices, min_code_size);
+        push(min_code_size);
+        for (let at = 0; at < packed_lzw.length; at += 255) {
+            const chunk = packed_lzw.slice(at, at + 255);
+            push(chunk.length, ...chunk);
         }
-        bytes.push(0x00); // block terminator
+        push(0x00); // block terminator
     }
-    bytes.push(0x3B); // trailer
-    return new Uint8Array(bytes);
+    push(0x3B); // trailer
+    return out.slice(0, len);
 }
 
 /**
@@ -49083,32 +49350,33 @@ function error_box(source, message) {
 /** Note comment, invisible but inspectable. @internal */
 const note_comment = (note) => `<!-- fsl-fence: ${escape_html(note)} -->`;
 /**
- *  Remap a display-text-keyed fill map (as produced by
- *  {@link extract_state_fills} from a rendered SVG) to be keyed by state
- *  NAME instead. Graphviz nodes are labeled with each state's display text
- *  (`label ?? name` — the same derivation `jssm_viz.ts`'s `state_node_line`
- *  uses via `machine.display_text(s)`), but `highlight_fsl_html`'s
- *  `state_colors` option is keyed by the state's own name (the code
- *  highlighter's semantic spans carry names, not labels). Without this
- *  remap, any labeled state's diagram color silently fails to reach its
- *  code span.
- *
- *  Handles the simple one-label-per-state case only; group-chip-suffixed
- *  labels (`label_with_chips` in jssm_viz.ts) render extra text after the
- *  label that this remap does not account for — filed as a follow-up.
- *
- *  @param machine - The constructed machine the fills were rendered from.
- *  @param fills - Display-text-keyed fills, from `extract_state_fills`.
+ *  Remap an SVG-label-keyed fill map (as produced by
+ *  {@link extract_state_fills} from a rendered SVG) to be keyed by state NAME
+ *  instead. Graphviz labels each node with its full rendered label text —
+ *  display text, plus any group chips, plus any multi-line wrap — while
+ *  `highlight_fsl_html`'s `state_colors` option is keyed by the state's own
+ *  name (the code highlighter's semantic spans carry names, not labels).
+ *  Without this remap, any state whose label diverges from its name silently
+ *  fails to carry its diagram color to its code span.
+ *
+ *  Both sides of the join derive the SVG label text from the same source:
+ *  `label_texts` comes from {@link state_svg_label_texts} (the viz's own label
+ *  builder) and `fills`'s keys are read straight off the SVG, so group chips
+ *  and multi-line labels are handled without either side drifting.
+ *
+ *  @param label_texts - State name → its rendered SVG label text, from
+ *  `state_svg_label_texts`.
+ *  @param fills - SVG-label-keyed fills, from `extract_state_fills`.
  *  @returns Fills re-keyed by state name; states with no matching fill are omitted.
  *
  *  @internal
  */
-function state_colors_by_name(machine, fills) {
+function state_colors_by_name(label_texts, fills) {
     const out = new Map();
-    for (const s of machine.states()) {
-        const fill = fills.get(machine.display_text(s));
+    for (const [state, label] of label_texts) {
+        const fill = fills.get(label);
         if (fill !== undefined) {
-            out.set(s, fill);
+            out.set(state, fill);
         }
     }
     return out;
@@ -49151,7 +49419,7 @@ async function render_fence_html(source, info, opts = {}) {
     }
     const svg = await fsl_to_svg_string(source);
     const fills = extract_state_fills(svg);
-    const state_colors = state_colors_by_name(machine, fills);
+    const state_colors = state_colors_by_name(state_svg_label_texts(machine), fills);
     const chunks = desc.notes.map(note_comment);
     for (const part of desc.parts) {
         if (INTERACTIVE_PARTS.has(part)) {
@@ -49286,14 +49554,15 @@ async function render_fence_gif(source, opts = {}) {
     const base_svg = await fsl_to_svg_string(source);
     const highlight = (_b = opts.highlight_fill) !== null && _b !== void 0 ? _b : '#ff9930';
     const scale = (_c = opts.scale) !== null && _c !== void 0 ? _c : 100;
+    const label_texts = state_svg_label_texts(machine);
     const frames = [];
     for (const state of walk) {
-        // base_svg's nodes are labeled with display text (label ?? name; the
-        // same `machine.display_text(s)` derivation jssm_viz.ts's
-        // state_node_line uses), not the walk's state NAME — patch by that or
-        // a labeled state's frame silently no-ops (see state_colors_by_name for
-        // the render_fence_html analog of this same fix).
-        const patched = patch_state_fill(base_svg, machine.display_text(state), highlight);
+        // base_svg's nodes are labeled with their full SVG label text (display
+        // text + any group chips + any multi-line wrap), not the walk's state
+        // NAME — patch by the shared derivation or a labeled/chipped/wrapped
+        // state's frame silently no-ops. `walk` is drawn from the machine's own
+        // states, so every entry has a label_texts key.
+        const patched = patch_state_fill(base_svg, label_texts.get(state), highlight);
         const raster = await rasterizeRgba(patched, { scale });
         frames.push({ rgba: raster.rgba, width: raster.width, height: raster.height });
     }