links-notation 0.22.0 → 0.24.0

package/dist/index.js

@@ -1,3 +1,49 @@
+// src/ReferenceLiteral.js
+function hasReferenceLiteralPrefix(text, start = 0) {
+  return /^~[0-9]+\{/.test(text.slice(start));
+}
+function encodeReferenceLiteral(text) {
+  if (typeof text !== "string" || !text.isWellFormed()) {
+    throw new TypeError("Reference must be well-formed Unicode text");
+  }
+  const hex = Array.from(new TextEncoder().encode(text), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `~1{${hex}}`;
+}
+function decodeReferenceLiteral(literal) {
+  const match = /^~([0-9]+)\{([0-9a-fA-F]*)\}$/.exec(literal);
+  if (!match || match[0] !== literal || match[1] !== "1" || match[2].length % 2 !== 0) {
+    throw new TypeError("Invalid or unsupported reference literal (expected ~1{UTF-8 hex})");
+  }
+  return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(match[2].match(/../g) ?? [], (hex) => parseInt(hex, 16)));
+}
+function formatReference(text) {
+  if (typeof text !== "string" || !text.isWellFormed()) {
+    throw new TypeError("Reference must be well-formed Unicode text");
+  }
+  if (!text || /[\u0000-\u001f\u007f]/u.test(text)) {
+    return encodeReferenceLiteral(text);
+  }
+  if (!text.startsWith("#") && !/^~[0-9]+\{/.test(text) && !/[\p{White_Space}\ufeff():"'`]/u.test(text)) {
+    return text;
+  }
+  let choice = null;
+  for (const quote of ["'", '"', "`"]) {
+    if (text.startsWith(quote))
+      continue;
+    let longest = 0;
+    let run = 0;
+    for (const character of text) {
+      run = character === quote ? run + 1 : 0;
+      longest = Math.max(longest, run);
+    }
+    const count = longest + 1 | 1;
+    if (choice === null || count < choice.count)
+      choice = { quote, count };
+  }
+  const delimiter = choice.quote.repeat(choice.count);
+  return delimiter + text + delimiter;
+}
+
 // src/Link.js
 class Link {
   constructor(id = null, values = null) {
@@ -39,26 +85,7 @@ class Link {
     if (reference === null || reference === undefined) {
       return "";
     }
-    if (reference === "") {
-      return '""';
-    }
-    const hasSingleQuote = reference.includes("'");
-    const hasDoubleQuote = reference.includes('"');
-    const needsQuoting = reference.startsWith("#") || reference.includes(":") || reference.includes("(") || reference.includes(")") || reference.includes(" ") || reference.includes("\t") || reference.includes(`
-`) || reference.includes("\r") || hasDoubleQuote || hasSingleQuote;
-    if (hasSingleQuote && hasDoubleQuote) {
-      return `'${reference.replace(/'/g, "\\'")}'`;
-    }
-    if (hasDoubleQuote) {
-      return `'${reference}'`;
-    }
-    if (hasSingleQuote) {
-      return `"${reference}"`;
-    }
-    if (needsQuoting) {
-      return `'${reference}'`;
-    }
-    return reference;
+    return formatReference(reference);
   }
   toLinkOrIdString() {
     if (!this.values || this.values.length === 0) {
@@ -631,14 +658,19 @@ 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$c6 = " ";
+  const peg$c3 = "~";
+  const peg$c4 = "{";
+  const peg$c5 = "}";
+  const peg$c6 = '"';
+  const peg$c7 = "'";
+  const peg$c8 = "`";
+  const peg$c9 = " ";
   const peg$r0 = /^[ \t]/;
   const peg$r1 = /^[\r\n]/;
-  const peg$r2 = /^[ \t\n\r]/;
-  const peg$r3 = /^[^ \t\n\r(:)]/;
+  const peg$r2 = /^[0-9]/;
+  const peg$r3 = /^[^} \t\r\n()]/;
+  const peg$r4 = /^[ \t\n\r]/;
+  const peg$r5 = /^[^ \t\n\r(:)]/;
   const peg$e0 = peg$classExpectation([" ", "\t"], false, false, false);
   const peg$e1 = peg$classExpectation(["\r", `
 `], false, false, false);
@@ -646,13 +678,19 @@ function peg$parse(input, options) {
   const peg$e3 = peg$literalExpectation("(", false);
   const peg$e4 = peg$literalExpectation(")", false);
   const peg$e5 = peg$literalExpectation(":", false);
-  const peg$e6 = peg$literalExpectation('"', false);
-  const peg$e7 = peg$literalExpectation("'", false);
-  const peg$e8 = peg$literalExpectation("`", false);
-  const peg$e9 = peg$literalExpectation(" ", false);
-  const peg$e10 = peg$classExpectation([" ", "\t", `
+  const peg$e6 = peg$literalExpectation("~", false);
+  const peg$e7 = peg$classExpectation([["0", "9"]], false, false, false);
+  const peg$e8 = peg$literalExpectation("{", false);
+  const peg$e9 = peg$classExpectation(["}", " ", "\t", "\r", `
+`, "(", ")"], true, false, false);
+  const peg$e10 = peg$literalExpectation("}", false);
+  const peg$e11 = peg$literalExpectation('"', false);
+  const peg$e12 = peg$literalExpectation("'", false);
+  const peg$e13 = peg$literalExpectation("`", false);
+  const peg$e14 = peg$literalExpectation(" ", false);
+  const peg$e15 = peg$classExpectation([" ", "\t", `
 `, "\r"], false, false, false);
-  const peg$e11 = peg$classExpectation([" ", "\t", `
+  const peg$e16 = peg$classExpectation([" ", "\t", `
 `, "\r", "(", ":", ")"], true, false, false);
   function peg$f0() {
     return resetState();
@@ -749,10 +787,19 @@ function peg$parse(input, options) {
   function peg$f28(id) {
     return { id, values: [] };
   }
-  function peg$f29(chars) {
+  function peg$f29() {
+    return hasReferenceLiteralPrefix(input, offset());
+  }
+  function peg$f30(literal) {
+    return decodeReferenceLiteral(literal);
+  }
+  function peg$f31() {
+    return !hasReferenceLiteralPrefix(input, offset());
+  }
+  function peg$f32(chars) {
     return chars.join("");
   }
-  function peg$f30() {
+  function peg$f33() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, '"');
     if (result) {
@@ -762,19 +809,19 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f31(chars) {
+  function peg$f34(chars) {
     return parsedValue;
   }
-  function peg$f32(c, cs) {
+  function peg$f35(c, cs) {
     return [c].concat(cs).join("");
   }
-  function peg$f33() {
+  function peg$f36() {
     return parsedLength > 1 && (parsedLength--, true);
   }
-  function peg$f34(c) {
+  function peg$f37(c) {
     return c;
   }
-  function peg$f35() {
+  function peg$f38() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, "'");
     if (result) {
@@ -784,19 +831,19 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f36(chars) {
+  function peg$f39(chars) {
     return parsedValue;
   }
-  function peg$f37(c, cs) {
+  function peg$f40(c, cs) {
     return [c].concat(cs).join("");
   }
-  function peg$f38() {
+  function peg$f41() {
     return parsedLength > 1 && (parsedLength--, true);
   }
-  function peg$f39(c) {
+  function peg$f42(c) {
     return c;
   }
-  function peg$f40() {
+  function peg$f43() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, "`");
     if (result) {
@@ -806,34 +853,34 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f41(chars) {
+  function peg$f44(chars) {
     return parsedValue;
   }
-  function peg$f42(c, cs) {
+  function peg$f45(c, cs) {
     return [c].concat(cs).join("");
   }
-  function peg$f43() {
+  function peg$f46() {
     return parsedLength > 1 && (parsedLength--, true);
   }
-  function peg$f44(c) {
+  function peg$f47(c) {
     return c;
   }
-  function peg$f45() {
+  function peg$f48() {
     return indentationStack.slice();
   }
-  function peg$f46(spaces) {
+  function peg$f49(spaces) {
     setBaseIndentation(spaces);
   }
-  function peg$f47(spaces) {
+  function peg$f50(spaces) {
     return normalizeIndentation(spaces) > getCurrentIndentation();
   }
-  function peg$f48(spaces) {
+  function peg$f51(spaces) {
     pushIndentation(spaces);
   }
-  function peg$f49(spaces) {
+  function peg$f52(spaces) {
     return checkIndentation(spaces);
   }
-  function peg$f50() {
+  function peg$f53() {
     return isInsideNestedContext();
   }
   let peg$currPos = options.peg$currPos | 0;
@@ -1680,30 +1727,198 @@ function peg$parse(input, options) {
   }
   function peg$parsereference() {
     let s0;
-    s0 = peg$parsequotedReference();
+    s0 = peg$parsereferenceLiteral();
     if (s0 === peg$FAILED) {
-      s0 = peg$parsesimpleReference();
+      s0 = peg$parsequotedReference();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsesimpleReference();
+      }
     }
     return s0;
   }
-  function peg$parsesimpleReference() {
-    let s0, s1, s2;
+  function peg$parsereferenceLiteral() {
+    let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
     s0 = peg$currPos;
-    s1 = [];
-    s2 = peg$parsereferenceSymbol();
+    s1 = peg$currPos;
+    peg$silentFails++;
+    if (input.charCodeAt(peg$currPos) === 126) {
+      s2 = peg$c3;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e6);
+      }
+    }
+    peg$silentFails--;
     if (s2 !== peg$FAILED) {
-      while (s2 !== peg$FAILED) {
-        s1.push(s2);
-        s2 = peg$parsereferenceSymbol();
+      peg$currPos = s1;
+      s1 = undefined;
+    } else {
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = peg$currPos;
+      s2 = peg$f29();
+      if (s2) {
+        s2 = undefined;
+      } else {
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$currPos;
+        s4 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 126) {
+          s5 = peg$c3;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e6);
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = [];
+          s7 = input.charAt(peg$currPos);
+          if (peg$r2.test(s7)) {
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e7);
+            }
+          }
+          if (s7 !== peg$FAILED) {
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = input.charAt(peg$currPos);
+              if (peg$r2.test(s7)) {
+                peg$currPos++;
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e7);
+                }
+              }
+            }
+          } else {
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 123) {
+              s7 = peg$c4;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e8);
+              }
+            }
+            if (s7 !== peg$FAILED) {
+              s8 = [];
+              s9 = input.charAt(peg$currPos);
+              if (peg$r3.test(s9)) {
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e9);
+                }
+              }
+              while (s9 !== peg$FAILED) {
+                s8.push(s9);
+                s9 = input.charAt(peg$currPos);
+                if (peg$r3.test(s9)) {
+                  peg$currPos++;
+                } else {
+                  s9 = peg$FAILED;
+                  if (peg$silentFails === 0) {
+                    peg$fail(peg$e9);
+                  }
+                }
+              }
+              if (input.charCodeAt(peg$currPos) === 125) {
+                s9 = peg$c5;
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e10);
+                }
+              }
+              if (s9 !== peg$FAILED) {
+                s5 = [s5, s6, s7, s8, s9];
+                s4 = s5;
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 !== peg$FAILED) {
+          s3 = input.substring(s3, peg$currPos);
+        } else {
+          s3 = s4;
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f30(s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
       }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parsesimpleReference() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    peg$savedPos = peg$currPos;
+    s1 = peg$f31();
+    if (s1) {
+      s1 = undefined;
     } else {
       s1 = peg$FAILED;
     }
     if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$f29(s1);
+      s2 = [];
+      s3 = peg$parsereferenceSymbol();
+      if (s3 !== peg$FAILED) {
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsereferenceSymbol();
+        }
+      } else {
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f32(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
     }
-    s0 = s1;
     return s0;
   }
   function peg$parsequotedReference() {
@@ -1723,12 +1938,12 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     peg$silentFails++;
     if (input.charCodeAt(peg$currPos) === 34) {
-      s2 = peg$c3;
+      s2 = peg$c6;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e6);
+        peg$fail(peg$e11);
       }
     }
     peg$silentFails--;
@@ -1740,7 +1955,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f30();
+      s2 = peg$f33();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1750,7 +1965,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeDouble();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f31(s3);
+          s0 = peg$f34(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1785,7 +2000,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeDoubleMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f32(s1, s2);
+      s0 = peg$f35(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1796,7 +2011,7 @@ function peg$parse(input, options) {
     let s0, s1, s2;
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f33();
+    s1 = peg$f36();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1814,7 +2029,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f34(s2);
+        s0 = peg$f37(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1831,12 +2046,12 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     peg$silentFails++;
     if (input.charCodeAt(peg$currPos) === 39) {
-      s2 = peg$c4;
+      s2 = peg$c7;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e7);
+        peg$fail(peg$e12);
       }
     }
     peg$silentFails--;
@@ -1848,7 +2063,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f35();
+      s2 = peg$f38();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1858,7 +2073,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeSingle();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f36(s3);
+          s0 = peg$f39(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1893,7 +2108,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeSingleMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f37(s1, s2);
+      s0 = peg$f40(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1904,7 +2119,7 @@ function peg$parse(input, options) {
     let s0, s1, s2;
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f38();
+    s1 = peg$f41();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1922,7 +2137,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f39(s2);
+        s0 = peg$f42(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1939,12 +2154,12 @@ function peg$parse(input, options) {
     s1 = peg$currPos;
     peg$silentFails++;
     if (input.charCodeAt(peg$currPos) === 96) {
-      s2 = peg$c5;
+      s2 = peg$c8;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e8);
+        peg$fail(peg$e13);
       }
     }
     peg$silentFails--;
@@ -1956,7 +2171,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f40();
+      s2 = peg$f43();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1966,7 +2181,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeBacktick();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f41(s3);
+          s0 = peg$f44(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -2001,7 +2216,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeBacktickMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f42(s1, s2);
+      s0 = peg$f45(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -2012,7 +2227,7 @@ function peg$parse(input, options) {
     let s0, s1, s2;
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f43();
+    s1 = peg$f46();
     if (s1) {
       s1 = undefined;
     } else {
@@ -2030,7 +2245,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f44(s2);
+        s0 = peg$f47(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -2046,7 +2261,7 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = "";
     peg$savedPos = s0;
-    s1 = peg$f45();
+    s1 = peg$f48();
     s0 = s1;
     return s0;
   }
@@ -2055,28 +2270,28 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = [];
     if (input.charCodeAt(peg$currPos) === 32) {
-      s2 = peg$c6;
+      s2 = peg$c9;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e9);
+        peg$fail(peg$e14);
       }
     }
     while (s2 !== peg$FAILED) {
       s1.push(s2);
       if (input.charCodeAt(peg$currPos) === 32) {
-        s2 = peg$c6;
+        s2 = peg$c9;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e9);
+          peg$fail(peg$e14);
         }
       }
     }
     peg$savedPos = s0;
-    s1 = peg$f46(s1);
+    s1 = peg$f49(s1);
     s0 = s1;
     return s0;
   }
@@ -2085,28 +2300,28 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = [];
     if (input.charCodeAt(peg$currPos) === 32) {
-      s2 = peg$c6;
+      s2 = peg$c9;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e9);
+        peg$fail(peg$e14);
       }
     }
     while (s2 !== peg$FAILED) {
       s1.push(s2);
       if (input.charCodeAt(peg$currPos) === 32) {
-        s2 = peg$c6;
+        s2 = peg$c9;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e9);
+          peg$fail(peg$e14);
         }
       }
     }
     peg$savedPos = peg$currPos;
-    s2 = peg$f47(s1);
+    s2 = peg$f50(s1);
     if (s2) {
       s2 = undefined;
     } else {
@@ -2114,7 +2329,7 @@ function peg$parse(input, options) {
     }
     if (s2 !== peg$FAILED) {
       peg$savedPos = s0;
-      s0 = peg$f48(s1);
+      s0 = peg$f51(s1);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -2126,28 +2341,28 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = [];
     if (input.charCodeAt(peg$currPos) === 32) {
-      s2 = peg$c6;
+      s2 = peg$c9;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e9);
+        peg$fail(peg$e14);
       }
     }
     while (s2 !== peg$FAILED) {
       s1.push(s2);
       if (input.charCodeAt(peg$currPos) === 32) {
-        s2 = peg$c6;
+        s2 = peg$c9;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e9);
+          peg$fail(peg$e14);
         }
       }
     }
     peg$savedPos = peg$currPos;
-    s2 = peg$f49(s1);
+    s2 = peg$f52(s1);
     if (s2) {
       s2 = undefined;
     } else {
@@ -2358,7 +2573,7 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3;
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f50();
+    s1 = peg$f53();
     if (s1) {
       s1 = undefined;
     } else {
@@ -2457,12 +2672,12 @@ function peg$parse(input, options) {
   function peg$parsewhiteSpaceSymbol() {
     let s0;
     s0 = input.charAt(peg$currPos);
-    if (peg$r2.test(s0)) {
+    if (peg$r4.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e10);
+        peg$fail(peg$e15);
       }
     }
     return s0;
@@ -2470,12 +2685,12 @@ function peg$parse(input, options) {
   function peg$parsereferenceSymbol() {
     let s0;
     s0 = input.charAt(peg$currPos);
-    if (peg$r3.test(s0)) {
+    if (peg$r5.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e11);
+        peg$fail(peg$e16);
       }
     }
     return s0;
@@ -2980,16 +3195,596 @@ class FormatOptions {
 // src/FormatConfig.js
 class FormatConfig extends FormatOptions {
 }
+// src/Binary.js
+var U64 = (1n << 64n) - 1n;
+var WIDTHS = [1, 2, 4, 8];
+function requireValue(condition, message) {
+  if (!condition)
+    throw new RangeError(message);
+}
+function uint64(value) {
+  requireValue(typeof value === "bigint" || Number.isSafeInteger(value) && value >= 0, "expected uint64");
+  const result = BigInt(value);
+  requireValue(result >= 0n && result <= U64, "uint64 overflow");
+  return result;
+}
+
+class External {
+  constructor(value) {
+    this.value = uint64(value);
+  }
+}
+
+class ArityRange {
+  constructor(min = 2, max = 2) {
+    this.min = uint64(min);
+    this.max = max === null ? null : uint64(max);
+    requireValue(this.min > 0n && this.min <= U64 >> 4n && (this.max === null || this.max >= this.min), "invalid arity");
+  }
+  contains(length) {
+    return BigInt(length) >= this.min && (this.max === null || BigInt(length) <= this.max);
+  }
+  get fixed() {
+    return this.min === this.max;
+  }
+  static parse(text) {
+    requireValue(/^[0-9]+(?:\.\.[0-9]*)?$/.test(text), "invalid arity");
+    const parts = text.split("..");
+    return new ArityRange(BigInt(parts[0]), parts.at(-1) === "" ? null : BigInt(parts.at(-1)));
+  }
+}
+
+class DecodeLimits {
+  constructor(values = {}) {
+    Object.assign(this, {
+      maxLinks: 2 ** 22,
+      maxReferences: 2 ** 24,
+      maxNodes: 2 ** 22,
+      maxStringBytes: 64 * 2 ** 20,
+      maxDepth: 64
+    }, values);
+    for (const key of Object.keys(this)) {
+      requireValue([
+        "maxLinks",
+        "maxReferences",
+        "maxNodes",
+        "maxStringBytes",
+        "maxDepth"
+      ].includes(key), "unknown limit");
+      requireValue(Number.isSafeInteger(this[key]) && this[key] >= 0, "invalid limit");
+    }
+  }
+  static unlimited() {
+    return new DecodeLimits({
+      maxLinks: Number.MAX_SAFE_INTEGER,
+      maxReferences: Number.MAX_SAFE_INTEGER,
+      maxNodes: Number.MAX_SAFE_INTEGER,
+      maxStringBytes: Number.MAX_SAFE_INTEGER,
+      maxDepth: Number.MAX_SAFE_INTEGER
+    });
+  }
+}
+
+class BinaryLinoOptions {
+  constructor(externalReferences = false, arity = new ArityRange, packedWidths = false) {
+    Object.assign(this, { externalReferences, arity, packedWidths });
+  }
+  static ofPacket(packet) {
+    let min = 2, max = 2;
+    for (const [, link] of packet.links()) {
+      min = Math.min(min, link.length);
+      max = Math.max(max, link.length);
+    }
+    return new BinaryLinoOptions(packet.externalReferences, new ArityRange(min, max), new Set(packet.sections.map((s) => s.width)).size > 1);
+  }
+}
+
+class Section {
+  constructor(gap, arity, width, links) {
+    Object.assign(this, { gap: uint64(gap), arity, width, links });
+  }
+}
+function referenceWidth(reference, external) {
+  const value = reference instanceof External ? reference.value : uint64(reference);
+  requireValue(!(reference instanceof External) || external, "external references disabled");
+  for (const width of WIDTHS)
+    if (value < 1n << BigInt(width * 8 - Number(external)))
+      return width;
+  throw new RangeError("reference exceeds capacity");
+}
+function leb(out, input) {
+  let value = uint64(input);
+  while (value >= 128n) {
+    out.push(Number(value & 127n) | 128);
+    value >>= 7n;
+  }
+  out.push(Number(value));
+}
+
+class PacketReader {
+  constructor(bytes, offset = 0) {
+    requireValue(bytes instanceof Uint8Array && Number.isSafeInteger(offset) && offset >= 0 && offset <= bytes.length, "invalid byte cursor");
+    this.bytes = bytes;
+    this.offset = offset;
+  }
+  raw(width) {
+    requireValue(width <= this.bytes.length - this.offset, "unexpected end of packet");
+    let result = 0n;
+    for (let i = 0;i < width; i++)
+      result |= BigInt(this.bytes[this.offset++]) << BigInt(i * 8);
+    return result;
+  }
+  leb() {
+    let value = 0n;
+    for (let shift = 0n;shift < 64n; shift += 7n) {
+      const byte = this.raw(1);
+      requireValue(shift !== 63n || (byte & 127n) <= 1n, "LEB128 overflow");
+      value |= (byte & 127n) << shift;
+      if (byte < 128n)
+        return value;
+    }
+    throw new RangeError("LEB128 overflow");
+  }
+  read(limits = new DecodeLimits) {
+    if (this.offset === this.bytes.length)
+      return null;
+    const header = Number(this.raw(1));
+    requireValue((header & 240) === 16, "unsupported binary version");
+    const sections = [], counts = [];
+    if (header & 2) {
+      requireValue((header & 12) === 0, "explicit header width bits set");
+      const sectionCount = this.leb();
+      requireValue(sectionCount <= BigInt(limits.maxLinks), "too many sections");
+      let address = 1n, total = 0n;
+      for (let i = 0n;i < sectionCount; i++) {
+        const shape = this.leb(), gap = shape & 4n ? this.leb() : 0n;
+        const min = shape >> 4n, extra = shape & 8n ? this.leb() : null;
+        const arity = new ArityRange(min, extra === null ? min : extra === 0n ? null : uint64(min + extra));
+        const count = this.leb();
+        address = uint64(address + gap + count);
+        total += count;
+        requireValue(total <= BigInt(limits.maxLinks), "too many links");
+        sections.push(new Section(gap, arity, WIDTHS[Number(shape & 3n)], []));
+        counts.push(Number(count));
+      }
+    } else {
+      const count = this.leb();
+      uint64(6n + count);
+      requireValue(count <= BigInt(limits.maxLinks), "too many links");
+      if (count) {
+        sections.push(new Section(5, new ArityRange, WIDTHS[header >> 2 & 3], []));
+        counts.push(Number(count));
+      }
+    }
+    let references = 0n;
+    for (let i = 0;i < sections.length; i++) {
+      const section = sections[i];
+      for (let j = 0;j < counts[i]; j++) {
+        const length = uint64(section.arity.min + (section.arity.fixed ? 0n : this.leb()));
+        requireValue(section.arity.contains(length), "link outside arity");
+        references += length;
+        requireValue(references <= BigInt(limits.maxReferences), "too many references");
+        const link = [], top = 1n << BigInt(section.width * 8 - 1);
+        for (let k = 0n;k < length; k++) {
+          const raw = this.raw(section.width);
+          link.push(header & 1 && raw >= top ? new External(raw === top ? 0n : (top << 1n) - raw) : raw);
+        }
+        section.links.push(link);
+      }
+    }
+    return new LinksPacket(Boolean(header & 1), sections);
+  }
+}
+
+class LinksPacket {
+  constructor(externalReferences = false, sections = []) {
+    Object.assign(this, { externalReferences, sections });
+  }
+  links() {
+    const result = [];
+    let address = 1n;
+    for (const section of this.sections) {
+      address = uint64(address + uint64(section.gap));
+      for (const link of section.links) {
+        result.push([
+          address,
+          link.map((r) => r instanceof External ? r : uint64(r))
+        ]);
+        address = uint64(address + 1n);
+      }
+    }
+    return result;
+  }
+  validate(limits = new DecodeLimits) {
+    requireValue(this.sections.length <= limits.maxLinks && this.links().length <= limits.maxLinks, "too many links or sections");
+    let references = 0;
+    for (const s of this.sections) {
+      requireValue(WIDTHS.includes(s.width), "invalid width");
+      new ArityRange(s.arity.min, s.arity.max);
+      for (const link of s.links) {
+        requireValue(s.arity.contains(link.length), "link outside arity");
+        references += link.length;
+        requireValue(references <= limits.maxReferences, "too many references");
+        for (const r of link)
+          requireValue(referenceWidth(r, this.externalReferences) <= s.width, "reference outside width");
+      }
+    }
+    return this;
+  }
+  toBytes(limits = new DecodeLimits) {
+    this.validate(limits);
+    const s = this.sections[0];
+    const compact = !s || this.sections.length === 1 && s.gap === 5n && s.arity.min === 2n && s.arity.max === 2n && s.links.length > 0;
+    const out = [16 | Number(this.externalReferences)];
+    if (compact) {
+      out[0] |= WIDTHS.indexOf(s?.width ?? 1) << 2;
+      leb(out, s?.links.length ?? 0);
+    } else {
+      out[0] |= 2;
+      leb(out, this.sections.length);
+      for (const s of this.sections) {
+        leb(out, s.arity.min << 4n | BigInt(WIDTHS.indexOf(s.width) | (s.gap ? 4 : 0) | (s.arity.fixed ? 0 : 8)));
+        if (s.gap)
+          leb(out, s.gap);
+        if (!s.arity.fixed)
+          leb(out, s.arity.max === null ? 0n : s.arity.max - s.arity.min);
+        leb(out, s.links.length);
+      }
+    }
+    for (const s of this.sections)
+      for (const link of s.links) {
+        if (!s.arity.fixed)
+          leb(out, BigInt(link.length) - s.arity.min);
+        for (const r of link) {
+          const bits = BigInt(s.width * 8);
+          let raw = r instanceof External ? r.value === 0n ? 1n << bits - 1n : (1n << bits) - r.value : uint64(r);
+          for (let i = 0;i < s.width; i++) {
+            out.push(Number(raw & 255n));
+            raw >>= 8n;
+          }
+        }
+      }
+    return Uint8Array.from(out);
+  }
+  static fromBytes(bytes, limits = new DecodeLimits) {
+    const reader = new PacketReader(bytes), packet = reader.read(limits);
+    requireValue(packet !== null, "empty input");
+    requireValue(reader.offset === bytes.length, "trailing bytes");
+    return packet;
+  }
+  static parseLinks(text) {
+    return text.split(";").filter((s) => s.trim()).map((entry) => {
+      const [a, refs] = entry.split(":");
+      return [
+        uint64(BigInt(a.trim())),
+        refs.trim().split(/\s+/).filter(Boolean).map((r) => r.startsWith("#") ? new External(BigInt(r.slice(1))) : uint64(BigInt(r)))
+      ];
+    });
+  }
+  static pack(externalReferences, input, packedWidths = false) {
+    const links = input.map(([a, r]) => [uint64(a), r]);
+    let previous = 0n;
+    const needs = links.map(([a, refs]) => {
+      requireValue(a > previous && a < U64 && refs.length > 0, "invalid address order or empty link");
+      previous = a;
+      return refs.reduce((need, r) => Math.max(need, referenceWidth(r, externalReferences)), 1);
+    });
+    function layout(packed) {
+      if (!links.length)
+        return [];
+      const widest = needs.reduce((a, b) => Math.max(a, b), 1), opens = [], bests = [];
+      let costs = Array(8).fill(Infinity);
+      const cheapest = (c) => c.reduce((best, v, s) => v < c[best] ? s : best, 0);
+      for (let i = 0;i < links.length; i++) {
+        const best = cheapest(costs), before = i ? costs[best] : 0, next = Array(8).fill(Infinity);
+        let mask = 0;
+        bests.push(best);
+        for (let state = 0;state < 8; state++) {
+          const width = WIDTHS[state >> 1], variable = state & 1;
+          if (!packed && width !== widest || width < needs[i])
+            continue;
+          const opening = before + 2 + variable;
+          const continuing = i && links[i - 1][0] + 1n === links[i][0] && (variable || links[i - 1][1].length === links[i][1].length) ? costs[state] : Infinity;
+          if (continuing <= opening)
+            next[state] = continuing + links[i][1].length * width + variable;
+          else {
+            next[state] = opening + links[i][1].length * width + variable;
+            mask |= 1 << state;
+          }
+        }
+        opens.push(mask);
+        costs = next;
+      }
+      const result = [];
+      let end = links.length, state = cheapest(costs);
+      for (let i = links.length - 1;i >= 0; i--)
+        if (opens[i] & 1 << state) {
+          result.push([end - i, WIDTHS[state >> 1]]);
+          end = i;
+          state = bests[i];
+        }
+      return result.reverse();
+    }
+    function packet(plan) {
+      const sections = [];
+      let index = 0, address = 1n;
+      for (const [count, width] of plan) {
+        const members = links.slice(index, index + count), start = members[0][0];
+        let min = Infinity, max = 0;
+        for (const [, r] of members) {
+          min = Math.min(min, r.length);
+          max = Math.max(max, r.length);
+        }
+        sections.push(new Section(start - address, new ArityRange(min, max), width, members.map(([, r]) => r)));
+        index += count;
+        address = start + BigInt(count);
+      }
+      return new LinksPacket(externalReferences, sections);
+    }
+    const uniform = packet(layout(false));
+    if (!packedWidths)
+      return uniform;
+    const packed = packet(layout(true));
+    return packed.toBytes(DecodeLimits.unlimited()).length < uniform.toBytes(DecodeLimits.unlimited()).length ? packed : uniform;
+  }
+}
+
+class Encoder {
+  constructor(options) {
+    this.options = options;
+    this.doublets = [];
+    this.tuples = [];
+    this.created = new Map;
+    this.powers = [["i", 1n]];
+  }
+  link(items) {
+    const key = items.map(([k, v]) => `${k}${v}`).join(",");
+    if (!this.created.has(key)) {
+      const doublet = items.length === 2 && items.every(([k]) => k !== "t"), target = doublet ? this.doublets : this.tuples;
+      const node = [doublet ? "d" : "t", BigInt(target.length)];
+      target.push(items);
+      this.created.set(key, node);
+    }
+    return this.created.get(key);
+  }
+  chain(items) {
+    let tail = ["i", 0n];
+    for (let i = items.length - 1;i >= 0; i--)
+      tail = this.link([items[i], tail]);
+    return tail;
+  }
+  typed(marker, elements) {
+    const items = [["i", BigInt(marker)], ...elements];
+    return items.length !== 2 && this.options.arity.contains(items.length) ? this.link(items) : this.link([items[0], this.chain(elements)]);
+  }
+  list(elements) {
+    if (!elements.length)
+      return ["i", 0n];
+    return elements.length === 2 || this.options.arity.contains(elements.length) ? this.link(elements) : this.typed(4, elements);
+  }
+  unary(value) {
+    const powers = [];
+    for (let bit = 63;bit >= 0; bit--)
+      if (value & 1n << BigInt(bit)) {
+        while (this.powers.length <= bit) {
+          const p = this.powers.at(-1);
+          this.powers.push(this.link([p, p]));
+        }
+        powers.push(this.powers[bit]);
+      }
+    let sum = powers.pop() ?? ["i", 0n];
+    while (powers.length)
+      sum = this.link([powers.pop(), sum]);
+    return sum;
+  }
+  scalar(value) {
+    return this.options.externalReferences && value < 1n << 63n ? ["e", value] : this.unary(value);
+  }
+  reference(text) {
+    if (/^(0|[1-9][0-9]*)$/.test(text) && text.length <= 20 && BigInt(text) <= U64) {
+      const value = BigInt(text);
+      return this.options.externalReferences && value < 1n << 63n ? ["e", value] : this.link([["i", 2n], this.unary(value)]);
+    }
+    return this.typed(3, Array.from(text, (c) => this.scalar(BigInt(c.codePointAt(0)))));
+  }
+  encode(node) {
+    if (node.id !== null && !node.values.length)
+      return this.reference(node.id);
+    if (node.id !== null) {
+      const id = this.reference(node.id);
+      return this.typed(5, [id, ...node.values.map((v) => this.encode(v))]);
+    }
+    return this.list(node.values.map((v) => this.encode(v)));
+  }
+  finish() {
+    const resolve = ([k, v]) => k === "e" ? new External(v) : k === "i" ? v : 6n + v + (k === "t" ? BigInt(this.doublets.length) : 0n);
+    return LinksPacket.pack(this.options.externalReferences, this.doublets.concat(this.tuples).map((items, i) => [6n + BigInt(i), items.map(resolve)]), this.options.packedWidths);
+  }
+}
+
+class Decoder {
+  constructor(packet, limits) {
+    packet.validate(limits);
+    this.limits = limits;
+    this.links = [];
+    this.unary = [];
+    this.nodes = limits.maxNodes;
+    this.strings = limits.maxStringBytes;
+    for (const [address, refs] of packet.links()) {
+      requireValue(address === 6n + BigInt(this.links.length) && refs.every((r) => r instanceof External || r < address), "document addresses must be contiguous and references backward");
+      const value = (r) => r instanceof External ? null : r <= 1n ? r : r >= 6n ? this.unary[Number(r - 6n)] : null;
+      const a = refs.length === 2 ? value(refs[0]) : null, b = refs.length === 2 ? value(refs[1]) : null;
+      this.unary.push(a !== null && b !== null && a + b <= U64 ? a + b : null);
+      this.links.push(refs);
+    }
+  }
+  chain(tail) {
+    const elements = [];
+    while (tail !== 0n) {
+      requireValue(typeof tail === "bigint" && tail >= 6n, "broken chain");
+      const items = this.links[Number(tail - 6n)];
+      requireValue(items.length === 2 && elements.length < this.limits.maxNodes, "broken or excessive chain");
+      elements.push(items[0]);
+      tail = items[1];
+    }
+    return elements;
+  }
+  number(r) {
+    const value = r instanceof External ? r.value : r <= 1n ? r : r >= 6n ? this.unary[Number(r - 6n)] : null;
+    requireValue(value !== null, "expected unary number");
+    return value;
+  }
+  text(text) {
+    this.strings -= new globalThis.TextEncoder().encode(text).length;
+    requireValue(this.strings >= 0, "string budget exceeded");
+    return new Link(text);
+  }
+  decode(r, depth) {
+    requireValue(depth < this.limits.maxDepth && --this.nodes >= 0, "node or depth budget exceeded");
+    if (r instanceof External)
+      return this.text(String(r.value));
+    if (r === 0n)
+      return new Link;
+    requireValue(r >= 6n, "standalone marker");
+    const items = this.links[Number(r - 6n)];
+    let elements;
+    if (typeof items[0] === "bigint" && items[0] >= 1n && items[0] <= 5n) {
+      const marker = Number(items[0]);
+      elements = items.length !== 2 || marker === 2 ? items.slice(1) : this.chain(items[1]);
+      if (marker === 2) {
+        requireValue(elements.length === 1, "number needs one value");
+        return this.text(String(this.number(elements[0])));
+      }
+      if (marker === 3) {
+        const chars = [];
+        let byteCount = 0;
+        for (const e of elements) {
+          const p = this.number(e);
+          requireValue(p <= 0x10ffffn && !(p >= 0xd800n && p <= 0xdfffn), "invalid Unicode scalar");
+          const size = p <= 0x7fn ? 1 : p <= 0x7ffn ? 2 : p <= 0xffffn ? 3 : 4;
+          requireValue(size <= this.strings - byteCount, "string budget exceeded");
+          byteCount += size;
+          chars.push(String.fromCodePoint(Number(p)));
+        }
+        return this.text(chars.join(""));
+      }
+      if (marker === 5) {
+        requireValue(elements.length > 0, "identified needs id");
+        const id = this.decode(elements[0], depth);
+        requireValue(id.id !== null && !id.values.length, "id must be reference");
+        return new Link(id.id, elements.slice(1).map((e) => this.decode(e, depth + 1)));
+      }
+      requireValue(marker === 4, "invalid typed marker");
+    } else
+      elements = items;
+    return new Link(null, elements.map((e) => this.decode(e, depth + 1)));
+  }
+  document() {
+    if (!this.links.length)
+      return [];
+    const root = this.links.at(-1);
+    let elements;
+    if (root.length === 2 && root[0] === 4n)
+      elements = this.chain(root[1]);
+    else {
+      requireValue(!(typeof root[0] === "bigint" && root[0] >= 1n && root[0] <= 5n), "root must be list");
+      elements = root;
+    }
+    return elements.map((e) => this.decode(e, 0));
+  }
+}
+function canonical(node) {
+  if (node.id === null && node.values.length === 1 && node.values[0].id !== null && !node.values[0].values.length)
+    return node.values[0];
+  return new Link(node.id, node.values.map(canonical));
+}
+function formatBinaryReference(text) {
+  return formatReference(text);
+}
+function formatBinaryDocument(document) {
+  function nested(node, top = false) {
+    if (node.id !== null && !node.values.length)
+      return formatBinaryReference(node.id);
+    const values = node.values.map((v) => nested(v)).join(" ");
+    if (node.id !== null)
+      return `(${formatBinaryReference(node.id)}: ${values})`;
+    if (node.values.length === 1 && node.values[0].id !== null && !node.values[0].values.length)
+      return `((${values}))`;
+    return top && node.values.length >= 2 ? values : `(${values})`;
+  }
+  return document.map((n) => nested(n, true)).join(`
+`);
+}
+
+class BinaryLinoCodec {
+  constructor(options = new BinaryLinoOptions, limits = new DecodeLimits) {
+    Object.assign(this, { options, limits });
+  }
+  encodePacket(document) {
+    requireValue(this.options.arity.contains(2), "arity must contain 2");
+    const pending = document.map((n) => [n, 0]);
+    let nodes = 0, strings = 0;
+    while (pending.length) {
+      const [n, depth] = pending.pop();
+      requireValue(n instanceof Link && depth < this.limits.maxDepth, "invalid model or excessive depth");
+      nodes += 1 + Number(n.id !== null && n.values.length > 0);
+      if (n.id !== null) {
+        requireValue(typeof n.id === "string" && n.id.isWellFormed(), "invalid Unicode string");
+        strings += new globalThis.TextEncoder().encode(n.id).length;
+      }
+      requireValue(nodes <= this.limits.maxNodes && strings <= this.limits.maxStringBytes, "model budget exceeded");
+      for (const v of n.values)
+        pending.push([v, depth + 1]);
+    }
+    const encoder = new Encoder(this.options);
+    if (document.length)
+      encoder.list(document.map((n) => encoder.encode(n)));
+    return encoder.finish().validate(this.limits);
+  }
+  encode(document) {
+    return this.encodePacket(document).toBytes(this.limits);
+  }
+  decodePacket(packet) {
+    return new Decoder(packet, this.limits).document();
+  }
+  decode(bytes) {
+    return this.decodePacket(LinksPacket.fromBytes(bytes, this.limits));
+  }
+  parseDocument(text, parser = new Parser) {
+    return parser.parse(text).map(canonical);
+  }
+  formatDocument(document) {
+    return formatBinaryDocument(document);
+  }
+  encodeText(text, parser) {
+    return this.encode(this.parseDocument(text, parser));
+  }
+  decodeText(bytes) {
+    return this.formatDocument(this.decode(bytes));
+  }
+}
 export {
+  ArityRange,
+  BinaryLinoCodec,
+  BinaryLinoOptions,
   DEFAULT_MAX_DEPTH,
+  DecodeLimits,
+  External,
   FormatConfig,
   FormatOptions,
   Link,
   LinksGroup,
+  LinksPacket,
+  PacketReader,
   ParseError,
   Parser,
+  Section,
   StreamParseError,
   StreamParser,
+  decodeReferenceLiteral,
+  encodeReferenceLiteral,
+  formatBinaryDocument,
+  formatBinaryReference,
   formatLinks,
   stripComments
 };