@descent-vtt/spec-graph 0.18.0 → 0.20.0

package/dist/extract.js

@@ -351,13 +351,39 @@ const NEGATION = /(?:^|[^\p{L}\p{N}-])(?:no|not|no-one|nobody|none|never|neither
  * by" are read, and "not only blocked by" and "nothing but blocked by",
  * which state the relation, are not. Only a space stands between, so a
  * mark keeps the word to itself: the option `"never" blocked by` states the
- * relation, as "Not in this release: deferred to" does. A comma is blanked
- * before this is read, as it was, so "If not, blocked by" is cancelled: a
- * miss, kept so that a comma moves no phrase's reach. A contraction is a
- * negation, `isn't` and `doesn’t`, and so is `cannot`. Tested against the
- * text just before the phrase, which ends with the space before it.
+ * relation, as "Not in this release: deferred to" does. A comma does too,
+ * and ends the clause the word belongs to: "If not, blocked by" and "both
+ * or neither, because" state the relation, where with the comma blanked
+ * they were cancelled (ADR-0006, 2026-10-19). A contraction is a negation,
+ * `isn't` and `doesn’t`, and so is `cannot`. Tested against the text just
+ * before the phrase, which ends with the space or the comma before it.
+ *
+ * An aside between the two, closed by a comma of its own, leaves the clause
+ * open: "Not, as it happens, blocked by", "never, ever, blocked by" and "it
+ * is not, as far as anyone knows, blocked by" deny the relation as the words
+ * without the aside do. The aside is anything up to a comma, and may hold
+ * several, so the negation may also end a clause the phrase is not in -
+ * "if not, then, blocked by" - and the relation such a sentence states is
+ * missed, which ADR-0006 prefers to one it denies (2026-10-24). The same few
+ * words may stand after the last comma, "not, in the end, been superseded
+ * by". A run of spaces and commas is one comma in the text this is tested
+ * on, so no aside is empty and `.*` would read as `.+` does; and only
+ * whether the pattern matches is asked, so a lazy `.+?` reads alike too.
+ */
+const NEGATED_BEFORE = /(?:^|[^\p{L}\p{N}-])(?:no|not|no one|no-one|nobody|none|never|neither|nor|nothing|without|cannot|\p{L}+n['’]t)(?: (?:be|been|being|is|are|was|were|yet|longer|ever|even|currently|actually|really|necessarily|always))*(?: |,.+,(?:(?:be|been|being|is|are|was|were|yet|longer|ever|even|currently|actually|really|necessarily|always) )*)$/u;
+/**
+ * A word that points the reader at the reference, and governs it as a
+ * citation from nearer than any phrase before it: "Per tick, see [ADR-7]"
+ * read ADR-7 as a premise, and "blocked by the cache, see [ADR-7]" read it
+ * as what blocks. `see` is no phrase for the vagueness that makes it a
+ * citation, and between a phrase and the reference it says the reference is
+ * where to read more, not what the phrase names (ADR-0006, 2026-10-24). It
+ * is a word as a negation is, between anything but a letter, a digit or a
+ * hyphen, so "the must-see list", "the licensee" and "seen in" point at
+ * nothing. The text it is tested on starts just after a phrase, where no
+ * letter stands, so the word is never its first and needs no start of text.
  */
-const NEGATED_BEFORE = /(?:^|[^\p{L}\p{N}-])(?:no|not|no one|no-one|nobody|none|never|neither|nor|nothing|without|cannot|\p{L}+n['’]t)(?: (?:be|been|being|is|are|was|were|yet|longer|ever|even|currently|actually|really|necessarily|always))* $/u;
+const POINTER = /[^\p{L}\p{N}-]see(?![\p{L}\p{N}-])/u;
 /**
  * A code span that holds nothing but a negation word: `` `none` ``.
  *
@@ -1276,7 +1302,7 @@ function ownerOf(items, offset) {
  * neutral citation.
  */
 export function classifyReference(text, start, end, section) {
-    const before = sentenceBefore(text, start);
+    const { words: before, commas } = sentenceBefore(text, start);
     // Left to right, so the last match within the window is the nearest one - and
     // the nearest governing phrase is the one that governs. `matchAll`, not a
     // loop over `exec`: an empty match leaves `lastIndex` where it began, and
@@ -1292,11 +1318,20 @@ export function classifyReference(text, start, end, section) {
             continue;
         // What sits between the phrase and the reference has to be connective. A
         // negation in there reverses the claim the phrase would otherwise make,
-        // and so does one just before the phrase.
+        // and so does one just before the phrase, where no comma ends its clause
+        // first. A pointer in there governs the reference itself, as a citation.
         if (NEGATION.test(before.slice(end)))
             continue;
-        if (NEGATED_BEFORE.test(before.slice(0, m.index)))
+        if (POINTER.test(before.slice(end)))
+            continue;
+        // A negation before a phrase stands between any phrase before it and the
+        // reference, and denies what follows it: a phrase it leaves before an
+        // aside governs no more than the one it cancels, so "Not, as decided in
+        // [ADR-3], blocked by [ADR-7]" makes ADR-7 a premise of nothing.
+        if (NEGATED_BEFORE.test(commas.slice(0, m.index))) {
+            best = null;
             continue;
+        }
         // Always found: the pattern was compiled from this table's own keys, and a
         // lower-cased search matches them only as written. The check is for types.
         const rule = VERB_LOOKUP.get(phrase);
@@ -1358,17 +1393,26 @@ const STATEMENT_BREAK = /[.?!;]\s|[。？！；]|\n\s*\n|\n\s*[-*+>#]|\|/g;
  * names a word, and `isn't` is one word. Kept, each counts toward the
  * distance a phrase reaches where it stands beside a space, as a curly one
  * did (ADR-0006, 2026-10-18).
+ *
+ * The same text is given a second time with each run of spaces that held a
+ * comma written as the comma: one character either way, so the two line up
+ * and a comma counts toward no phrase's reach, and a negation before a
+ * phrase is read from the second, where a comma keeps the two apart
+ * (ADR-0006, 2026-10-19).
  */
 function sentenceBefore(text, start) {
     const window = text.slice(Math.max(0, start - 160), start);
     let cut = 0;
     for (const m of window.matchAll(STATEMENT_BREAK))
         cut = m.index + m[0].length;
-    return window
+    const statement = window
         .slice(cut)
         .toLowerCase()
-        .replace(/[`*_~()\[\],]/g, ' ')
-        .replace(/\s+/g, ' ');
+        .replace(/[`*_~()\[\]]/g, ' ');
+    return {
+        words: statement.replace(/[\s,]+/g, ' '),
+        commas: statement.replace(/[\s,]+/g, (run) => (run.includes(',') ? ',' : ' ')),
+    };
 }
 /**
  * The statement after a reference, to the first stop, the stops of a sentence