@knowvah/dot-engine 2.3.1 → 2.4.1

package/dist/index.js

@@ -110,9 +110,9 @@ function peg$parse(input, options) {
   const peg$c0 = "{";
   const peg$c1 = "}";
   const peg$c2 = ";";
-  const peg$c3 = "[";
-  const peg$c4 = "]";
-  const peg$c5 = "=";
+  const peg$c3 = "=";
+  const peg$c4 = "[";
+  const peg$c5 = "]";
   const peg$c6 = ":";
   const peg$c7 = "->";
   const peg$c8 = "--";
@@ -136,32 +136,30 @@ function peg$parse(input, options) {
   const peg$r3 = /^[A-Za-z_\x80-\uFFFF]/;
   const peg$r4 = /^[A-Za-z_0-9\x80-\uFFFF]/;
   const peg$r5 = /^[0-9]/;
-  const peg$r6 = /^[eE]/;
-  const peg$r7 = /^[+\-]/;
-  const peg$r8 = /^[Ss]/;
-  const peg$r9 = /^[Tt]/;
-  const peg$r10 = /^[Rr]/;
-  const peg$r11 = /^[Ii]/;
-  const peg$r12 = /^[Cc]/;
-  const peg$r13 = /^[Gg]/;
-  const peg$r14 = /^[Aa]/;
-  const peg$r15 = /^[Pp]/;
-  const peg$r16 = /^[Hh]/;
-  const peg$r17 = /^[Dd]/;
-  const peg$r18 = /^[Nn]/;
-  const peg$r19 = /^[Oo]/;
-  const peg$r20 = /^[Ee]/;
-  const peg$r21 = /^[Uu]/;
-  const peg$r22 = /^[Bb]/;
-  const peg$r23 = /^[ \t\r\n]/;
-  const peg$r24 = /^[^\n]/;
+  const peg$r6 = /^[Ss]/;
+  const peg$r7 = /^[Tt]/;
+  const peg$r8 = /^[Rr]/;
+  const peg$r9 = /^[Ii]/;
+  const peg$r10 = /^[Cc]/;
+  const peg$r11 = /^[Gg]/;
+  const peg$r12 = /^[Aa]/;
+  const peg$r13 = /^[Pp]/;
+  const peg$r14 = /^[Hh]/;
+  const peg$r15 = /^[Dd]/;
+  const peg$r16 = /^[Nn]/;
+  const peg$r17 = /^[Oo]/;
+  const peg$r18 = /^[Ee]/;
+  const peg$r19 = /^[Uu]/;
+  const peg$r20 = /^[Bb]/;
+  const peg$r21 = /^[ \t\r\n]/;
+  const peg$r22 = /^[^\n]/;
   const peg$e0 = peg$literalExpectation("{", false);
   const peg$e1 = peg$literalExpectation("}", false);
   const peg$e2 = peg$literalExpectation(";", false);
-  const peg$e3 = peg$literalExpectation("[", false);
-  const peg$e4 = peg$literalExpectation("]", false);
-  const peg$e5 = peg$classExpectation([";", ","], false, false, false);
-  const peg$e6 = peg$literalExpectation("=", false);
+  const peg$e3 = peg$literalExpectation("=", false);
+  const peg$e4 = peg$literalExpectation("[", false);
+  const peg$e5 = peg$literalExpectation("]", false);
+  const peg$e6 = peg$classExpectation([";", ","], false, false, false);
   const peg$e7 = peg$literalExpectation(":", false);
   const peg$e8 = peg$otherExpectation("edge operator");
   const peg$e9 = peg$literalExpectation("->", false);
@@ -181,30 +179,28 @@ function peg$parse(input, options) {
   const peg$e23 = peg$literalExpectation("-", false);
   const peg$e24 = peg$classExpectation([["0", "9"]], false, false, false);
   const peg$e25 = peg$literalExpectation(".", false);
-  const peg$e26 = peg$classExpectation(["e", "E"], false, false, false);
-  const peg$e27 = peg$classExpectation(["+", "-"], false, false, false);
-  const peg$e28 = peg$classExpectation(["S", "s"], false, false, false);
-  const peg$e29 = peg$classExpectation(["T", "t"], false, false, false);
-  const peg$e30 = peg$classExpectation(["R", "r"], false, false, false);
-  const peg$e31 = peg$classExpectation(["I", "i"], false, false, false);
-  const peg$e32 = peg$classExpectation(["C", "c"], false, false, false);
-  const peg$e33 = peg$classExpectation(["G", "g"], false, false, false);
-  const peg$e34 = peg$classExpectation(["A", "a"], false, false, false);
-  const peg$e35 = peg$classExpectation(["P", "p"], false, false, false);
-  const peg$e36 = peg$classExpectation(["H", "h"], false, false, false);
-  const peg$e37 = peg$classExpectation(["D", "d"], false, false, false);
-  const peg$e38 = peg$classExpectation(["N", "n"], false, false, false);
-  const peg$e39 = peg$classExpectation(["O", "o"], false, false, false);
-  const peg$e40 = peg$classExpectation(["E", "e"], false, false, false);
-  const peg$e41 = peg$classExpectation(["U", "u"], false, false, false);
-  const peg$e42 = peg$classExpectation(["B", "b"], false, false, false);
-  const peg$e43 = peg$classExpectation([" ", "	", "\r", "\n"], false, false, false);
-  const peg$e44 = peg$literalExpectation("/*", false);
-  const peg$e45 = peg$literalExpectation("*/", false);
-  const peg$e46 = peg$literalExpectation("//", false);
-  const peg$e47 = peg$classExpectation(["\n"], true, false, false);
-  const peg$e48 = peg$literalExpectation("\n", false);
-  const peg$e49 = peg$literalExpectation("#", false);
+  const peg$e26 = peg$classExpectation(["S", "s"], false, false, false);
+  const peg$e27 = peg$classExpectation(["T", "t"], false, false, false);
+  const peg$e28 = peg$classExpectation(["R", "r"], false, false, false);
+  const peg$e29 = peg$classExpectation(["I", "i"], false, false, false);
+  const peg$e30 = peg$classExpectation(["C", "c"], false, false, false);
+  const peg$e31 = peg$classExpectation(["G", "g"], false, false, false);
+  const peg$e32 = peg$classExpectation(["A", "a"], false, false, false);
+  const peg$e33 = peg$classExpectation(["P", "p"], false, false, false);
+  const peg$e34 = peg$classExpectation(["H", "h"], false, false, false);
+  const peg$e35 = peg$classExpectation(["D", "d"], false, false, false);
+  const peg$e36 = peg$classExpectation(["N", "n"], false, false, false);
+  const peg$e37 = peg$classExpectation(["O", "o"], false, false, false);
+  const peg$e38 = peg$classExpectation(["E", "e"], false, false, false);
+  const peg$e39 = peg$classExpectation(["U", "u"], false, false, false);
+  const peg$e40 = peg$classExpectation(["B", "b"], false, false, false);
+  const peg$e41 = peg$classExpectation([" ", "	", "\r", "\n"], false, false, false);
+  const peg$e42 = peg$literalExpectation("/*", false);
+  const peg$e43 = peg$literalExpectation("*/", false);
+  const peg$e44 = peg$literalExpectation("//", false);
+  const peg$e45 = peg$classExpectation(["\n"], true, false, false);
+  const peg$e46 = peg$literalExpectation("\n", false);
+  const peg$e47 = peg$literalExpectation("#", false);
   function peg$f0(s, t, id, stmts) {
     return {
       type: "graph",
@@ -247,37 +243,44 @@ function peg$parse(input, options) {
   function peg$f11(s) {
     return s;
   }
-  function peg$f12(t, attrs) {
+  function peg$f12(t, m, attrs) {
+    if (m) console.error("Warning: attribute macros not implemented");
     return { type: "attr", target: t, attrs };
   }
   function peg$f13(a) {
     return { type: "assign", key: a.key, value: a.value };
   }
   function peg$f14() {
-    return "graph";
+    return true;
   }
   function peg$f15() {
-    return "node";
+    return false;
   }
   function peg$f16() {
+    return "graph";
+  }
+  function peg$f17() {
+    return "node";
+  }
+  function peg$f18() {
     return "edge";
   }
-  function peg$f17(defs, rest) {
+  function peg$f19(defs, rest) {
     return defs.concat(rest);
   }
-  function peg$f18() {
+  function peg$f20() {
     return [];
   }
-  function peg$f19(a) {
+  function peg$f21(a) {
     return a;
   }
-  function peg$f20(pairs) {
+  function peg$f22(pairs) {
     return pairs;
   }
-  function peg$f21(k, v) {
+  function peg$f23(k, v) {
     return { key: k, value: v };
   }
-  function peg$f22(head, chain, attrs) {
+  function peg$f24(head, chain, attrs) {
     if (chain.length > 0) {
       const nodes = [head].concat(chain);
       return { type: "edge", nodes, attrs };
@@ -288,70 +291,70 @@ function peg$parse(input, options) {
       return { type: "node", id: head, attrs };
     }
   }
-  function peg$f23(s) {
+  function peg$f25(s) {
     return s;
   }
-  function peg$f24(n) {
+  function peg$f26(n) {
     return n;
   }
-  function peg$f25(id, port, compass) {
+  function peg$f27(id, port, compass) {
     return { id, port, compass };
   }
-  function peg$f26(id, port) {
+  function peg$f28(id, port) {
     return { id, port, compass: null };
   }
-  function peg$f27(id) {
+  function peg$f29(id) {
     return { id, port: null, compass: null };
   }
-  function peg$f28(s, rest) {
+  function peg$f30(s, rest) {
     return [s].concat(rest);
   }
-  function peg$f29() {
+  function peg$f31() {
     return [];
   }
-  function peg$f30(id, stmts) {
+  function peg$f32(id, stmts) {
     return { type: "subgraph", id, stmts };
   }
-  function peg$f31(stmts) {
+  function peg$f33(stmts) {
     return { type: "subgraph", id: null, stmts };
   }
-  function peg$f32(stmts) {
+  function peg$f34(stmts) {
     return { type: "subgraph", id: null, stmts };
   }
-  function peg$f33(first, s) {
+  function peg$f35(first, s) {
     return s;
   }
-  function peg$f34(first, rest) {
+  function peg$f36(first, rest) {
     return rest.length > 0 ? first + rest.join("") : first;
   }
-  function peg$f35(chars) {
+  function peg$f37(chars) {
     return chars.join("");
   }
-  function peg$f36() {
+  function peg$f38() {
     return '"';
   }
-  function peg$f37() {
+  function peg$f39() {
     return "";
   }
-  function peg$f38(c) {
+  function peg$f40(c) {
     return "\\" + c;
   }
-  function peg$f39(content) {
+  function peg$f41(content) {
     return "
" + content;
   }
-  function peg$f40(chars) {
+  function peg$f42(chars) {
     return chars.join("");
   }
-  function peg$f41(nested2, content) {
+  function peg$f43(nested2, content) {
     return "<" + content + ">";
   }
-  function peg$f42(n) {
+  function peg$f44(n) {
     return n;
   }
-  function peg$f43(first, rest) {
+  function peg$f45(first, rest) {
     return first + rest.join("");
   }
-  function peg$f44(s) {
+  function peg$f46(s) {
     return Array.isArray(s) ? s.flat(Infinity).filter((x) => x !== null && x !== void 0).join("") : String(s);
   }
   let peg$currPos = options.peg$currPos | 0;
@@ -722,15 +725,21 @@ function peg$parse(input, options) {
     return s0;
   }
   function peg$parseAttrStmt() {
-    let s0, s12, s2, s3;
+    let s0, s12, s2, s3, s4;
     s0 = peg$currPos;
     s12 = peg$parseAttrType();
     if (s12 !== peg$FAILED) {
       s2 = peg$parse_();
-      s3 = peg$parseAttrListReq();
+      s3 = peg$parseOptMacroName();
       if (s3 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s0 = peg$f12(s12, s3);
+        s4 = peg$parseAttrListReq();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f12(s12, s3, s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -750,13 +759,49 @@ function peg$parse(input, options) {
     }
     return s0;
   }
+  function peg$parseOptMacroName() {
+    let s0, s12, s2, s3, s4;
+    s0 = peg$currPos;
+    s12 = peg$parseAtom();
+    if (s12 !== peg$FAILED) {
+      s2 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 61) {
+        s3 = peg$c3;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e3);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        peg$savedPos = s0;
+        s0 = peg$f14();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s12 = "";
+      peg$savedPos = s0;
+      s12 = peg$f15();
+      s0 = s12;
+    }
+    return s0;
+  }
   function peg$parseAttrType() {
     let s0, s12;
     s0 = peg$currPos;
     s12 = peg$parseGraphKw();
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f14();
+      s12 = peg$f16();
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -764,7 +809,7 @@ function peg$parse(input, options) {
       s12 = peg$parseNodeKw();
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f15();
+        s12 = peg$f17();
       }
       s0 = s12;
       if (s0 === peg$FAILED) {
@@ -772,7 +817,7 @@ function peg$parse(input, options) {
         s12 = peg$parseEdgeKw();
         if (s12 !== peg$FAILED) {
           peg$savedPos = s0;
-          s12 = peg$f16();
+          s12 = peg$f18();
         }
         s0 = s12;
       }
@@ -784,12 +829,12 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s12 = peg$parse_();
     if (input.charCodeAt(peg$currPos) === 91) {
-      s2 = peg$c3;
+      s2 = peg$c4;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e3);
+        peg$fail(peg$e4);
       }
     }
     if (s2 !== peg$FAILED) {
@@ -797,19 +842,19 @@ function peg$parse(input, options) {
       s4 = peg$parseAttrDefs();
       s5 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 93) {
-        s6 = peg$c4;
+        s6 = peg$c5;
         peg$currPos++;
       } else {
         s6 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e4);
+          peg$fail(peg$e5);
         }
       }
       if (s6 !== peg$FAILED) {
         s7 = peg$parseAttrList();
         if (s7 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f17(s4, s7);
+          s0 = peg$f19(s4, s7);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -831,7 +876,7 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s12 = "";
       peg$savedPos = s0;
-      s12 = peg$f18();
+      s12 = peg$f20();
       s0 = s12;
     }
     return s0;
@@ -851,7 +896,7 @@ function peg$parse(input, options) {
       } else {
         s6 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e5);
+          peg$fail(peg$e6);
         }
       }
       if (s6 !== peg$FAILED) {
@@ -866,7 +911,7 @@ function peg$parse(input, options) {
         s5 = null;
       }
       peg$savedPos = s2;
-      s2 = peg$f19(s3);
+      s2 = peg$f21(s3);
     } else {
       peg$currPos = s2;
       s2 = peg$FAILED;
@@ -884,7 +929,7 @@ function peg$parse(input, options) {
         } else {
           s6 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e5);
+            peg$fail(peg$e6);
           }
         }
         if (s6 !== peg$FAILED) {
@@ -899,14 +944,14 @@ function peg$parse(input, options) {
           s5 = null;
         }
         peg$savedPos = s2;
-        s2 = peg$f19(s3);
+        s2 = peg$f21(s3);
       } else {
         peg$currPos = s2;
         s2 = peg$FAILED;
       }
     }
     peg$savedPos = s0;
-    s12 = peg$f20(s12);
+    s12 = peg$f22(s12);
     s0 = s12;
     return s0;
   }
@@ -917,12 +962,12 @@ function peg$parse(input, options) {
     if (s12 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c5;
+        s3 = peg$c3;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e6);
+          peg$fail(peg$e3);
         }
       }
       if (s3 !== peg$FAILED) {
@@ -930,7 +975,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAtom();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f21(s12, s5);
+          s0 = peg$f23(s12, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -957,7 +1002,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAttrList();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f22(s12, s3, s5);
+          s0 = peg$f24(s12, s3, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -978,7 +1023,7 @@ function peg$parse(input, options) {
     s12 = peg$parseSubgraph();
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f23(s12);
+      s12 = peg$f25(s12);
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -986,7 +1031,7 @@ function peg$parse(input, options) {
       s12 = peg$parseNode();
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f24(s12);
+        s12 = peg$f26(s12);
       }
       s0 = s12;
     }
@@ -1026,7 +1071,7 @@ function peg$parse(input, options) {
             s9 = peg$parseAtom();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f25(s12, s5, s9);
+              s0 = peg$f27(s12, s5, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -1066,7 +1111,7 @@ function peg$parse(input, options) {
           s5 = peg$parseAtom();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f26(s12, s5);
+            s0 = peg$f28(s12, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -1084,7 +1129,7 @@ function peg$parse(input, options) {
         s12 = peg$parseAtom();
         if (s12 !== peg$FAILED) {
           peg$savedPos = s0;
-          s12 = peg$f27(s12);
+          s12 = peg$f29(s12);
         }
         s0 = s12;
       }
@@ -1103,7 +1148,7 @@ function peg$parse(input, options) {
         s5 = peg$parseEdgeChain();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f28(s3, s5);
+          s0 = peg$f30(s3, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1120,7 +1165,7 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s12 = "";
       peg$savedPos = s0;
-      s12 = peg$f29();
+      s12 = peg$f31();
       s0 = s12;
     }
     return s0;
@@ -1191,7 +1236,7 @@ function peg$parse(input, options) {
             }
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f30(s3, s7);
+              s0 = peg$f32(s3, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -1242,7 +1287,7 @@ function peg$parse(input, options) {
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f31(s5);
+              s0 = peg$f33(s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -1286,7 +1331,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f32(s3);
+              s0 = peg$f34(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -1325,7 +1370,7 @@ function peg$parse(input, options) {
         s7 = peg$parseQAtom();
         if (s7 !== peg$FAILED) {
           peg$savedPos = s3;
-          s3 = peg$f33(s12, s7);
+          s3 = peg$f35(s12, s7);
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
@@ -1352,7 +1397,7 @@ function peg$parse(input, options) {
           s7 = peg$parseQAtom();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s3;
-            s3 = peg$f33(s12, s7);
+            s3 = peg$f35(s12, s7);
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -1363,7 +1408,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f34(s12, s2);
+      s0 = peg$f36(s12, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1411,7 +1456,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f35(s2);
+        s0 = peg$f37(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1436,7 +1481,7 @@ function peg$parse(input, options) {
     }
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f36();
+      s12 = peg$f38();
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -1452,7 +1497,7 @@ function peg$parse(input, options) {
       }
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f37();
+        s12 = peg$f39();
       }
       s0 = s12;
       if (s0 === peg$FAILED) {
@@ -1478,7 +1523,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f38(s2);
+            s0 = peg$f40(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -1527,7 +1572,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f39(s2);
+        s0 = peg$f41(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1548,7 +1593,7 @@ function peg$parse(input, options) {
       s2 = peg$parseHtmlChar();
     }
     peg$savedPos = s0;
-    s12 = peg$f40(s12);
+    s12 = peg$f42(s12);
     s0 = s12;
     return s0;
   }
@@ -1578,7 +1623,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f41(s12, s2);
+          s0 = peg$f43(s12, s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1623,7 +1668,7 @@ function peg$parse(input, options) {
         s2 = peg$parseName();
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f42(s2);
+          s0 = peg$f44(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1671,7 +1716,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f43(s12, s2);
+      s0 = peg$f45(s12, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1821,70 +1866,7 @@ function peg$parse(input, options) {
       }
     }
     if (s3 !== peg$FAILED) {
-      s4 = peg$currPos;
-      s5 = input.charAt(peg$currPos);
-      if (peg$r6.test(s5)) {
-        peg$currPos++;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) {
-          peg$fail(peg$e26);
-        }
-      }
-      if (s5 !== peg$FAILED) {
-        s6 = input.charAt(peg$currPos);
-        if (peg$r7.test(s6)) {
-          peg$currPos++;
-        } else {
-          s6 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$e27);
-          }
-        }
-        if (s6 === peg$FAILED) {
-          s6 = null;
-        }
-        s7 = [];
-        s8 = input.charAt(peg$currPos);
-        if (peg$r5.test(s8)) {
-          peg$currPos++;
-        } else {
-          s8 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$e24);
-          }
-        }
-        if (s8 !== peg$FAILED) {
-          while (s8 !== peg$FAILED) {
-            s7.push(s8);
-            s8 = input.charAt(peg$currPos);
-            if (peg$r5.test(s8)) {
-              peg$currPos++;
-            } else {
-              s8 = peg$FAILED;
-              if (peg$silentFails === 0) {
-                peg$fail(peg$e24);
-              }
-            }
-          }
-        } else {
-          s7 = peg$FAILED;
-        }
-        if (s7 !== peg$FAILED) {
-          s5 = [s5, s6, s7];
-          s4 = s5;
-        } else {
-          peg$currPos = s4;
-          s4 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s4;
-        s4 = peg$FAILED;
-      }
-      if (s4 === peg$FAILED) {
-        s4 = null;
-      }
-      s2 = [s2, s3, s4];
+      s2 = [s2, s3];
       s12 = s2;
     } else {
       peg$currPos = s12;
@@ -1892,7 +1874,7 @@ function peg$parse(input, options) {
     }
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f44(s12);
+      s12 = peg$f46(s12);
     }
     s0 = s12;
     return s0;
@@ -1901,62 +1883,62 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r8.test(s12)) {
+    if (peg$r6.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r9.test(s2)) {
+      if (peg$r7.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e29);
+          peg$fail(peg$e27);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r10.test(s3)) {
+        if (peg$r8.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e30);
+            peg$fail(peg$e28);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r11.test(s4)) {
+          if (peg$r9.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e31);
+              peg$fail(peg$e29);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r12.test(s5)) {
+            if (peg$r10.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e32);
+                peg$fail(peg$e30);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r9.test(s6)) {
+              if (peg$r7.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e29);
+                  peg$fail(peg$e27);
                 }
               }
               if (s6 !== peg$FAILED) {
@@ -2007,52 +1989,52 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r13.test(s12)) {
+    if (peg$r11.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e33);
+        peg$fail(peg$e31);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r10.test(s2)) {
+      if (peg$r8.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e30);
+          peg$fail(peg$e28);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r14.test(s3)) {
+        if (peg$r12.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e34);
+            peg$fail(peg$e32);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r15.test(s4)) {
+          if (peg$r13.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e35);
+              peg$fail(peg$e33);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r16.test(s5)) {
+            if (peg$r14.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e36);
+                peg$fail(peg$e34);
               }
             }
             if (s5 !== peg$FAILED) {
@@ -2099,72 +2081,72 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8, s9;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r17.test(s12)) {
+    if (peg$r15.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e37);
+        peg$fail(peg$e35);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r11.test(s2)) {
+      if (peg$r9.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e31);
+          peg$fail(peg$e29);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r13.test(s3)) {
+        if (peg$r11.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r10.test(s4)) {
+          if (peg$r8.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e30);
+              peg$fail(peg$e28);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r14.test(s5)) {
+            if (peg$r12.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e34);
+                peg$fail(peg$e32);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r15.test(s6)) {
+              if (peg$r13.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e35);
+                  peg$fail(peg$e33);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r16.test(s7)) {
+                if (peg$r14.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e36);
+                    peg$fail(peg$e34);
                   }
                 }
                 if (s7 !== peg$FAILED) {
@@ -2219,42 +2201,42 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r18.test(s12)) {
+    if (peg$r16.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e38);
+        peg$fail(peg$e36);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r19.test(s2)) {
+      if (peg$r17.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e39);
+          peg$fail(peg$e37);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r17.test(s3)) {
+        if (peg$r15.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e37);
+            peg$fail(peg$e35);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r20.test(s4)) {
+          if (peg$r18.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e40);
+              peg$fail(peg$e38);
             }
           }
           if (s4 !== peg$FAILED) {
@@ -2297,42 +2279,42 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r20.test(s12)) {
+    if (peg$r18.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e40);
+        peg$fail(peg$e38);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r17.test(s2)) {
+      if (peg$r15.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e37);
+          peg$fail(peg$e35);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r13.test(s3)) {
+        if (peg$r11.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r20.test(s4)) {
+          if (peg$r18.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e40);
+              peg$fail(peg$e38);
             }
           }
           if (s4 !== peg$FAILED) {
@@ -2375,82 +2357,82 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8, s9, s10;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r8.test(s12)) {
+    if (peg$r6.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r21.test(s2)) {
+      if (peg$r19.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e41);
+          peg$fail(peg$e39);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r22.test(s3)) {
+        if (peg$r20.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e42);
+            peg$fail(peg$e40);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r13.test(s4)) {
+          if (peg$r11.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e33);
+              peg$fail(peg$e31);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r10.test(s5)) {
+            if (peg$r8.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e30);
+                peg$fail(peg$e28);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r14.test(s6)) {
+              if (peg$r12.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e34);
+                  peg$fail(peg$e32);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r15.test(s7)) {
+                if (peg$r13.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e35);
+                    peg$fail(peg$e33);
                   }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = input.charAt(peg$currPos);
-                  if (peg$r16.test(s8)) {
+                  if (peg$r14.test(s8)) {
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e36);
+                      peg$fail(peg$e34);
                     }
                   }
                   if (s8 !== peg$FAILED) {
@@ -2523,62 +2505,62 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s12 = peg$currPos;
     s2 = input.charAt(peg$currPos);
-    if (peg$r8.test(s2)) {
+    if (peg$r6.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s2 !== peg$FAILED) {
       s3 = input.charAt(peg$currPos);
-      if (peg$r9.test(s3)) {
+      if (peg$r7.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e29);
+          peg$fail(peg$e27);
         }
       }
       if (s3 !== peg$FAILED) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r10.test(s4)) {
+        if (peg$r8.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e30);
+            peg$fail(peg$e28);
           }
         }
         if (s4 !== peg$FAILED) {
           s5 = input.charAt(peg$currPos);
-          if (peg$r11.test(s5)) {
+          if (peg$r9.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e31);
+              peg$fail(peg$e29);
             }
           }
           if (s5 !== peg$FAILED) {
             s6 = input.charAt(peg$currPos);
-            if (peg$r12.test(s6)) {
+            if (peg$r10.test(s6)) {
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e32);
+                peg$fail(peg$e30);
               }
             }
             if (s6 !== peg$FAILED) {
               s7 = input.charAt(peg$currPos);
-              if (peg$r9.test(s7)) {
+              if (peg$r7.test(s7)) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e29);
+                  peg$fail(peg$e27);
                 }
               }
               if (s7 !== peg$FAILED) {
@@ -2611,72 +2593,72 @@ function peg$parse(input, options) {
     if (s12 === peg$FAILED) {
       s12 = peg$currPos;
       s2 = input.charAt(peg$currPos);
-      if (peg$r17.test(s2)) {
+      if (peg$r15.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e37);
+          peg$fail(peg$e35);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r11.test(s3)) {
+        if (peg$r9.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e31);
+            peg$fail(peg$e29);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r13.test(s4)) {
+          if (peg$r11.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e33);
+              peg$fail(peg$e31);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r10.test(s5)) {
+            if (peg$r8.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e30);
+                peg$fail(peg$e28);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r14.test(s6)) {
+              if (peg$r12.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e34);
+                  peg$fail(peg$e32);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r15.test(s7)) {
+                if (peg$r13.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e35);
+                    peg$fail(peg$e33);
                   }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = input.charAt(peg$currPos);
-                  if (peg$r16.test(s8)) {
+                  if (peg$r14.test(s8)) {
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e36);
+                      peg$fail(peg$e34);
                     }
                   }
                   if (s8 !== peg$FAILED) {
@@ -2713,52 +2695,52 @@ function peg$parse(input, options) {
       if (s12 === peg$FAILED) {
         s12 = peg$currPos;
         s2 = input.charAt(peg$currPos);
-        if (peg$r13.test(s2)) {
+        if (peg$r11.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s2 !== peg$FAILED) {
           s3 = input.charAt(peg$currPos);
-          if (peg$r10.test(s3)) {
+          if (peg$r8.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e30);
+              peg$fail(peg$e28);
             }
           }
           if (s3 !== peg$FAILED) {
             s4 = input.charAt(peg$currPos);
-            if (peg$r14.test(s4)) {
+            if (peg$r12.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e34);
+                peg$fail(peg$e32);
               }
             }
             if (s4 !== peg$FAILED) {
               s5 = input.charAt(peg$currPos);
-              if (peg$r15.test(s5)) {
+              if (peg$r13.test(s5)) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e35);
+                  peg$fail(peg$e33);
                 }
               }
               if (s5 !== peg$FAILED) {
                 s6 = input.charAt(peg$currPos);
-                if (peg$r16.test(s6)) {
+                if (peg$r14.test(s6)) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e36);
+                    peg$fail(peg$e34);
                   }
                 }
                 if (s6 !== peg$FAILED) {
@@ -2787,42 +2769,42 @@ function peg$parse(input, options) {
         if (s12 === peg$FAILED) {
           s12 = peg$currPos;
           s2 = input.charAt(peg$currPos);
-          if (peg$r18.test(s2)) {
+          if (peg$r16.test(s2)) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e38);
+              peg$fail(peg$e36);
             }
           }
           if (s2 !== peg$FAILED) {
             s3 = input.charAt(peg$currPos);
-            if (peg$r19.test(s3)) {
+            if (peg$r17.test(s3)) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e39);
+                peg$fail(peg$e37);
               }
             }
             if (s3 !== peg$FAILED) {
               s4 = input.charAt(peg$currPos);
-              if (peg$r17.test(s4)) {
+              if (peg$r15.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e37);
+                  peg$fail(peg$e35);
                 }
               }
               if (s4 !== peg$FAILED) {
                 s5 = input.charAt(peg$currPos);
-                if (peg$r20.test(s5)) {
+                if (peg$r18.test(s5)) {
                   peg$currPos++;
                 } else {
                   s5 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e40);
+                    peg$fail(peg$e38);
                   }
                 }
                 if (s5 !== peg$FAILED) {
@@ -2847,42 +2829,42 @@ function peg$parse(input, options) {
           if (s12 === peg$FAILED) {
             s12 = peg$currPos;
             s2 = input.charAt(peg$currPos);
-            if (peg$r20.test(s2)) {
+            if (peg$r18.test(s2)) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e40);
+                peg$fail(peg$e38);
               }
             }
             if (s2 !== peg$FAILED) {
               s3 = input.charAt(peg$currPos);
-              if (peg$r17.test(s3)) {
+              if (peg$r15.test(s3)) {
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e37);
+                  peg$fail(peg$e35);
                 }
               }
               if (s3 !== peg$FAILED) {
                 s4 = input.charAt(peg$currPos);
-                if (peg$r13.test(s4)) {
+                if (peg$r11.test(s4)) {
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e33);
+                    peg$fail(peg$e31);
                   }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = input.charAt(peg$currPos);
-                  if (peg$r20.test(s5)) {
+                  if (peg$r18.test(s5)) {
                     peg$currPos++;
                   } else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e40);
+                      peg$fail(peg$e38);
                     }
                   }
                   if (s5 !== peg$FAILED) {
@@ -2907,82 +2889,82 @@ function peg$parse(input, options) {
             if (s12 === peg$FAILED) {
               s12 = peg$currPos;
               s2 = input.charAt(peg$currPos);
-              if (peg$r8.test(s2)) {
+              if (peg$r6.test(s2)) {
                 peg$currPos++;
               } else {
                 s2 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e28);
+                  peg$fail(peg$e26);
                 }
               }
               if (s2 !== peg$FAILED) {
                 s3 = input.charAt(peg$currPos);
-                if (peg$r21.test(s3)) {
+                if (peg$r19.test(s3)) {
                   peg$currPos++;
                 } else {
                   s3 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e41);
+                    peg$fail(peg$e39);
                   }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = input.charAt(peg$currPos);
-                  if (peg$r22.test(s4)) {
+                  if (peg$r20.test(s4)) {
                     peg$currPos++;
                   } else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e42);
+                      peg$fail(peg$e40);
                     }
                   }
                   if (s4 !== peg$FAILED) {
                     s5 = input.charAt(peg$currPos);
-                    if (peg$r13.test(s5)) {
+                    if (peg$r11.test(s5)) {
                       peg$currPos++;
                     } else {
                       s5 = peg$FAILED;
                       if (peg$silentFails === 0) {
-                        peg$fail(peg$e33);
+                        peg$fail(peg$e31);
                       }
                     }
                     if (s5 !== peg$FAILED) {
                       s6 = input.charAt(peg$currPos);
-                      if (peg$r10.test(s6)) {
+                      if (peg$r8.test(s6)) {
                         peg$currPos++;
                       } else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
-                          peg$fail(peg$e30);
+                          peg$fail(peg$e28);
                         }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = input.charAt(peg$currPos);
-                        if (peg$r14.test(s7)) {
+                        if (peg$r12.test(s7)) {
                           peg$currPos++;
                         } else {
                           s7 = peg$FAILED;
                           if (peg$silentFails === 0) {
-                            peg$fail(peg$e34);
+                            peg$fail(peg$e32);
                           }
                         }
                         if (s7 !== peg$FAILED) {
                           s8 = input.charAt(peg$currPos);
-                          if (peg$r15.test(s8)) {
+                          if (peg$r13.test(s8)) {
                             peg$currPos++;
                           } else {
                             s8 = peg$FAILED;
                             if (peg$silentFails === 0) {
-                              peg$fail(peg$e35);
+                              peg$fail(peg$e33);
                             }
                           }
                           if (s8 !== peg$FAILED) {
                             s9 = input.charAt(peg$currPos);
-                            if (peg$r16.test(s9)) {
+                            if (peg$r14.test(s9)) {
                               peg$currPos++;
                             } else {
                               s9 = peg$FAILED;
                               if (peg$silentFails === 0) {
-                                peg$fail(peg$e36);
+                                peg$fail(peg$e34);
                               }
                             }
                             if (s9 !== peg$FAILED) {
@@ -3054,24 +3036,24 @@ function peg$parse(input, options) {
     s0 = [];
     s12 = [];
     s2 = input.charAt(peg$currPos);
-    if (peg$r23.test(s2)) {
+    if (peg$r21.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e43);
+        peg$fail(peg$e41);
       }
     }
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
         s12.push(s2);
         s2 = input.charAt(peg$currPos);
-        if (peg$r23.test(s2)) {
+        if (peg$r21.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e43);
+            peg$fail(peg$e41);
           }
         }
       }
@@ -3091,24 +3073,24 @@ function peg$parse(input, options) {
       s0.push(s12);
       s12 = [];
       s2 = input.charAt(peg$currPos);
-      if (peg$r23.test(s2)) {
+      if (peg$r21.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e43);
+          peg$fail(peg$e41);
         }
       }
       if (s2 !== peg$FAILED) {
         while (s2 !== peg$FAILED) {
           s12.push(s2);
           s2 = input.charAt(peg$currPos);
-          if (peg$r23.test(s2)) {
+          if (peg$r21.test(s2)) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e43);
+              peg$fail(peg$e41);
             }
           }
         }
@@ -3136,7 +3118,7 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e44);
+        peg$fail(peg$e42);
       }
     }
     if (s12 !== peg$FAILED) {
@@ -3150,7 +3132,7 @@ function peg$parse(input, options) {
       } else {
         s5 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e45);
+          peg$fail(peg$e43);
         }
       }
       peg$silentFails--;
@@ -3192,7 +3174,7 @@ function peg$parse(input, options) {
         } else {
           s5 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e45);
+            peg$fail(peg$e43);
           }
         }
         peg$silentFails--;
@@ -3230,7 +3212,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e45);
+          peg$fail(peg$e43);
         }
       }
       if (s3 !== peg$FAILED) {
@@ -3255,29 +3237,29 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e46);
+        peg$fail(peg$e44);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r24.test(s3)) {
+      if (peg$r22.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e47);
+          peg$fail(peg$e45);
         }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r24.test(s3)) {
+        if (peg$r22.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e47);
+            peg$fail(peg$e45);
           }
         }
       }
@@ -3287,7 +3269,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e48);
+          peg$fail(peg$e46);
         }
       }
       if (s3 === peg$FAILED) {
@@ -3332,29 +3314,29 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e49);
+        peg$fail(peg$e47);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r24.test(s3)) {
+      if (peg$r22.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e47);
+          peg$fail(peg$e45);
         }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r24.test(s3)) {
+        if (peg$r22.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e47);
+            peg$fail(peg$e45);
           }
         }
       }
@@ -3364,7 +3346,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e48);
+          peg$fail(peg$e46);
         }
       }
       if (s3 === peg$FAILED) {
@@ -4266,6 +4248,75 @@ function buildFromAst(ast) {
   return graph;
 }
 
+// src/parser/number-scan.ts
+var ASCII_DEL = 127;
+function isLetter(c) {
+  if (c === void 0) return false;
+  return c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c.charCodeAt(0) > ASCII_DEL;
+}
+function isDigit(c) {
+  return c !== void 0 && c >= "0" && c <= "9";
+}
+function startsNumber(s, i) {
+  const c = s[i];
+  if (isDigit(c)) return true;
+  if (c === ".") return isDigit(s[i + 1]);
+  if (c !== "-") return false;
+  return isDigit(s[i + 1]) || s[i + 1] === "." && isDigit(s[i + 2]);
+}
+function matchNumber(s, i) {
+  let j = s[i] === "-" ? i + 1 : i;
+  if (s[j] === ".") {
+    j++;
+    while (isDigit(s[j])) j++;
+  } else {
+    while (isDigit(s[j])) j++;
+    if (s[j] === ".") {
+      j++;
+      while (isDigit(s[j])) j++;
+    }
+  }
+  if (s[j] === "." || isLetter(s[j])) j++;
+  return j;
+}
+function twoDots(text) {
+  const dot = text.indexOf(".");
+  return dot !== -1 && dot !== text.length - 1;
+}
+function chkNum(text) {
+  const c = text[text.length - 1];
+  return !isDigit(c) && c !== "." || c === "." && twoDots(text);
+}
+function lexToken(s, i) {
+  if (isLetter(s[i])) {
+    let j2 = i + 1;
+    while (isLetter(s[j2]) || isDigit(s[j2])) j2++;
+    return { next: j2, bad: null };
+  }
+  if (s[i] === "-" && (s[i + 1] === "-" || s[i + 1] === ">")) return { next: i + 2, bad: null };
+  if (!startsNumber(s, i)) return { next: i + 1, bad: null };
+  const j = matchNumber(s, i);
+  const text = s.slice(i, j);
+  return chkNum(text) ? { next: j - 1, bad: text } : { next: j, bad: null };
+}
+function scanNumberAmbiguities(src, stripped) {
+  const out = [];
+  let line = 1;
+  let lineAt = 0;
+  for (let i = 0; i < stripped.length; ) {
+    const { next, bad } = lexToken(stripped, i);
+    if (bad !== null) {
+      for (; lineAt < i; lineAt++) if (src[lineAt] === "\n") line++;
+      out.push({ text: bad, line, offset: i });
+    }
+    i = next;
+  }
+  return out;
+}
+function numberAmbiguityMessage(a) {
+  return `Warning: syntax ambiguity - badly delimited number '${a.text}' in line ${a.line} of input splits into two tokens`;
+}
+
 // src/errors.ts
 var FRIENDLY_MESSAGES = {
   SYNTAX_ERROR: "There is a syntax error in the DOT source.",
@@ -4542,6 +4593,12 @@ function isPeggyError(err) {
   if (typeof e["location"] !== "object" || e["location"] === null) return false;
   return "start" in e["location"];
 }
+function warnNumberAmbiguities(src, upTo) {
+  for (const a of scanNumberAmbiguities(src, Stripper.strip(src))) {
+    if (a.offset > upTo) break;
+    console.error(numberAmbiguityMessage(a));
+  }
+}
 function parse(src) {
   if (typeof src !== "string") {
     throw invalidArgType("dotSource", "string", src);
@@ -4552,6 +4609,7 @@ function parse(src) {
   } catch (err) {
     if (isPeggyError(err)) {
       const start = err.location.start;
+      warnNumberAmbiguities(src, start.offset);
       const code = err.found === null ? "SYNTAX_UNEXPECTED_EOF" : "SYNTAX_ERROR";
       throw new ParseError(
         err instanceof Error ? err.message : String(err),
@@ -4569,6 +4627,7 @@ function parse(src) {
     }
     throw err;
   }
+  warnNumberAmbiguities(src, src.length);
   validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }
@@ -5552,6 +5611,10 @@ var RenderJob = class {
   format;
   bb = { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } };
   pad = { x: 0, y: 0 };
+  /** Current page clip in graph units, as setup_page computes it from the
+   * viewport focus/view (see setupPageClip). Read by the SVG page translate and
+   * background. @see lib/gvc/gvcjob.h:GVJ_s.clip; lib/common/emit.c:setup_page */
+  clip = { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } };
   /** Graph-level `margin=` (init_job_margin); page-pagination margin, distinct
    * from node/cluster label margin. @see lib/common/emit.c:3309-3331 */
   margin = { x: 0, y: 0 };
@@ -5721,6 +5784,8 @@ function gvrenderTextspan(renderer, pos, span, job) {
 }
 
 // src/util/math.ts
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
 function isExactlyEqual(a, b) {
   const buf = new ArrayBuffer(16);
   const dv = new DataView(buf);
@@ -5732,6 +5797,11 @@ function isExactlyEqual(a, b) {
   }
   return true;
 }
+function d2i(v) {
+  if (v > INT32_MAX) return INT32_MAX;
+  if (v < INT32_MIN) return INT32_MIN;
+  return Math.trunc(v);
+}
 
 // src/common/colorData.ts
 var COLOR_LIB = [
@@ -9881,11 +9951,11 @@ function emitHtmlLabel(placed, pos, renderer, job) {
         style: placed.style
       });
     }
-    for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
     emitTableRules(placed, pos, renderer, job);
     if (placed.border > 0) {
       emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
     }
+    for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
   }
   if (inAnchor) endHtmlAnchor(renderer, job);
   if (clustersLast && initHtmlAnchor(anchorData, tblBox, renderer, job)) {
@@ -15743,8 +15813,8 @@ function normalizeFontName(name) {
   for (let i = 0; i < name.length; i++) {
     const ch = name[i];
     const code = ch.charCodeAt(0);
-    const isLetter = code >= 65 && code <= 90 || code >= 97 && code <= 122;
-    if (isLetter) result += ch.toLowerCase();
+    const isLetter2 = code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    if (isLetter2) result += ch.toLowerCase();
   }
   return result;
 }
@@ -16603,7 +16673,7 @@ function interpretCRNL(str) {
 
 // src/common/make-label.ts
 var DEFAULT_FONTSIZE2 = 14;
-var DEFAULT_FONTNAME = "Times,serif";
+var DEFAULT_FONTNAME = "Times-Roman";
 var DEFAULT_COLOR2 = "black";
 function getPenColor(obj) {
   if (obj === void 0) return void 0;
@@ -16870,6 +16940,18 @@ function fms(a, b, c) {
 function cround(v) {
   return v >= 0 ? Math.floor(v + 0.5) : Math.ceil(v - 0.5);
 }
+var INT64_MAX = 2n ** 63n - 1n;
+var INT64_MIN = -(2n ** 63n);
+var TWO_POW_63 = 2 ** 63;
+function croundNarrow32(v) {
+  const r = cround(v);
+  let i64;
+  if (Number.isNaN(r)) i64 = 0n;
+  else if (r >= TWO_POW_63) i64 = INT64_MAX;
+  else if (r < -TWO_POW_63) i64 = INT64_MIN;
+  else i64 = BigInt(r);
+  return Number(BigInt.asIntN(32, i64));
+}
 function RADIANS(deg) {
   return deg / 180 * Math.PI;
 }
@@ -23576,9 +23658,12 @@ function isMulticolor(fillcolor) {
   return fillcolor.includes(":");
 }
 function renderEllipse(ring, coord, renderer, job, filled) {
-  const rx = Math.abs((ring[1].x - ring[0].x) / 2);
-  const ry = Math.abs((ring[1].y - ring[0].y) / 2);
-  const center = transformPoint(coord, job);
+  const af0 = { x: ring[0].x + coord.x, y: ring[0].y + coord.y };
+  const af1 = { x: ring[1].x + coord.x, y: ring[1].y + coord.y };
+  const mid = { x: (af0.x + af1.x) / 2, y: (af0.y + af1.y) / 2 };
+  const rx = af1.x - mid.x;
+  const ry = af1.y - mid.y;
+  const center = transformPoint(mid, job);
   renderer.ellipse(center, rx, ry, filled, job);
 }
 function renderPolygon(ring, coord, renderer, job, filled) {
@@ -25420,7 +25505,7 @@ var BGCOLOR_TRANSPARENT = "\0transparent";
 function formatG(n) {
   return String(parseFloat(n.toPrecision(6)));
 }
-function emitSvgTag(job) {
+function emitSvgTag(job, svgid = "") {
   const bb = job.bb;
   const szx = bb.ur.x - bb.ll.x + 2 * job.pad.x;
   const szy = bb.ur.y - bb.ll.y + 2 * job.pad.y;
@@ -25429,16 +25514,20 @@ function emitSvgTag(job) {
   const rotated = job.rotation !== 0;
   const pageX = rotated ? viewY : viewX;
   const pageY = rotated ? viewX : viewY;
-  const w = cround(pageX + 2 * job.margin.x);
-  const h = cround(pageY + 2 * job.margin.y);
+  const w = croundNarrow32(pageX + 2 * job.margin.x);
+  const h = croundNarrow32(pageY + 2 * job.margin.y);
   job.write('<svg width="' + String(w) + 'pt" height="' + String(h) + 'pt"\n');
-  const vbLLx = cround(job.margin.x);
-  const vbLLy = cround(job.margin.y);
-  const vbURx = cround(job.margin.x + pageX);
-  const vbURy = cround(job.margin.y + pageY);
+  const vbLLx = croundNarrow32(job.margin.x);
+  const vbLLy = croundNarrow32(job.margin.y);
+  const vbURx = croundNarrow32(job.margin.x + pageX);
+  const vbURy = croundNarrow32(job.margin.y + pageY);
   job.write('     viewBox="' + String(vbLLx) + ".00 " + String(vbLLy) + ".00 " + String(vbURx) + ".00 " + String(vbURy) + '.00"\n');
   job.write('     xmlns="http://www.w3.org/2000/svg"');
-  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink">\n');
+  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink"');
+  if (svgid !== void 0 && svgid.length > 0) {
+    job.write(' id="' + escapeXmlTitle(svgid) + '"');
+  }
+  job.write(">\n");
 }
 function emitGraphGroupOpen(graphId, classStr, tx, ty, job) {
   const sx = formatG(job.scale.x);
@@ -25462,12 +25551,12 @@ function resolveGraphBgcolor(bgcolorAttr) {
   const solid = grad !== null ? grad[0] : bgcolorAttr;
   return colorPaint(resolveRenderColor(solid));
 }
-function emitGraphBackground(bb, resolvedColor, job) {
+function emitGraphBackground(clip, resolvedColor, job) {
   if (resolvedColor === BGCOLOR_TRANSPARENT) return;
-  const left2 = bb.ll.x - job.pad.x;
-  const right2 = bb.ur.x + job.pad.x;
-  const top = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const top = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners = [
     [left2, bottom],
     [left2, top],
@@ -25484,11 +25573,11 @@ function emitGraphBackground(bb, resolvedColor, job) {
   });
   job.write('"/>\n');
 }
-function bgGradientPts(bb, pad) {
-  const left2 = bb.ll.x - pad.x;
-  const right2 = bb.ur.x + pad.x;
-  const bottom = bb.ll.y - pad.y;
-  const top = bb.ur.y + pad.y;
+function bgGradientPts(clip) {
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const bottom = clip.ll.y;
+  const top = clip.ur.y;
   return [
     { x: left2, y: bottom },
     { x: left2, y: top },
@@ -25496,11 +25585,11 @@ function bgGradientPts(bb, pad) {
     { x: right2, y: bottom }
   ];
 }
-function writeGradientPolygon(bb, id, job) {
-  const left2 = bb.ll.x - job.pad.x;
-  const right2 = bb.ur.x + job.pad.x;
-  const top = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+function writeGradientPolygon(clip, id, job) {
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const top = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners = [
     [left2, bottom],
     [left2, top],
@@ -25517,7 +25606,7 @@ function writeGradientPolygon(bb, id, job) {
   });
   job.write('"/>\n');
 }
-function emitGradientBackground(bb, spec, job) {
+function emitGradientBackground(clip, spec, job) {
   const obj = createObjState(0 /* RootGraph */);
   obj.id = "graph0";
   obj.fillColor = resolveRenderColor(spec.fillColor);
@@ -25532,10 +25621,10 @@ function emitGradientBackground(bb, spec, job) {
     emitRadialGradient(job, gid);
   } else {
     gid = gradientId("graph0", "l", job.linearGradId++);
-    emitLinearGradient(job, bgGradientPts(bb, job.pad), gid);
+    emitLinearGradient(job, bgGradientPts(clip), gid);
   }
   job.popObj();
-  writeGradientPolygon(bb, gid, job);
+  writeGradientPolygon(clip, gid, job);
 }
 function resolveBgGradientSpec(g, bgcolorAttr) {
   const stop = findStopColor(bgcolorAttr);
@@ -25545,17 +25634,17 @@ function resolveBgGradientSpec(g, bgcolorAttr) {
   const angle = angleStr ? parseInt(angleStr, 10) || 0 : 0;
   return { fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle, radial: flags.radial };
 }
-function emitBgcolorBackground(g, bb, bgcolorAttr, job) {
+function emitBgcolorBackground(g, clip, bgcolorAttr, job) {
   if (!bgcolorAttr || bgcolorAttr.length === 0 || bgcolorAttr === "transparent") {
-    emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+    emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
     return;
   }
   const spec = resolveBgGradientSpec(g, bgcolorAttr);
   if (spec !== null) {
-    emitGradientBackground(bb, spec, job);
+    emitGradientBackground(clip, spec, job);
     return;
   }
-  emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+  emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
 }
 function svgBeginGraph(g, job) {
   job.devscale = { x: 1, y: -1 };
@@ -25569,13 +25658,23 @@ function svgBeginGraph(g, job) {
   }
   job.write(SVG_DOCTYPE);
   job.write(SVG_GENERATOR_COMMENT);
-  emitSvgTag(job);
+  const comment = g.attrs.get("comment");
+  if (comment !== void 0 && comment.length > 0) svgComment(comment, job);
+  emitTitlePagesComment(g, job);
+  emitSvgTag(job, g.attrs.get("svgid"));
+}
+function emitTitlePagesComment(g, job) {
+  job.write("<!--");
+  if (g.name.length > 0 && g.name[0] !== "%") {
+    job.write(" Title: " + escapeXmlTitle(g.name));
+  }
+  job.write(" Pages: 1 -->\n");
 }
 function svgBeginPage(g, job) {
-  const bb = job.bb;
+  const clip = job.clip;
   const z = job.scale.x;
-  const tx = job.rotation !== 0 ? -(bb.ur.x + job.pad.x) - job.margin.x / z : job.pad.x + job.margin.x / z;
-  const ty = bb.ur.y + job.pad.y + job.margin.y / z;
+  const tx = job.rotation !== 0 ? -clip.ur.x - job.margin.x / z : -clip.ll.x + job.margin.x / z;
+  const ty = clip.ur.y + job.margin.y / z;
   emitGraphGroupOpen(
     job.idLayerPrefix() + svgGraphId(g, job),
     svgGraphClass(g),
@@ -25586,7 +25685,7 @@ function svgBeginPage(g, job) {
   emitGraphTitle(g, job);
 }
 function svgPageBackground(g, job) {
-  emitBgcolorBackground(g, job.bb, g.attrs.get("bgcolor"), job);
+  emitBgcolorBackground(g, job.clip, g.attrs.get("bgcolor"), job);
 }
 function svgEndPage(job) {
   job.write("</g>\n");
@@ -25922,7 +26021,7 @@ function svgPolyline(pts, job) {
   job.write('"/>\n');
 }
 function svgComment(text, job) {
-  job.write("<!-- " + escapeXml(text) + " -->\n");
+  job.write("<!-- " + escapeXmlTitle(text) + " -->\n");
 }
 function svgEdgePath(e, job) {
   const spl = e.info.spl;
@@ -26109,6 +26208,22 @@ function initJobViewportZoom(bb, size, pad) {
   if (drawingNeedsFit(size, szx, szy)) return Math.min(size.x / szx, size.y / szy);
   return 1;
 }
+function setupPageClip(bb, size, pad, z) {
+  const jbLL = { x: bb.ll.x - pad.x, y: bb.ll.y - pad.y };
+  const jbUR = { x: bb.ur.x + pad.x, y: bb.ur.y + pad.y };
+  const sz = { x: jbUR.x - jbLL.x, y: jbUR.y - jbLL.y };
+  if (size !== null && size.x > 1e-3 && size.y > 1e-3) {
+    if (sz.x <= 1e-3) sz.x = size.x;
+    if (sz.y <= 1e-3) sz.y = size.y;
+  }
+  const focus = { x: 0.5 * (bb.ll.x + bb.ur.x), y: 0.5 * (bb.ll.y + bb.ur.y) };
+  const pageSize = { x: z * sz.x / z, y: z * sz.y / z };
+  const ll = {
+    x: focus.x + pageSize.x * (0 - 1 / 2),
+    y: focus.y + pageSize.y * (0 - 1 / 2)
+  };
+  return { ll, ur: { x: ll.x + pageSize.x, y: ll.y + pageSize.y } };
+}
 
 // src/gvc/anchor.ts
 function attr(attrs, key) {
@@ -26620,10 +26735,22 @@ function renderClusterLabel(sg, renderer, job) {
   renderOneLabel(sg.info.label, renderer, job, false);
 }
 
-// src/gvc/device.ts
-function labelTextOf2(lp) {
-  return lp?.text ?? null;
+// src/common/edge-in-box.ts
+function overlapLabel(lp, b) {
+  const sx = lp.dimen.x / 2;
+  const sy = lp.dimen.y / 2;
+  const bb = {
+    ll: { x: lp.pos.x - sx, y: lp.pos.y - sy },
+    ur: { x: lp.pos.x + sx, y: lp.pos.y + sy }
+  };
+  return boxOverlap(b, bb);
 }
+function edgeHasDrawableContent(e, clip) {
+  const i = e.info;
+  return i.spl !== void 0 || i.label !== void 0 && i.label.set && overlapLabel(i.label, clip) || i.xlabel !== void 0 || i.head_label !== void 0 || i.tail_label !== void 0;
+}
+
+// src/gvc/emit-gates.ts
 function nodeBBox(n) {
   const { coord, lw, rw, ht } = n.info;
   return {
@@ -26638,6 +26765,26 @@ function nodeInBox(n, job) {
   };
   return boxOverlap(nodeBBox(n), clip);
 }
+function gvrenderComment(renderer, job, str) {
+  if (str === void 0 || str.length === 0) return;
+  renderer.comment?.(str, job);
+}
+function emitNodeComments(n, renderer, job) {
+  gvrenderComment(renderer, job, n.name);
+  gvrenderComment(renderer, job, nodeAttr(n, n.root, "comment"));
+}
+function emitEdgeComments(e, renderer, job) {
+  if (!edgeHasDrawableContent(e, job.bb)) return;
+  const kind = e.head.root.kind;
+  const op = kind === "directed" || kind === "strict-directed" ? "->" : "--";
+  gvrenderComment(renderer, job, e.tail.name + op + e.head.name);
+  gvrenderComment(renderer, job, e.attrs.get("comment"));
+}
+
+// src/gvc/device.ts
+function labelTextOf2(lp) {
+  return lp?.text ?? null;
+}
 function emitNodeBody(n, renderer, job) {
   setHtmlAnchorObj(svgNodeId(n, job), labelTextOf2(n.info.label), job.obj ?? void 0);
   setHtmlObjImgscale(nodeAttr(n, n.root, "imagescale"));
@@ -26653,6 +26800,7 @@ function renderNode(n, renderer, job, done) {
   if (done.has(n)) return;
   done.add(n);
   if (!nodeInBox(n, job)) return;
+  emitNodeComments(n, renderer, job);
   const nodeStyle = nodeAttr(n, n.root, "style");
   if (parseStyleFlags(nodeStyle).invis) return;
   if (!isPointNode(n) && styleHasInvisibleAlias(nodeStyle)) return;
@@ -26678,6 +26826,7 @@ function setEdgePen(e, job) {
   obj.rawStyle = styleTokens(e.attrs.get("style"));
 }
 function renderEdge(e, renderer, job) {
+  emitEdgeComments(e, renderer, job);
   const edgeStyle = e.attrs.get("style");
   if (parseStyleFlags(edgeStyle).invis || styleHasInvisibleAlias(edgeStyle)) return;
   const obj = createObjState(3 /* Edge */);
@@ -26791,7 +26940,9 @@ function render(ctx, g, format, inlineImages = false) {
   job.bb = g.info.bb;
   job.pad = parseGraphPad(g.attrs.get("pad"));
   job.margin = parseGraphMargin(g.attrs.get("margin"));
-  const z = initJobViewportZoom(job.bb, parseDrawingSize(g.attrs.get("size")), job.pad);
+  const drawingSize = parseDrawingSize(g.attrs.get("size"));
+  const z = initJobViewportZoom(job.bb, drawingSize, job.pad);
+  job.clip = setupPageClip(job.bb, drawingSize, job.pad, z);
   const drawingDpi = lateDouble(
     g.attrs.get("dpi"),
     lateDouble(g.attrs.get("resolution"), 0, 0),
@@ -31136,7 +31287,7 @@ function routeMultiRankEdgeFaithful(g, e) {
   }
   const segs = chainSegments(e);
   if (segs.length === 0 || segs[segs.length - 1].head !== e.head) return null;
-  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
+  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs) ?? "lost";
 }
 function entryRunSegments(e) {
   const segs = [e];
@@ -31208,7 +31359,10 @@ function routeBackEdge(e, _tailBox, _headBox, g) {
   if (segs.length < 2 || segs[segs.length - 1].head !== e.tail) return;
   const fwdEdge = makeFwdEdge(e);
   const fwd = routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
-  if (fwd === null) return;
+  if (fwd === null) {
+    e.info.lost = true;
+    return;
+  }
   clipAndInstall(fwdEdge, fwdEdge.head, fwd, fwd.length, buildDotSinfo());
   if (swapEndsP(e)) swapEdgeSpline(e);
 }
@@ -31360,7 +31514,7 @@ function baseSplineForGroup(g, e0) {
   const orig = resolveOrigEdge(e0);
   const fe = isBackEdgeMember(orig) ? makeFwdEdge(orig) : orig;
   const pts = routeRegularEdgeFaithful(g, fe);
-  if (pts === "lost") return null;
+  if (pts === "lost") return "lost";
   return pts ?? routeMultiRankEdgeFaithful(g, fe);
 }
 function isBackEdgeMember(e) {
@@ -31389,6 +31543,10 @@ function routeParallelEdgeGroup(g, edges, multisep) {
     return o.info.head_port?.defined || o.info.tail_port?.defined;
   }) ?? edges[0];
   const base = baseSplineForGroup(g, baseEdge);
+  if (base === "lost") {
+    for (const e of edges) resolveOrigEdge(e).info.lost = true;
+    return;
+  }
   if (base === null) return;
   if (cnt === 1) {
     installShiftedEdge(edges[0], base);
@@ -34294,6 +34452,10 @@ function routeOneEdge(e, g) {
 function routeFaithfulMultiRank(e, g) {
   const pts = routeMultiRankEdgeFaithful(g, e);
   if (pts === null) return false;
+  if (pts === "lost") {
+    e.info.lost = true;
+    return true;
+  }
   clipAndInstall(e, e.head, pts, pts.length, buildDotSinfo());
   return true;
 }
@@ -34802,24 +34964,28 @@ function addSegment(segnum, seg2, tr, qs) {
     swapSegEndpoints(s);
     isSwapped = true;
   }
-  let tfirst;
-  if (!inserted(segnum, seg2, isSwapped ? LASTPT : FIRSTPT)) {
-    tfirst = insertV0(s, seg2, tr, qs, segnum);
-  } else {
-    tfirst = locateEndpoint(s.v0, s.v1, s.root0, seg2, qs);
+  const ctx = { s, seg: seg2, tr, qs, segnum, tribot: false, isSwapped };
+  const tfirst = firstTrap(ctx);
+  const tlast = lastTrap(ctx);
+  if (threadSegment(ctx, tfirst, tlast) !== 0) return -1;
+  seg2[segnum].isInserted = true;
+  return 0;
+}
+function firstTrap(c) {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? LASTPT : FIRSTPT)) {
+    return insertV0(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
-  let tlast;
-  let tribot = false;
-  if (!inserted(segnum, seg2, isSwapped ? FIRSTPT : LASTPT)) {
-    tlast = insertV1(s, seg2, tr, qs, segnum);
-  } else {
-    tlast = locateEndpoint(s.v1, s.v0, s.root1, seg2, qs);
-    tribot = true;
+  return locateEndpoint(c.s.v0, c.s.v1, c.s.root0, c.seg, c.qs);
+}
+function lastTrap(c) {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? FIRSTPT : LASTPT)) {
+    return insertV1(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
-  threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped);
-  seg2[segnum].isInserted = true;
+  c.tribot = true;
+  return locateEndpoint(c.s.v1, c.s.v0, c.s.root1, c.seg, c.qs);
 }
-function threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped) {
+function threadSegment(c, tfirst, tlast) {
+  const { s, seg: seg2, tr, qs, segnum, tribot, isSwapped } = c;
   let tfirstr = INVALID_TRAP;
   let tlastr = INVALID_TRAP;
   let t = tfirst;
@@ -34846,17 +35012,20 @@ function threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped
     if (equalTo(tr[t].lo, tr[tlast].lo)) tlastr = tn;
     const tSav = t;
     const tnSav = tn;
+    if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+      console.error("trapezoid segment construction failed");
+      return -1;
+    }
     t = advanceT(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot);
     tr[tSav].rseg = segnum;
     tr[tnSav].lseg = segnum;
   }
   mergeTrapezoids(segnum, tfirst, tlast, S_LEFT, tr, qs);
   mergeTrapezoids(segnum, tfirstr, tlastr, S_RIGHT, tr, qs);
+  return 0;
 }
 function advanceT(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot) {
-  if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
-    return INVALID_TRAP;
-  } else if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+  if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
     handleD0Only(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot);
     return tr[t].d0;
   } else if (!isValidTrap(tr[t].d0) && isValidTrap(tr[t].d1)) {
@@ -34876,33 +35045,16 @@ function findNewRoots(segnum, seg2, tr, qs) {
 // src/ortho/trapezoid.ts
 function constructTrapezoids(nseg, seg2, permute) {
   const qs = [];
-  const tr = [];
-  tr.push({
-    lseg: 0,
-    rseg: 0,
-    hi: { x: 0, y: 0 },
-    lo: { x: 0, y: 0 },
-    u0: 0,
-    u1: 0,
-    d0: 0,
-    d1: 0,
-    sink: 0,
-    usave: 0,
-    uside: 0,
-    isValid: false
-  });
+  const tr = [sentinelTrap()];
   let segi = 0;
   const root = initQueryStructure(permute[segi++], seg2, tr, qs);
-  for (let i = 1; i <= nseg; i++) {
-    seg2[i].root0 = root;
-    seg2[i].root1 = root;
-  }
+  seedRoots(nseg, seg2, root);
   const logstar = mathLogstarN(nseg);
   for (let h = 1; h <= logstar; h++) {
     const lo = mathN(nseg, h - 1) + 1;
     const hi = mathN(nseg, h);
     for (let i = lo; i <= hi; i++) {
-      addSegment(permute[segi++], seg2, tr, qs);
+      if (addSegment(permute[segi++], seg2, tr, qs) !== 0) return [];
     }
     for (let i = 1; i <= nseg; i++) {
       findNewRoots(i, seg2, tr, qs);
@@ -34910,10 +35062,32 @@ function constructTrapezoids(nseg, seg2, permute) {
   }
   const remaining = mathN(nseg, logstar) + 1;
   for (let i = remaining; i <= nseg; i++) {
-    addSegment(permute[segi++], seg2, tr, qs);
+    if (addSegment(permute[segi++], seg2, tr, qs) !== 0) return [];
   }
   return tr;
 }
+function sentinelTrap() {
+  return {
+    lseg: 0,
+    rseg: 0,
+    hi: { x: 0, y: 0 },
+    lo: { x: 0, y: 0 },
+    u0: 0,
+    u1: 0,
+    d0: 0,
+    d1: 0,
+    sink: 0,
+    usave: 0,
+    uside: 0,
+    isValid: false
+  };
+}
+function seedRoots(nseg, seg2, root) {
+  for (let i = 1; i <= nseg; i++) {
+    seg2[i].root0 = root;
+    seg2[i].root1 = root;
+  }
+}
 function initQueryStructure(segnum, seg2, tr, qs) {
   const s = seg2[segnum];
   const i1 = newQNode(qs);
@@ -35217,10 +35391,18 @@ function partition(cells, bb) {
   const hSeg = h.genSegments(cells, bb, false);
   const hPerm = h.generateRandomOrdering(nsegs);
   const hTr = constructTrapezoids(nsegs, hSeg, hPerm);
+  if (hTr.length === 0) {
+    console.error("horizontal trapezoid construction failed");
+    return null;
+  }
   const hDecomp = h.monotonateTrapezoids(hTr, hSeg, false);
   const vSeg = h.genSegments(cells, bb, true);
   const vPerm = h.generateRandomOrdering(nsegs);
   const vTr = constructTrapezoids(nsegs, vSeg, vPerm);
+  if (vTr.length === 0) {
+    console.error("vertical trapezoid construction failed");
+    return null;
+  }
   const vDecomp = h.monotonateTrapezoids(vTr, vSeg, true);
   const result = [];
   for (const v of vDecomp) {
@@ -35229,7 +35411,7 @@ function partition(cells, bb) {
       if (isect) result.push(isect);
     }
   }
-  return result;
+  return result.length === 0 ? null : result;
 }
 
 // src/ortho/rawgraph.ts
@@ -36077,6 +36259,7 @@ function mkMaze(g) {
     UR: { x: BB.UR.x + MARGIN, y: BB.UR.y + MARGIN }
   };
   const rects = partition(gcells, BB);
+  if (rects === null) return null;
   const cells = rects.map((bb) => ({
     flags: 0,
     nedges: 0,
@@ -36558,6 +36741,24 @@ function buildSpline(e, rte, mp) {
   pts.push({ ...p });
   return pts;
 }
+function ensureDummyNodes(sg, gstart) {
+  while (sg.nodes.length < gstart + 2) {
+    sg.nodes.push({
+      nVal: 0,
+      nIdx: 0,
+      nDad: null,
+      nEdge: null,
+      nAdj: 0,
+      saveNAdj: 0,
+      cells: [null, null],
+      adjEdgeList: [],
+      index: sg.nodes.length,
+      isVert: false,
+      x: 0,
+      y: 0
+    });
+  }
+}
 function orthoEdges(g, useLbls, clipAndInstall2) {
   if (useLbls) {
     console.warn(
@@ -36567,6 +36768,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   }
   void useLbls;
   const mp = mkMaze(g);
+  if (mp === null) return -1;
   const sg = mp.sg;
   const es = g.edges.map((e) => ({ e, d: edgeLen(e) }));
   gvQsort(es, edgeCmp);
@@ -36576,22 +36778,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   const pq = pqGenForGraph(sg);
   const sn = sg.nodes[gstart];
   const dn = sg.nodes[gstart + 1];
-  while (sg.nodes.length < gstart + 2) {
-    sg.nodes.push({
-      nVal: 0,
-      nIdx: 0,
-      nDad: null,
-      nEdge: null,
-      nAdj: 0,
-      saveNAdj: 0,
-      cells: [null, null],
-      adjEdgeList: [],
-      index: sg.nodes.length,
-      isVert: false,
-      x: 0,
-      y: 0
-    });
-  }
+  ensureDummyNodes(sg, gstart);
   for (let i = 0; i < nEdges; i++) {
     const e = es[i].e;
     const start = mp.gcells[g.nodes.indexOf(e.tail)];
@@ -36605,7 +36792,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
     if (shortPath(pq, sg, dn, sn) !== 0) {
       pqFree(pq);
       freeMaze(mp);
-      return;
+      return 0;
     }
     routeList[i] = convertSPtoRoute(sg, sn, dn);
     reset(sg);
@@ -36616,7 +36803,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   assignSegs(routeList, mp);
   if (assignTracks(mp) !== 0) {
     freeMaze(mp);
-    return;
+    return 0;
   }
   if (clipAndInstall2) {
     for (let i = 0; i < nEdges; i++) {
@@ -36627,6 +36814,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
     }
   }
   freeMaze(mp);
+  return 0;
 }
 
 // src/layout/dot/ortho-adapter.ts
@@ -36697,7 +36885,7 @@ function installOrthoResult(oe, pts) {
   clipAndInstall(origEdge, origEdge.head, pts, pts.length, ORTHO_SINFO);
 }
 function dispatchOrthoEdges(g, useLbls) {
-  orthoEdges(
+  return orthoEdges(
     buildOrthoGraph(g),
     useLbls,
     (_og, oe, pts) => installOrthoResult(oe, pts)
@@ -37234,12 +37422,12 @@ function resetRW(g) {
 }
 function orthoDispatch(g) {
   resetRW(g);
+  let rc;
   if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
     setEdgeLabelPos(g);
-    dispatchOrthoEdges(g, true);
-  } else {
-    dispatchOrthoEdges(g, false);
-  }
+    rc = dispatchOrthoEdges(g, true);
+  } else rc = dispatchOrthoEdges(g, false);
+  if (rc !== 0) return rc;
   placePortLabels(g);
   g.info.edgeLabelsDone = true;
   return 0;
@@ -37765,12 +37953,14 @@ function computeStep(ng, bbs, margin) {
     c -= W * H;
   }
   const d = b * b - 4 * a * c;
-  if (d < 0) return 1;
-  const root = Math.floor((-b + Math.sqrt(d)) / (2 * a));
-  return root <= 0 ? 1 : root;
+  const r = Math.sqrt(d);
+  const l1 = (-b + r) / (2 * a);
+  let root = Number.isNaN(l1) ? 0 : d2i(l1);
+  if (root === 0) root = 1;
+  return root;
 }
 function gridCells(x, s) {
-  return Math.ceil(x / s);
+  return d2i(Math.ceil(x / s));
 }
 function cval(v, s) {
   return v >= 0 ? v / s : (v + 1) / s - 1;
@@ -37811,8 +38001,8 @@ function fits(x, y, info, ctx) {
   const bb = ctx.bbs[info.index];
   if (bb === void 0) return null;
   const place = {
-    x: ctx.step * x - cround(bb.ll.x),
-    y: ctx.step * y - cround(bb.ll.y)
+    x: Math.imul(ctx.step, x) - cround(bb.ll.x),
+    y: Math.imul(ctx.step, y) - cround(bb.ll.y)
   };
   markCells(info.cells, x, y, ctx.ps);
   return place;
@@ -37895,7 +38085,7 @@ function computeStep2(bbs, margin) {
     c -= W * H;
   }
   const r = Math.sqrt(b * b - 4 * a * c);
-  const root = Math.trunc((-b + r) / (2 * a));
+  const root = d2i((-b + r) / (2 * a));
   return root === 0 ? 1 : root;
 }
 function lineXDominant(st, ps) {
@@ -38041,7 +38231,7 @@ function fits2(x, y, info, ctx) {
   }
   const bb = ctx.bbs[info.index];
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
-  ctx.places[info.index] = { x: ctx.step * x - LL.x, y: ctx.step * y - LL.y };
+  ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
   for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
   return true;
 }
@@ -38527,7 +38717,7 @@ function dotLayoutComponent(sg, root) {
   dotRank(sg);
   dotMincross(sg);
   dotPosition(sg);
-  dotPhasePostNoFinish(sg);
+  return dotPhasePostNoFinish(sg);
 }
 function mapClust(clone, origOf) {
   const orig = origOf.get(clone);
@@ -38613,7 +38803,9 @@ function packComponentsClusterAware(root, comps, pinfo) {
 }
 function layoutAndPack(root, comps, pinfo, origOf) {
   dotGraphInit(root);
-  for (const sg of comps) dotLayoutComponent(sg, root);
+  for (const sg of comps) {
+    if (dotLayoutComponent(sg, root) !== 0) return;
+  }
   packComponentsClusterAware(root, comps, pinfo);
   copyClusterInfo(comps, root, origOf);
   expandRootBbForClusters(root);
@@ -38645,11 +38837,13 @@ function dotPhaseInit(g) {
 function dotPhasePostNoFinish(g) {
   removeFill(g);
   dotSameports(g);
-  dotSplines(g);
+  const r = dotSplines(g);
+  if (r !== 0) return r;
   if (mapbool2(g.attrs.get("compound") ?? g.root.attrs.get("compound"))) dotCompoundEdges(g);
+  return 0;
 }
 function dotPhasePost(g) {
-  dotPhasePostNoFinish(g);
+  if (dotPhasePostNoFinish(g) !== 0) return;
   gvPostprocess(g);
 }
 function graphPhase(g) {
@@ -41535,10 +41729,10 @@ function raySegIntersect(v, w, a, b) {
   const mv = { x: w.x - v.x, y: w.y - v.y };
   const lv = { x: b.x - a.x, y: b.y - a.y };
   const ln = { x: -lv.y, y: lv.x };
-  const lc = -(ln.x * a.x + ln.y * a.y);
-  const dt = ln.x * mv.x + ln.y * mv.y;
+  const lc = -fma(ln.x, a.x, ln.y * a.y);
+  const dt = fma(ln.x, mv.x, ln.y * mv.y);
   if (Math.abs(dt) < SMALL3) return null;
-  const s = (ln.x * v.x + ln.y * v.y + lc) / dt;
+  const s = (fma(ln.x, v.x, ln.y * v.y) + lc) / dt;
   return { x: v.x - s * mv.x, y: v.y - s * mv.y };
 }
 function triPoint(trip, vx, v, w) {
@@ -41556,36 +41750,44 @@ function ctrlPtIdx(v, ps) {
   return -1;
 }
 var SEP = 15;
+function bisectorTarget(v, cosTheta, sinTheta) {
+  return { x: fma(cosTheta, 100, v.x), y: fma(sinTheta, 100, v.y) };
+}
+function distFused(p, q) {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return Math.sqrt(fma(dx, dx, dy * dy));
+}
 function mkCtrlPts(s, mult, prev, v, nxt, trip) {
   const idx = ctrlPtIdx(v, trip.ps);
   if (idx < 0) return null;
   const theta = bisect(prev, v, nxt);
   let sinTheta = Math.sin(theta);
   let cosTheta = Math.cos(theta);
-  let w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+  let w = bisectorTarget(v, cosTheta, sinTheta);
   if (idx > s) {
     if (wind(prev, v, w) !== 1) {
       sinTheta *= -1;
       cosTheta *= -1;
-      w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+      w = bisectorTarget(v, cosTheta, sinTheta);
     }
   } else if (wind(prev, v, w) !== -1) {
     sinTheta *= -1;
     cosTheta *= -1;
-    w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+    w = bisectorTarget(v, cosTheta, sinTheta);
   }
   const q = triPoint(trip, idx, v, w);
   if (q === null) return null;
-  const d = Math.hypot(q.x - v.x, q.y - v.y);
+  const d = distFused(q, v);
   const sep = d >= mult * SEP ? SEP : d / mult;
   const ps = new Array(mult);
   if (idx < s) {
     for (let i = 0; i < mult; i++) {
-      ps[i] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[i] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   } else {
     for (let i = 0; i < mult; i++) {
-      ps[mult - i - 1] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[mult - i - 1] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   }
   return ps;
@@ -42019,7 +42221,7 @@ var ObstacleHelper = class {
 };
 function ellipseTangentSlope(a, b, p) {
   const signY = p.y >= 0 ? 1 : -1;
-  return -signY * (b * p.x) / (a * Math.sqrt(a * a - p.x * p.x));
+  return -signY * (b * p.x) / (a * Math.sqrt(fma(a, a, -(p.x * p.x))));
 }
 function circumscribedCorner(a, b, i, nsides) {
   const angle0 = 2 * Math.PI * (i - 0.5) / nsides;
@@ -42028,8 +42230,8 @@ function circumscribedCorner(a, b, i, nsides) {
   const p1 = { x: a * Math.cos(angle1), y: b * Math.sin(angle1) };
   const m0 = ellipseTangentSlope(a, b, p0);
   const m1 = ellipseTangentSlope(a, b, p1);
-  const x = (m0 * p0.x - p0.y - m1 * p1.x + p1.y) / (m0 - m1);
-  const y = p0.y + m0 * (x - p0.x);
+  const x = (fms(p1.x, m1, fma(m0, p0.x, -p0.y)) + p1.y) / (m0 - m1);
+  const y = fma(m0, x - p0.x, p0.y);
   return { x, y };
 }
 function boxCornerMargin(j, m) {
@@ -46106,8 +46308,8 @@ function initItem(n, margin) {
   let w2;
   let h2;
   if (margin.doAdd) {
-    w2 = Math.trunc(SCALE * (cround(width / 2 * POINTS_PER_INCH6) + margin.x));
-    h2 = Math.trunc(SCALE * (cround(height / 2 * POINTS_PER_INCH6) + margin.y));
+    w2 = d2i(SCALE * (cround(width / 2 * POINTS_PER_INCH6) + margin.x));
+    h2 = d2i(SCALE * (cround(height / 2 * POINTS_PER_INCH6) + margin.y));
   } else {
     w2 = cround(margin.x * SCALE2 * width * POINTS_PER_INCH6);
     h2 = cround(margin.y * SCALE2 * height * POINTS_PER_INCH6);
@@ -50115,6 +50317,20 @@ function powerLawGraph(A3) {
   }
   return mask[1] > 0.8 * max && mask[1] > 0.3 * m;
 }
+var PCP_COVARIANCE_LANES = 4;
+function pcpCovariance(n, dim, x, y) {
+  const nUnfused = n - n % PCP_COVARIANCE_LANES;
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < dim; k++) {
+      for (let l = 0; l < dim; l++) {
+        const a = x[i * dim + k];
+        const b = x[i * dim + l];
+        const acc = y[dim * k + l];
+        y[dim * k + l] = i < nUnfused ? acc + a * b : fma(a, b, acc);
+      }
+    }
+  }
+}
 function pcpRotate(n, dim, x) {
   const y = [0, 0, 0, 0];
   const center = [0, 0];
@@ -50125,24 +50341,23 @@ function pcpRotate(n, dim, x) {
   for (let i = 0; i < n; i++) {
     for (let k = 0; k < dim; k++) x[dim * i + k] -= center[k];
   }
-  for (let i = 0; i < n; i++) {
-    for (let k = 0; k < dim; k++) {
-      for (let l = 0; l < dim; l++) {
-        y[dim * k + l] = fma(x[i * dim + k], x[i * dim + l], y[dim * k + l]);
-      }
-    }
-  }
+  pcpCovariance(n, dim, x, y);
   const axis = [0, 1];
   if (y[1] !== 0) {
-    axis[0] = -(-y[0] + y[3] - Math.sqrt(y[0] * y[0] + 4 * y[1] * y[1] - 2 * y[0] * y[3] + y[3] * y[3])) / (2 * y[1]);
+    const radicand = fma(
+      y[3],
+      y[3],
+      fma(-2 * y[0], y[3], fma(y[0], y[0], 4 * y[1] * y[1]))
+    );
+    axis[0] = -(-y[0] + y[3] - Math.sqrt(radicand)) / (2 * y[1]);
     axis[1] = 1;
   }
-  const dist4 = Math.sqrt(1 + axis[0] * axis[0]);
+  const dist4 = Math.sqrt(fma(axis[0], axis[0], 1));
   axis[0] = axis[0] / dist4;
   axis[1] = axis[1] / dist4;
   for (let i = 0; i < n; i++) {
-    const x0 = x[dim * i] * axis[0] + x[dim * i + 1] * axis[1];
-    const x1 = -x[dim * i] * axis[1] + x[dim * i + 1] * axis[0];
+    const x0 = fma(x[dim * i], axis[0], x[dim * i + 1] * axis[1]);
+    const x1 = fma(-x[dim * i], axis[1], x[dim * i + 1] * axis[0]);
     x[dim * i] = x0;
     x[dim * i + 1] = x1;
   }
@@ -50405,16 +50620,7 @@ function makeCData(dn) {
   };
 }
 
-// src/layout/circo/blockpath.ts
-function blockGraph(allEdges3, sn) {
-  const ns = new Set(sn.subGraph.nodes);
-  for (const n of sn.subGraph.nodes) {
-    for (const e of allEdges3) {
-      if (e.tail === n && ns.has(e.head) && !sn.subGraph.edges.includes(e))
-        sn.subGraph.edges.push(e);
-    }
-  }
-}
+// src/layout/circo/crossings.ts
 function derivedOf(n) {
   return n.info.alg?.derivedNode ?? null;
 }
@@ -50425,27 +50631,51 @@ function closeOpenEdge(e, d, opened) {
   }
   return cross2;
 }
-function openEdgesAt(d, edges, opened, order) {
+function agfstedgeLists(edges) {
+  const seq2 = /* @__PURE__ */ new Map();
+  edges.forEach((e, i) => seq2.set(e, i));
+  const by = (end) => (a, b) => end(a).orig.id - end(b).orig.id || seq2.get(a) - seq2.get(b);
+  const out = /* @__PURE__ */ new Map();
+  const inn = /* @__PURE__ */ new Map();
   for (const e of edges) {
-    if (e.order === 0 && (e.tail === d || e.head === d)) {
-      e.order = order;
-      opened.push(e);
-    }
+    out.set(e.tail, [...out.get(e.tail) ?? [], e]);
+    inn.set(e.head, [...inn.get(e.head) ?? [], e]);
   }
+  const lists = /* @__PURE__ */ new Map();
+  for (const d of /* @__PURE__ */ new Set([...out.keys(), ...inn.keys()])) {
+    const o = (out.get(d) ?? []).sort(by((e) => e.head));
+    const i = (inn.get(d) ?? []).sort(by((e) => e.tail));
+    lists.set(d, [...o, ...i]);
+  }
+  return lists;
 }
 function countCrossings(list, edges) {
   for (const e of edges) e.order = 0;
-  const opened = [];
+  const incident = agfstedgeLists(edges);
+  const opened = /* @__PURE__ */ new Map();
   let crossings = 0;
   let order = 1;
   for (const n of list) {
     const d = derivedOf(n);
     if (!d) continue;
-    for (const e of edges) {
-      if (e.order > 0 && (e.tail === d || e.head === d))
-        crossings += closeOpenEdge(e, d, opened);
+    const es = incident.get(d) ?? [];
+    crossings += closeEdgesAt(d, es, opened);
+    for (const e of es) {
+      if (e.order === 0) {
+        e.order = order;
+        opened.set(e, d);
+      }
     }
-    openEdgesAt(d, edges, opened, order++);
+    order++;
+  }
+  return crossings;
+}
+function closeEdgesAt(d, es, opened) {
+  let crossings = 0;
+  for (const e of es) {
+    if (e.order === 0) continue;
+    crossings += closeOpenEdge(e, d, opened.keys());
+    if (opened.get(e) === d) opened.delete(e);
   }
   return crossings;
 }
@@ -50498,6 +50728,17 @@ function spanIncident(dn, edges, ord, seq2) {
   const inn = edges.filter((e) => e.head === dn).sort((a, b) => (ord.get(a.tail) ?? 0) - (ord.get(b.tail) ?? 0) || (seq2.get(a) ?? 0) - (seq2.get(b) ?? 0));
   return [...out, ...inn];
 }
+
+// src/layout/circo/blockpath.ts
+function blockGraph(allEdges3, sn) {
+  const ns = new Set(sn.subGraph.nodes);
+  for (const n of sn.subGraph.nodes) {
+    for (const e of allEdges3) {
+      if (e.tail === n && ns.has(e.head) && !sn.subGraph.edges.includes(e))
+        sn.subGraph.edges.push(e);
+    }
+  }
+}
 function dfsSpan(sn, map, edges, ord, seq2) {
   sn.visited = true;
   for (const e of spanIncident(sn.dn, edges, ord, seq2)) {
@@ -51976,17 +52217,30 @@ function renderEdgeLabels(e, renderer, job) {
 }
 function emitEdgeLabel(lp, id, hs, renderer, job, spl, emitState) {
   if (!lp?.set) return;
-  const open = hs.url !== null || hs.explicit;
-  if (open) openAnchorWith(renderer, job, hs.url, hs.tooltip, hs.target, id);
-  const savedOverride = job.labelEmitOverride;
-  if (emitState !== void 0) job.labelEmitOverride = emitState;
-  try {
-    renderOneLabel(lp, renderer, job);
-  } finally {
-    job.labelEmitOverride = savedOverride;
+  withObjEmitState(job, emitState ?? 11 /* ELabel */, () => {
+    const open = hs.url !== null || hs.explicit;
+    if (open) openAnchorWith(renderer, job, hs.url, hs.tooltip, hs.target, id);
+    const savedOverride = job.labelEmitOverride;
+    if (emitState !== void 0) job.labelEmitOverride = emitState;
+    try {
+      renderOneLabel(lp, renderer, job);
+    } finally {
+      job.labelEmitOverride = savedOverride;
+    }
+    if (spl) emitAttachment(lp, spl, renderer, job);
+    if (open) renderer.endAnchor?.(job);
+  });
+}
+function withObjEmitState(job, lkind, fn) {
+  const obj = job.obj;
+  if (obj === null) {
+    fn();
+    return;
   }
-  if (spl) emitAttachment(lp, spl, renderer, job);
-  if (open) renderer.endAnchor?.(job);
+  const oldEmitState = obj.emitState;
+  obj.emitState = lkind;
+  fn();
+  obj.emitState = oldEmitState;
 }
 function emitAttachment(lp, spl, renderer, job) {
   if (!lp?.set) return;
@@ -53572,6 +53826,7 @@ var DotWriterBase = class {
 
 // src/render/dot/edge-draw.ts
 var DEFAULT_COLOR5 = "black";
+var DEFAULT_LINE_STYLE = ["solid", "setlinewidth(1)"];
 function emitArrowOp(buf, op, pen) {
   switch (op.kind) {
     case "polygon":
@@ -53595,6 +53850,25 @@ function emitArrowOp(buf, op, pen) {
 var EdgeDrawBase = class extends DotWriterBase {
   /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
   penwidth = new Array(12).fill(1);
+  /**
+   * emit_attachment's draw calls (decorate=true): gvrender_set_style with the
+   * default line style sets the obj's rawstyle/pen/penwidth (setlinewidth 1),
+   * gvrender_set_pencolor sets the pen to the label fontcolor (first entry of
+   * a color list), then gvrender_polyline → xdot_polyline emits the style ops
+   * (`S 5 -solid`; setlinewidth is filtered), the pen color and `L 3`.
+   * @see lib/common/emit.c:emit_attachment (1886-1893)
+   * @see lib/gvc/gvrender.c:gvrender_set_style / gvrender_set_pencolor
+   */
+  attachmentPolyline(pts, pencolor, job) {
+    const obj = job.obj;
+    if (obj !== null) {
+      obj.rawStyle = [...DEFAULT_LINE_STYLE];
+      obj.pen = 3 /* Solid */;
+      obj.penWidth = 1;
+      obj.penColor = resolveRenderColor(pencolor.split(":")[0]);
+    }
+    this.polyline(pts, job);
+  }
   /**
    * The plain single-colour spline branch of beginEdge — lifted verbatim so the
    * four-way spline-kind chain above stays readable; no branch was reordered or
@@ -54134,19 +54408,6 @@ function emitMulticolorArrows(e, job, headColor, tailColor) {
     emitArrowOps(headOps, headColor, job, pw, colorOpacity(resolveRenderColor(headColor)));
   }
 }
-function overlapLabel(lp, b) {
-  const sx = lp.dimen.x / 2;
-  const sy = lp.dimen.y / 2;
-  const bb = {
-    ll: { x: lp.pos.x - sx, y: lp.pos.y - sy },
-    ur: { x: lp.pos.x + sx, y: lp.pos.y + sy }
-  };
-  return boxOverlap(b, bb);
-}
-function edgeHasDrawableContent(e, clip) {
-  const i = e.info;
-  return i.spl !== void 0 || i.label !== void 0 && i.label.set && overlapLabel(i.label, clip) || i.xlabel !== void 0 || i.head_label !== void 0 || i.tail_label !== void 0;
-}
 var SvgRenderer = class {
   type = "svg";
   /** @see plugin/core/gvplugin_core.c registration table */
@@ -54303,6 +54564,7 @@ function createSvgRenderer() {
 var XDOT_PARSE_ERROR = 1;
 
 // src/xdot/parse.ts
+var ULONG_MAX = 0xffffffffffffffffn;
 var XdotParser = class _XdotParser {
   static isWs(c) {
     return c === " " || c === "	" || c === "\n" || c === "\r";
@@ -54346,12 +54608,23 @@ var XdotParser = class _XdotParser {
     if (i === digStart) return null;
     return { val: parseInt(s.slice(start, i), 10), pos: i };
   }
+  /**
+   * strtoul(s, &endp, 10) cast to unsigned int: optional sign, a leading "-"
+   * negates modulo 2^64, magnitude overflow saturates to ULONG_MAX, and the
+   * result keeps the low 32 bits.
+   * @see lib/xdot/xdot.c:parseUInt
+   */
   static parseUInt_(s, pos) {
     const i = _XdotParser.skipWs(s, pos);
-    const start = i;
-    const end = _XdotParser.consumeDigits(s, i);
+    let start = i;
+    const negative = i < s.length && s[i] === "-";
+    if (i < s.length && (s[i] === "-" || s[i] === "+")) start++;
+    const end = _XdotParser.consumeDigits(s, start);
     if (end === start) return null;
-    return { val: parseInt(s.slice(start, end), 10), pos: end };
+    const mag = BigInt(s.slice(start, end));
+    const clamped = mag > ULONG_MAX ? ULONG_MAX : mag;
+    const wrapped = negative && mag <= ULONG_MAX ? BigInt.asUintN(64, -clamped) : clamped;
+    return { val: Number(BigInt.asUintN(32, wrapped)), pos: end };
   }
   static parseRect(s, pos) {
     const rx = _XdotParser.parseReal(s, pos);
@@ -54448,7 +54721,7 @@ var XdotParser = class _XdotParser {
     if (!rx1) return null;
     const ry1 = _XdotParser.parseReal(s, rx1.pos);
     if (!ry1) return null;
-    const rn = _XdotParser.parseInt_(s, ry1.pos);
+    const rn = _XdotParser.parseUInt_(s, ry1.pos);
     if (!rn) return null;
     const rs = _XdotParser.parseStops(s, rn.pos, rn.val);
     if (!rs) return null;
@@ -54467,7 +54740,7 @@ var XdotParser = class _XdotParser {
     if (!ry1) return null;
     const rr1 = _XdotParser.parseReal(s, ry1.pos);
     if (!rr1) return null;
-    const rn = _XdotParser.parseInt_(s, rr1.pos);
+    const rn = _XdotParser.parseUInt_(s, rr1.pos);
     if (!rn) return null;
     const rs = _XdotParser.parseStops(s, rn.pos, rn.val);
     if (!rs) return null;