links-notation 0.21.0 → 0.21.2

package/dist/index.js

@@ -341,9 +341,146 @@ function windowAround(lineText, column) {
   return [quoted, target - start + shift + 1];
 }
 
+// src/quotes.js
+var QUOTES = ['"', "'", "`"];
+
+class DelimitedReferences {
+  constructor(document) {
+    this.document = document;
+    this.runsByQuote = new Map;
+    this.readings = new Map;
+  }
+  readAt(start) {
+    if (!this.readings.has(start)) {
+      this.readings.set(start, this.#read(start));
+    }
+    return this.readings.get(start);
+  }
+  endAt(start) {
+    const reading = this.readAt(start);
+    return reading === null ? null : start + reading.length;
+  }
+  #read(start) {
+    const document = this.document;
+    const quote = document[start];
+    if (!QUOTES.includes(quote)) {
+      return null;
+    }
+    const runs = this.#runsOf(quote);
+    const opening = runs.indexOf(start);
+    const count = runs.end(opening) - start;
+    let closing = opening + 1;
+    while (closing < runs.count) {
+      const length = runs.lengths[closing];
+      if (length < count) {
+        closing = runs.nextLonger[closing];
+      } else if (Math.floor(length / count) % 2 === 1) {
+        break;
+      } else {
+        closing++;
+      }
+    }
+    const end = closing < runs.count ? runs.end(closing) : null;
+    return reading(document, start, quote, count, end);
+  }
+  #runsOf(quote) {
+    if (!this.runsByQuote.has(quote)) {
+      this.runsByQuote.set(quote, new DelimiterRuns(this.document, quote));
+    }
+    return this.runsByQuote.get(quote);
+  }
+}
+function reading(document, start, quote, count, end) {
+  const emptyReference = count % 2 === 0 ? { value: "", length: count } : null;
+  if (end === null) {
+    return emptyReference;
+  }
+  const parts = [];
+  let position = start + count;
+  let run = document.indexOf(quote, position);
+  while (run !== -1 && run < end) {
+    const length = runLength(document, run, quote);
+    const escaped = Math.floor(length / (2 * count)) * count;
+    const closes = run + length === end ? count : 0;
+    parts.push(document.slice(position, run));
+    parts.push(quote.repeat(length - escaped - closes));
+    position = run + length;
+    run = document.indexOf(quote, position);
+  }
+  const value = parts.join("");
+  if (emptyReference !== null && !isSubstantiveBody(value)) {
+    return emptyReference;
+  }
+  return { value, length: end - start };
+}
+function runLength(text, start, quote) {
+  let end = start;
+  while (end < text.length && text[end] === quote) {
+    end++;
+  }
+  return end - start;
+}
+
+class DelimiterRuns {
+  constructor(document, quote) {
+    this.starts = [];
+    this.lengths = [];
+    let position = document.indexOf(quote);
+    while (position !== -1) {
+      const length = runLength(document, position, quote);
+      this.starts.push(position);
+      this.lengths.push(length);
+      position = document.indexOf(quote, position + length);
+    }
+    this.count = this.starts.length;
+    this.nextLonger = new Array(this.count);
+    const longer = [];
+    for (let run = this.count - 1;run >= 0; run--) {
+      while (longer.length > 0 && this.lengths[longer[longer.length - 1]] <= this.lengths[run]) {
+        longer.pop();
+      }
+      this.nextLonger[run] = longer.length > 0 ? longer[longer.length - 1] : this.count;
+      longer.push(run);
+    }
+  }
+  end(run) {
+    return this.starts[run] + this.lengths[run];
+  }
+  indexOf(position) {
+    let low = 0;
+    let high = this.count - 1;
+    while (low < high) {
+      const middle = low + high + 1 >> 1;
+      if (this.starts[middle] <= position) {
+        low = middle;
+      } else {
+        high = middle - 1;
+      }
+    }
+    return low;
+  }
+}
+function isSubstantiveBody(content) {
+  let depth = 0;
+  let hasVisible = false;
+  for (const character of content) {
+    if (character === "(") {
+      depth++;
+    } else if (character === ")") {
+      depth--;
+      if (depth < 0) {
+        return false;
+      }
+    }
+    if (!/[ \t\n\r]/.test(character)) {
+      hasVisible = true;
+    }
+  }
+  return hasVisible && depth === 0;
+}
+
 // src/comments.js
 var COMMENT = "#";
-var QUOTES = ['"', "'", "`"];
 var BEFORE_REFERENCE = [" ", "\t", `
 `, "\r", "(", ":"];
 var BEFORE_COMMENT = [" ", "\t", `
@@ -351,10 +488,11 @@ var BEFORE_COMMENT = [" ", "\t", `
 function stripComments(document) {
   let blanked = null;
   let position = 0;
+  const references = new DelimitedReferences(document);
   while (position < document.length) {
     const character = document[position];
     if (QUOTES.includes(character) && follows(document, position, BEFORE_REFERENCE)) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       position = end === null ? position + 1 : end;
       continue;
     }
@@ -374,59 +512,6 @@ function stripComments(document) {
 function follows(document, position, allowed) {
   return position === 0 || allowed.includes(document[position - 1]);
 }
-function quotedReferenceEnd(document, start) {
-  const quote = document[start];
-  if (!QUOTES.includes(quote)) {
-    return null;
-  }
-  let position = start;
-  while (position < document.length && document[position] === quote) {
-    position++;
-  }
-  const count = position - start;
-  const isEvenRun = count % 2 === 0;
-  const emptyReference = isEvenRun ? start + count : null;
-  const closing = quote.repeat(count);
-  const escape = quote.repeat(count * 2);
-  let content = "";
-  while (position < document.length) {
-    if (document.startsWith(escape, position)) {
-      content += closing;
-      position += escape.length;
-      continue;
-    }
-    if (document.startsWith(closing, position)) {
-      const afterClosing = position + count;
-      if (afterClosing >= document.length || document[afterClosing] !== quote) {
-        if (isEvenRun && !isSubstantiveBody(content)) {
-          return emptyReference;
-        }
-        return afterClosing;
-      }
-    }
-    content += document[position];
-    position++;
-  }
-  return emptyReference;
-}
-function isSubstantiveBody(content) {
-  let depth = 0;
-  let hasVisible = false;
-  for (const character of content) {
-    if (character === "(") {
-      depth++;
-    } else if (character === ")") {
-      depth--;
-      if (depth < 0) {
-        return false;
-      }
-    }
-    if (!/[ \t\n\r]/.test(character)) {
-      hasVisible = true;
-    }
-  }
-  return hasVisible && depth === 0;
-}
 
 // src/parser-generated.js
 class peg$SyntaxError extends SyntaxError {
@@ -2229,61 +2314,12 @@ function peg$parse(input, options) {
   function getCurrentIndentation() {
     return indentationStack[indentationStack.length - 1];
   }
-  function isSubstantiveBody(content) {
-    let depth = 0;
-    let hasVisible = false;
-    for (const c of content) {
-      if (c === "(") {
-        depth++;
-      } else if (c === ")") {
-        depth--;
-        if (depth < 0) {
-          return false;
-        }
-      }
-      if (!/[ \t\n\r]/.test(c)) {
-        hasVisible = true;
-      }
-    }
-    return hasVisible && depth === 0;
-  }
+  const delimitedReferences = new DelimitedReferences(input);
   function parseQuotedStringAt(inputStr, startPos, quoteChar) {
     if (startPos >= inputStr.length || inputStr[startPos] !== quoteChar) {
       return null;
     }
-    let quoteCount = 0;
-    let pos = startPos;
-    while (pos < inputStr.length && inputStr[pos] === quoteChar) {
-      quoteCount++;
-      pos++;
-    }
-    const isEvenRun = quoteCount % 2 === 0;
-    const emptyReference = isEvenRun ? { value: "", length: quoteCount } : null;
-    const closeSeq = quoteChar.repeat(quoteCount);
-    const escapeSeq = quoteChar.repeat(quoteCount * 2);
-    let content = "";
-    while (pos < inputStr.length) {
-      if (inputStr.substr(pos, escapeSeq.length) === escapeSeq) {
-        content += closeSeq;
-        pos += escapeSeq.length;
-        continue;
-      }
-      if (inputStr.substr(pos, quoteCount) === closeSeq) {
-        const afterClose = pos + quoteCount;
-        if (afterClose >= inputStr.length || inputStr[afterClose] !== quoteChar) {
-          if (isEvenRun && !isSubstantiveBody(content)) {
-            return emptyReference;
-          }
-          return {
-            value: content,
-            length: afterClose - startPos
-          };
-        }
-      }
-      content += inputStr[pos];
-      pos++;
-    }
-    return emptyReference;
+    return delimitedReferences.readAt(startPos);
   }
   let parsedValue = null;
   let parsedLength = 0;
@@ -2355,12 +2391,7 @@ class Parser {
       return;
     if (item.children && item.children.length > 0) {
       if (item.id !== undefined && item.id !== null && (!item.values || item.values.length === 0)) {
-        const childValues = item.children.map((child) => {
-          if (child.values && child.values.length === 1) {
-            return this.transformLink(child.values[0]);
-          }
-          return this.transformLink(child);
-        });
+        const childValues = item.children.map((child) => this.transformIndentedValue(child));
         const linkWithChildren = {
           id: item.id,
           values: childValues
@@ -2392,6 +2423,23 @@ class Parser {
       }
     }
   }
+  transformIndentedValue(item) {
+    const children = item.children || [];
+    if (children.length && item.id != null && !item.values?.length) {
+      return new Link(item.id, children.map((child) => this.transformIndentedValue(child)));
+    }
+    const current = this.transformLink(item);
+    if (children.length) {
+      return new Link(current.id, [
+        ...current.values,
+        ...children.map((child) => this.transformIndentedValue(child))
+      ]);
+    }
+    if (item.id == null && item.nested === undefined && current.values.length === 1) {
+      return current.values[0];
+    }
+    return current;
+  }
   combinePathElements(pathElements, current) {
     if (pathElements.length === 0)
       return current;
@@ -2630,12 +2678,13 @@ function structurallyComplete(document, comments) {
 `, "\r", "(", ":"];
   const beforeComment = [" ", "\t", `
 `, "\r"];
+  const references = new DelimitedReferences(document);
   let depth = 0;
   for (let position = 0;position < document.length; position++) {
     const character = document[position];
     const previous = position === 0 ? null : document[position - 1];
     if (quotes.includes(character) && (previous === null || beforeReference.includes(previous))) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       if (end === null)
         return false;
       position = end - 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/Parser.js

@@ -80,13 +80,9 @@ export class Parser {
         item.id !== null &&
         (!item.values || item.values.length === 0)
       ) {
-        const childValues = item.children.map((child) => {
-          // For indented children, extract the actual reference from the child's values
-          if (child.values && child.values.length === 1) {
-            return this.transformLink(child.values[0]);
-          }
-          return this.transformLink(child);
-        });
+        const childValues = item.children.map((child) =>
+          this.transformIndentedValue(child)
+        );
         const linkWithChildren = {
           id: item.id,
           values: childValues,
@@ -128,6 +124,34 @@ export class Parser {
     }
   }
 
+  // A line below an indented ID is a value in its own right. Bare single
+  // references unwrap, but named links and descendants keep their structure.
+  transformIndentedValue(item) {
+    const children = item.children || [];
+    if (children.length && item.id != null && !item.values?.length) {
+      return new Link(
+        item.id,
+        children.map((child) => this.transformIndentedValue(child))
+      );
+    }
+
+    const current = this.transformLink(item);
+    if (children.length) {
+      return new Link(current.id, [
+        ...current.values,
+        ...children.map((child) => this.transformIndentedValue(child)),
+      ]);
+    }
+    if (
+      item.id == null &&
+      item.nested === undefined &&
+      current.values.length === 1
+    ) {
+      return current.values[0];
+    }
+    return current;
+  }
+
   combinePathElements(pathElements, current) {
     if (pathElements.length === 0) return current;
     if (pathElements.length === 1) {

package/src/StreamParser.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { Parser } from './Parser.js';
-import { quotedReferenceEnd } from './comments.js';
+import { DelimitedReferences } from './quotes.js';
 
 const DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 
@@ -249,6 +249,7 @@ function structurallyComplete(document, comments) {
   const quotes = ['"', "'", '`'];
   const beforeReference = [' ', '\t', '\n', '\r', '(', ':'];
   const beforeComment = [' ', '\t', '\n', '\r'];
+  const references = new DelimitedReferences(document);
   let depth = 0;
 
   for (let position = 0; position < document.length; position++) {
@@ -259,7 +260,7 @@ function structurallyComplete(document, comments) {
       quotes.includes(character) &&
       (previous === null || beforeReference.includes(previous))
     ) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       if (end === null) return false;
       position = end - 1;
       continue;

package/src/comments.js

@@ -12,12 +12,11 @@
  * the reader can see.
  */
 
+import { DelimitedReferences, QUOTES, readReference } from './quotes.js';
+
 /** The character that starts a comment. */
 export const COMMENT = '#';
 
-/** The delimiters a reference can be written between. */
-const QUOTES = ['"', "'", '`'];
-
 /** What a delimited reference may start after. */
 const BEFORE_REFERENCE = [' ', '\t', '\n', '\r', '(', ':'];
 
@@ -38,6 +37,7 @@ export function stripComments(document) {
   // parse error reports are both counted in.
   let blanked = null;
   let position = 0;
+  const references = new DelimitedReferences(document);
 
   while (position < document.length) {
     const character = document[position];
@@ -46,7 +46,7 @@ export function stripComments(document) {
       QUOTES.includes(character) &&
       follows(document, position, BEFORE_REFERENCE)
     ) {
-      const end = quotedReferenceEnd(document, position);
+      const end = references.endAt(position);
       position = end === null ? position + 1 : end;
       continue;
     }
@@ -95,70 +95,6 @@ function follows(document, position, allowed) {
  * @returns {number|null} The position just past the reference
  */
 export function quotedReferenceEnd(document, start) {
-  const quote = document[start];
-  if (!QUOTES.includes(quote)) {
-    return null;
-  }
-
-  let position = start;
-  while (position < document.length && document[position] === quote) {
-    position++;
-  }
-  const count = position - start;
-  const isEvenRun = count % 2 === 0;
-  const emptyReference = isEvenRun ? start + count : null;
-
-  const closing = quote.repeat(count);
-  const escape = quote.repeat(count * 2);
-  let content = '';
-
-  while (position < document.length) {
-    if (document.startsWith(escape, position)) {
-      content += closing;
-      position += escape.length;
-      continue;
-    }
-
-    if (document.startsWith(closing, position)) {
-      const afterClosing = position + count;
-      if (afterClosing >= document.length || document[afterClosing] !== quote) {
-        if (isEvenRun && !isSubstantiveBody(content)) {
-          return emptyReference;
-        }
-        return afterClosing;
-      }
-    }
-
-    content += document[position];
-    position++;
-  }
-
-  return emptyReference;
-}
-
-/**
- * Whether a body written between an even run of delimiters carries something a
- * pair of delimiters enclosing nothing cannot.
- * @param {string} content - The body between the delimiters
- * @returns {boolean} True when the n-quote reading is the one to take
- */
-function isSubstantiveBody(content) {
-  let depth = 0;
-  let hasVisible = false;
-
-  for (const character of content) {
-    if (character === '(') {
-      depth++;
-    } else if (character === ')') {
-      depth--;
-      if (depth < 0) {
-        return false;
-      }
-    }
-    if (!/[ \t\n\r]/.test(character)) {
-      hasVisible = true;
-    }
-  }
-
-  return hasVisible && depth === 0;
+  const reading = readReference(document, start);
+  return reading === null ? null : start + reading.length;
 }

package/src/grammar.pegjs

@@ -1,3 +1,7 @@
+{{
+  import { DelimitedReferences } from './quotes.js';
+}}
+
 {
   let indentationStack = [0];
   let baseIndentation = null;
@@ -66,87 +70,18 @@
     return indentationStack[indentationStack.length - 1];
   }
 
-  // A body written between an even run of delimiters is substantive when it
-  // holds at least one visible character and does not straddle a parenthesis.
-  // An even run can always be read as delimiter pairs enclosing nothing, so the
-  // n-quote reading is only taken when it carries something the pairs cannot.
-  function isSubstantiveBody(content) {
-    let depth = 0;
-    let hasVisible = false;
-
-    for (const c of content) {
-      if (c === '(') {
-        depth++;
-      } else if (c === ')') {
-        depth--;
-        if (depth < 0) {
-          return false;
-        }
-      }
-      if (!/[ \t\n\r]/.test(c)) {
-        hasVisible = true;
-      }
-    }
-
-    return hasVisible && depth === 0;
-  }
+  // Delimited references of this document, each read once however many
+  // alternatives ask for it (see quotes.js for how a reference is read)
+  const delimitedReferences = new DelimitedReferences(input);
 
   // Universal procedural parser for N-quote strings (any N >= 1)
   // Parses from the given position in the input string
-  // A run of an even number of delimiters that does not open a reference with a
-  // substantive body is the empty reference: the shortest reading, a bare
-  // delimiter pair enclosing nothing, wins over a longer n-quote delimiter.
   // Returns { value, length } or null
   function parseQuotedStringAt(inputStr, startPos, quoteChar) {
     if (startPos >= inputStr.length || inputStr[startPos] !== quoteChar) {
       return null;
     }
-
-    // Count opening quotes
-    let quoteCount = 0;
-    let pos = startPos;
-    while (pos < inputStr.length && inputStr[pos] === quoteChar) {
-      quoteCount++;
-      pos++;
-    }
-
-    const isEvenRun = quoteCount % 2 === 0;
-    const emptyReference = isEvenRun ? { value: '', length: quoteCount } : null;
-
-    const closeSeq = quoteChar.repeat(quoteCount);
-    const escapeSeq = quoteChar.repeat(quoteCount * 2);
-
-    let content = '';
-    while (pos < inputStr.length) {
-      // Check for escape sequence (2*N quotes)
-      if (inputStr.substr(pos, escapeSeq.length) === escapeSeq) {
-        content += closeSeq; // 2*N quotes become N quotes
-        pos += escapeSeq.length;
-        continue;
-      }
-
-      // Check for closing sequence (exactly N quotes)
-      if (inputStr.substr(pos, quoteCount) === closeSeq) {
-        // Verify it's exactly N quotes (not followed by more of same char)
-        const afterClose = pos + quoteCount;
-        if (afterClose >= inputStr.length || inputStr[afterClose] !== quoteChar) {
-          // Found valid closing
-          if (isEvenRun && !isSubstantiveBody(content)) {
-            return emptyReference;
-          }
-          return {
-            value: content,
-            length: afterClose - startPos
-          };
-        }
-      }
-
-      // Add character to content
-      content += inputStr[pos];
-      pos++;
-    }
-
-    return emptyReference; // No valid closing found
+    return delimitedReferences.readAt(startPos);
   }
 
   // Global state for passing parsed values between predicate and action

package/src/parser-generated.js

@@ -3,6 +3,9 @@
 // https://peggyjs.org/
 
 
+
+  import { DelimitedReferences } from './quotes.js';
+
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -1864,87 +1867,18 @@ function peg$parse(input, options) {
     return indentationStack[indentationStack.length - 1];
   }
 
-  // A body written between an even run of delimiters is substantive when it
-  // holds at least one visible character and does not straddle a parenthesis.
-  // An even run can always be read as delimiter pairs enclosing nothing, so the
-  // n-quote reading is only taken when it carries something the pairs cannot.
-  function isSubstantiveBody(content) {
-    let depth = 0;
-    let hasVisible = false;
-
-    for (const c of content) {
-      if (c === '(') {
-        depth++;
-      } else if (c === ')') {
-        depth--;
-        if (depth < 0) {
-          return false;
-        }
-      }
-      if (!/[ \t\n\r]/.test(c)) {
-        hasVisible = true;
-      }
-    }
-
-    return hasVisible && depth === 0;
-  }
+  // Delimited references of this document, each read once however many
+  // alternatives ask for it (see quotes.js for how a reference is read)
+  const delimitedReferences = new DelimitedReferences(input);
 
   // Universal procedural parser for N-quote strings (any N >= 1)
   // Parses from the given position in the input string
-  // A run of an even number of delimiters that does not open a reference with a
-  // substantive body is the empty reference: the shortest reading, a bare
-  // delimiter pair enclosing nothing, wins over a longer n-quote delimiter.
   // Returns { value, length } or null
   function parseQuotedStringAt(inputStr, startPos, quoteChar) {
     if (startPos >= inputStr.length || inputStr[startPos] !== quoteChar) {
       return null;
     }
-
-    // Count opening quotes
-    let quoteCount = 0;
-    let pos = startPos;
-    while (pos < inputStr.length && inputStr[pos] === quoteChar) {
-      quoteCount++;
-      pos++;
-    }
-
-    const isEvenRun = quoteCount % 2 === 0;
-    const emptyReference = isEvenRun ? { value: '', length: quoteCount } : null;
-
-    const closeSeq = quoteChar.repeat(quoteCount);
-    const escapeSeq = quoteChar.repeat(quoteCount * 2);
-
-    let content = '';
-    while (pos < inputStr.length) {
-      // Check for escape sequence (2*N quotes)
-      if (inputStr.substr(pos, escapeSeq.length) === escapeSeq) {
-        content += closeSeq; // 2*N quotes become N quotes
-        pos += escapeSeq.length;
-        continue;
-      }
-
-      // Check for closing sequence (exactly N quotes)
-      if (inputStr.substr(pos, quoteCount) === closeSeq) {
-        // Verify it's exactly N quotes (not followed by more of same char)
-        const afterClose = pos + quoteCount;
-        if (afterClose >= inputStr.length || inputStr[afterClose] !== quoteChar) {
-          // Found valid closing
-          if (isEvenRun && !isSubstantiveBody(content)) {
-            return emptyReference;
-          }
-          return {
-            value: content,
-            length: afterClose - startPos
-          };
-        }
-      }
-
-      // Add character to content
-      content += inputStr[pos];
-      pos++;
-    }
-
-    return emptyReference; // No valid closing found
+    return delimitedReferences.readAt(startPos);
   }
 
   // Global state for passing parsed values between predicate and action

package/src/quotes.js

@@ -0,0 +1,251 @@
+/**
+ * Delimited references, and how far each one reaches.
+ *
+ * A reference opened by a run of N delimiters (`"`, `'` or `` ` ``) closes at
+ * the next run of exactly N, and a run of 2N inside it is that delimiter
+ * escaped. An even run that encloses nothing substantive is the empty
+ * reference: the shortest reading, a bare delimiter pair enclosing nothing,
+ * wins over a longer n-quote delimiter.
+ *
+ * A run of R delimiters in a body is read as a whole: each 2N of it in turn are
+ * an escaped N, and the R % 2N left over close the reference when there are at
+ * least N of them - the last N close it, the ones before are content - and are
+ * content otherwise. So a run closes the reference exactly when
+ * `Math.floor(R / N)` is odd, and a run shorter than N never does.
+ *
+ * {@link DelimitedReferences} lists the runs of a delimiter once per document
+ * and links each run to the next longer one, so finding where a reference
+ * closes skips every run too short to close it. Reading a reference takes time
+ * linear in its body however wide its opening run is, and finding that a
+ * reference never closes does not take a pass over the rest of the document
+ * each time it is asked.
+ */
+
+/** The characters a reference can be written between. */
+export const QUOTES = ['"', "'", '`'];
+
+/**
+ * Every delimited reference of one document, read on demand.
+ *
+ * The grammar and the comment reader each keep one per document they read, so
+ * a reference asked for twice is read once.
+ */
+export class DelimitedReferences {
+  /**
+   * @param {string} document - The document the references are read from
+   */
+  constructor(document) {
+    this.document = document;
+    this.runsByQuote = new Map();
+    this.readings = new Map();
+  }
+
+  /**
+   * The reference opened at `start`.
+   * @param {number} start - Position of the opening delimiter
+   * @returns {{value: string, length: number}|null} What the reference holds
+   *   and how many characters it takes, or null when nothing opens there
+   */
+  readAt(start) {
+    if (!this.readings.has(start)) {
+      this.readings.set(start, this.#read(start));
+    }
+    return this.readings.get(start);
+  }
+
+  /**
+   * The position just past the reference opened at `start`.
+   * @param {number} start - Position of the opening delimiter
+   * @returns {number|null} The position, or null when nothing opens there
+   */
+  endAt(start) {
+    const reading = this.readAt(start);
+    return reading === null ? null : start + reading.length;
+  }
+
+  #read(start) {
+    const document = this.document;
+    const quote = document[start];
+    if (!QUOTES.includes(quote)) {
+      return null;
+    }
+
+    const runs = this.#runsOf(quote);
+    const opening = runs.indexOf(start);
+    const count = runs.end(opening) - start;
+
+    // The first run after the opening one that closes the reference.
+    let closing = opening + 1;
+    while (closing < runs.count) {
+      const length = runs.lengths[closing];
+      if (length < count) {
+        closing = runs.nextLonger[closing];
+      } else if (Math.floor(length / count) % 2 === 1) {
+        break;
+      } else {
+        closing++;
+      }
+    }
+    const end = closing < runs.count ? runs.end(closing) : null;
+    return reading(document, start, quote, count, end);
+  }
+
+  #runsOf(quote) {
+    if (!this.runsByQuote.has(quote)) {
+      this.runsByQuote.set(quote, new DelimiterRuns(this.document, quote));
+    }
+    return this.runsByQuote.get(quote);
+  }
+}
+
+/**
+ * The reference opened at `start`, read without a list of runs: for a single
+ * reference that is as quick, since it is read once.
+ * @param {string} document - The document being read
+ * @param {number} start - Position of the opening delimiter
+ * @returns {{value: string, length: number}|null} What the reference holds
+ *   and how many characters it takes, or null when nothing opens there
+ */
+export function readReference(document, start) {
+  const quote = document[start];
+  if (!QUOTES.includes(quote)) {
+    return null;
+  }
+  const count = runLength(document, start, quote);
+
+  let end = null;
+  let position = document.indexOf(quote, start + count);
+  while (position !== -1) {
+    const length = runLength(document, position, quote);
+    if (length >= count && Math.floor(length / count) % 2 === 1) {
+      end = position + length;
+      break;
+    }
+    position = document.indexOf(quote, position + length);
+  }
+  return reading(document, start, quote, count, end);
+}
+
+/**
+ * The reading of a reference opened by `count` delimiters at `start`, closed
+ * by the run that ends at `end` when there is one.
+ */
+function reading(document, start, quote, count, end) {
+  const emptyReference = count % 2 === 0 ? { value: '', length: count } : null;
+  if (end === null) {
+    return emptyReference;
+  }
+
+  const parts = [];
+  let position = start + count;
+  let run = document.indexOf(quote, position);
+  while (run !== -1 && run < end) {
+    const length = runLength(document, run, quote);
+    const escaped = Math.floor(length / (2 * count)) * count;
+    // The closing run is the last one of the body.
+    const closes = run + length === end ? count : 0;
+    parts.push(document.slice(position, run));
+    parts.push(quote.repeat(length - escaped - closes));
+    position = run + length;
+    run = document.indexOf(quote, position);
+  }
+  const value = parts.join('');
+
+  if (emptyReference !== null && !isSubstantiveBody(value)) {
+    return emptyReference;
+  }
+  return { value, length: end - start };
+}
+
+/** The number of `quote` delimiters in a row from `start` of `text`. */
+function runLength(text, start, quote) {
+  let end = start;
+  while (end < text.length && text[end] === quote) {
+    end++;
+  }
+  return end - start;
+}
+
+/**
+ * The maximal runs of one delimiter in a document, in order, each linked to the
+ * next run that is longer than it.
+ */
+class DelimiterRuns {
+  constructor(document, quote) {
+    this.starts = [];
+    this.lengths = [];
+
+    let position = document.indexOf(quote);
+    while (position !== -1) {
+      const length = runLength(document, position, quote);
+      this.starts.push(position);
+      this.lengths.push(length);
+      position = document.indexOf(quote, position + length);
+    }
+    this.count = this.starts.length;
+
+    // Every run between a run and the next longer one is at most as long as
+    // it, which is what lets a search for a run of some length jump over them.
+    this.nextLonger = new Array(this.count);
+    const longer = [];
+    for (let run = this.count - 1; run >= 0; run--) {
+      while (
+        longer.length > 0 &&
+        this.lengths[longer[longer.length - 1]] <= this.lengths[run]
+      ) {
+        longer.pop();
+      }
+      this.nextLonger[run] =
+        longer.length > 0 ? longer[longer.length - 1] : this.count;
+      longer.push(run);
+    }
+  }
+
+  /** Position just past the given run. */
+  end(run) {
+    return this.starts[run] + this.lengths[run];
+  }
+
+  /** The run that holds the given position of a delimiter. */
+  indexOf(position) {
+    let low = 0;
+    let high = this.count - 1;
+    while (low < high) {
+      const middle = (low + high + 1) >> 1;
+      if (this.starts[middle] <= position) {
+        low = middle;
+      } else {
+        high = middle - 1;
+      }
+    }
+    return low;
+  }
+}
+
+/**
+ * Whether a body written between an even run of delimiters carries something a
+ * pair of delimiters enclosing nothing cannot: at least one visible character,
+ * and no parenthesis it straddles.
+ * @param {string} content - The body between the delimiters
+ * @returns {boolean} True when the n-quote reading is the one to take
+ */
+export function isSubstantiveBody(content) {
+  let depth = 0;
+  let hasVisible = false;
+
+  for (const character of content) {
+    if (character === '(') {
+      depth++;
+    } else if (character === ')') {
+      depth--;
+      if (depth < 0) {
+        return false;
+      }
+    }
+    if (!/[ \t\n\r]/.test(character)) {
+      hasVisible = true;
+    }
+  }
+
+  return hasVisible && depth === 0;
+}

package/tests/IndentedIdNestedValues.test.js

@@ -0,0 +1,38 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const cases = [
+  [
+    'outer:\n  inner:\n    value1\n    value2\n  value3',
+    '(outer: (inner: value1 value2) value3)',
+  ],
+  [
+    'statement:\n  subject:\n    I\n  verb:\n    love\n  object:\n    you:\n      very\n      much',
+    '(statement: (subject: I) (verb: love) (object: (you: very much)))',
+  ],
+  [
+    'document:\n  (metadata: title author date)\n  content:\n    paragraph1\n    (paragraph2: text (with: nested structure))\n    paragraph3',
+    '(document: (metadata: title author date) (content: paragraph1 (paragraph2: text (with: nested structure)) paragraph3))',
+  ],
+  [
+    'image:\n    file: .gitpod.Dockerfile\n    context: ./docker-content',
+    '(image: (file: .gitpod.Dockerfile) (context: ./docker-content))',
+  ],
+  [
+    'level1:\n  level2:\n    level3a\n    level3b\n  level2b',
+    '(level1: (level2: level3a level3b) level2b)',
+  ],
+  [
+    'root:\n  child1\n  child2\n    grandchild',
+    '(root: child1 (child2 grandchild))',
+  ],
+];
+
+test('indented ID retains nested values', () => {
+  for (const [source, expected] of cases) {
+    const parser = new Parser();
+    expect(formatLinks(parser.parse(source))).toBe(expected);
+    expect(parser.parse(source)).toEqual(parser.parse(expected));
+  }
+});

package/tests/IndentedIdSyntax.test.js

@@ -123,7 +123,6 @@ test('Indented ID with deeper nesting', () => {
   child2
     grandchild`;
 
-  // This should work but the grandchild will be processed as a separate nested structure
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
 
@@ -131,6 +130,7 @@ test('Indented ID with deeper nesting', () => {
   const rootLink = result[0];
   expect(rootLink.id).toBe('root');
   expect(rootLink.values.length).toBe(2);
+  expect(formatLinks(result)).toBe('(root: child1 (child2 grandchild))');
 });
 
 test('Empty indented ID should work', () => {

package/tests/Issue316QuoteRuns.test.js

@@ -0,0 +1,163 @@
+import { test, expect, setDefaultTimeout } from 'bun:test';
+import { performance } from 'node:perf_hooks';
+import { Parser } from '../src/Parser.js';
+import { quotedReferenceEnd, stripComments } from '../src/comments.js';
+import { DelimitedReferences } from '../src/quotes.js';
+import { StreamParser } from '../src/StreamParser.js';
+
+// Issue #316: a reference that opens with a wide run of delimiters used to be
+// read one character at a time, comparing the whole width at every position,
+// and every run that never closed was read to the end of the document again.
+// These documents took from seconds to tens of seconds; read a run at a time
+// they take milliseconds, so the bound below only fails on the old behaviour.
+
+const parser = new Parser();
+const BOUND_MS = 2000;
+const SIZE = 400000;
+// A regression fails on the bound; the timeout stops it from hanging the run.
+setDefaultTimeout(20000);
+
+function render(node) {
+  if (!node.values || node.values.length === 0) {
+    return `<${node.id ?? ''}>`;
+  }
+  const head =
+    node.id === null || node.id === undefined ? '' : `<${node.id}>: `;
+  return `(${head}${node.values.map(render).join(' ')})`;
+}
+
+function parsesAs(source) {
+  return parser.parse(source).map(render).join('\n');
+}
+
+const q = (count) => "'".repeat(count);
+
+function timed(read) {
+  const started = performance.now();
+  const result = read();
+  return { result, elapsed: performance.now() - started };
+}
+
+// The shapes from the issue, and two that defeat shortcuts a fix could take.
+
+function wideQuoteOverALongRun(size) {
+  const width = Math.floor(size / 4);
+  return `${q(width + 1)} a ${q(width - 4)} ${'x'.repeat(2 * width)}`;
+}
+
+function narrowingUnclosedQuotes(size) {
+  const widths = [];
+  for (
+    let width = 2 * Math.floor(Math.sqrt(size / 2) / 2) + 1;
+    width >= 1;
+    width -= 2
+  ) {
+    widths.push(width);
+  }
+  const head = widths.map((width) => `${q(width)}x`).join(' ');
+  return `${head} ${"a' ".repeat(Math.floor((size - head.length) / 3))}`;
+}
+
+function closedWideQuoteOverQuotes(size) {
+  const width = Math.floor(size / 8);
+  return `${q(width)}${`${q(width - 1)}x`.repeat(6)}${q(width)}`;
+}
+
+function unclosedWidthsOverAnEvenRun(size) {
+  const run = Math.floor(size / 4);
+  const widths = [];
+  for (let width = Math.floor(Math.sqrt(size)); width >= 2; width--) {
+    if (Math.floor(run / width) % 2 === 0) widths.push(width);
+  }
+  const head = widths.map((width) => `${q(width)}x`).join(' ');
+  const tail = "a' ".repeat(Math.floor((size - head.length - run) / 3));
+  return `${head} ${tail}${q(run)} b`;
+}
+
+function expectParsedWithinBound(source) {
+  expect(timed(() => parser.parse(source)).elapsed).toBeLessThan(BOUND_MS);
+  expect(timed(() => stripComments(source)).elapsed).toBeLessThan(BOUND_MS);
+}
+
+test('a run inside a body is read as escapes then a closing run', () => {
+  expect(parsesAs("'''a'''")).toBe('(<a>)');
+  expect(parsesAs("'''a''''''b'''")).toBe("(<a'''b>)");
+  expect(parsesAs("''a'''")).toBe("(<a'>)");
+  expect(parsesAs("'a'''")).toBe("(<a'>)");
+  expect(parsesAs(`${q(3)}a${q(9)} b`)).toBe("(<a'''> <b>)");
+  expect(parsesAs(`${q(50)}a${q(100)}b${q(50)}`)).toBe(`(<a${q(50)}b>)`);
+  expect(parsesAs('"""a""b"""')).toBe('(<a""b>)');
+  expect(parsesAs('``a````b``')).toBe('(<a``b>)');
+});
+
+test('a run that never closes the reference leaves it unclosed', () => {
+  // Math.floor(7 / 3) is even: two escaped runs of three and one delimiter.
+  expect(parsesAs(`${q(3)}a${q(7)}`)).toBe(`(<${q(3)}a${q(7)}>)`);
+  expect(parsesAs(`${q(5)}a${q(4)}`)).toBe(`(<${q(5)}a${q(4)}>)`);
+  expect(parsesAs("''a'''''")).toBe("(<> <a'''''>)");
+  expect(parsesAs("''''x a")).toBe('(<> <x> <a>)');
+});
+
+test('a reference can open inside a run', () => {
+  // Comment stripping and the stream parser ask where a reference opened at
+  // any delimiter ends, including one in the middle of a run.
+  const cases = [
+    ["x'''a'''", 1, 8],
+    ["x'''a''", 2, 7],
+    ["x'''a'", 3, 6],
+    ["'''a", 0, null],
+    ["''''a", 0, 4],
+    ['a', 0, null],
+    ["'a'", 3, null],
+  ];
+  for (const [document, start, end] of cases) {
+    expect(quotedReferenceEnd(document, start)).toBe(end);
+    expect(new DelimitedReferences(document).endAt(start)).toBe(end);
+  }
+});
+
+test('a reference that opens with a wide run is read in linear time', () => {
+  const width = Math.floor(SIZE / 4);
+  const source = wideQuoteOverALongRun(SIZE);
+  const { result, elapsed } = timed(() => parser.parse(source));
+  // The odd opening run never closes, so it is a plain reference; the even
+  // run after `a` encloses nothing and is the empty reference.
+  expect(result.length).toBe(1);
+  expect(result[0].values.map((value) => value.id)).toEqual([
+    q(width + 1),
+    'a',
+    '',
+    'x'.repeat(2 * width),
+  ]);
+  expect(elapsed).toBeLessThan(BOUND_MS);
+});
+
+test('wide quote over a long run is parsed within the time bound', () => {
+  expectParsedWithinBound(wideQuoteOverALongRun(SIZE));
+});
+
+test('narrowing unclosed quotes is parsed within the time bound', () => {
+  expectParsedWithinBound(narrowingUnclosedQuotes(SIZE));
+});
+
+test('closed wide quote over quotes is parsed within the time bound', () => {
+  expectParsedWithinBound(closedWideQuoteOverQuotes(SIZE));
+});
+
+test('unclosed widths over an even run is parsed within the time bound', () => {
+  expectParsedWithinBound(unclosedWidthsOverAnEvenRun(SIZE));
+});
+
+test('a stream of wide quotes is read within the time bound', () => {
+  // The second line is what makes the stream ask whether the first is complete.
+  const source = `${closedWideQuoteOverQuotes(SIZE)}\nb`;
+  const links = [];
+  const { elapsed } = timed(() => {
+    const stream = new StreamParser();
+    stream.on('link', (link) => links.push(link));
+    stream.write(source);
+    stream.end();
+  });
+  expect(links.length).toBe(2);
+  expect(elapsed).toBeLessThan(BOUND_MS);
+});