eyeling 1.25.2 → 1.25.4

package/eyeling.js

@@ -4965,12 +4965,14 @@ function main() {
     outTriples = res.queryTriples;
     outDerived = res.queryDerived;
   } else {
+    const skipDerivedCollection = mayAutoRenderOutputStrings && !engine.getProofCommentsEnabled();
     derived = engine.forwardChain(facts, frules, brules, null, {
       captureExplanations: engine.getProofCommentsEnabled(),
+      collectDerived: !skipDerivedCollection,
       prefixes,
     });
     outDerived = derived;
-    outTriples = derived.map((df) => df.fact);
+    outTriples = skipDerivedCollection ? [] : derived.map((df) => df.fact);
   }
 
   const renderedOutputTriples = hasQueries ? outTriples : facts;
@@ -6521,6 +6523,12 @@ function alphaEqGraphTriples(xs, ys, opts) {
 //   - __byPred: Map<predicateId, number[]>   (indices into facts array)
 //   - __byPS:   Map<predicateId, Map<subjectId, number[]>>
 //   - __byPO:   Map<predicateId, Map<objectId, number[]>>
+//   - __byPNonFastS / __byPNonFastO: Map<predicateId, number[]>
+//       IRI-predicate facts whose subject/object cannot be indexed by fast key.
+//       These are the fallback clauses for a constrained subject/object, just
+//       like a Prolog clause index keeps variable-headed clauses as fallback.
+//   - __varPred* indexes: facts whose predicate is a Var.  Only these non-IRI
+//       predicate facts can unify with a ground IRI predicate goal.
 //   - __keySet: Set<"S\tP\tO"> for Iri/Literal/Blank-only triples (fast dup check)
 //
 // Backward rules:
@@ -6536,6 +6544,8 @@ const __compoundKeyToTid = new Map();
 // Use a negative id space so we never collide with __tid (which is positive).
 let __nextCompoundTid = -1;
 
+const EMPTY_FACT_INDEX_BUCKET = Object.freeze([]);
+
 function __internCompoundTid(key) {
   const hit = __compoundKeyToTid.get(key);
   if (hit !== undefined) return hit;
@@ -6587,6 +6597,71 @@ function termFastKey(t) {
   return null;
 }
 
+function encodeLookupKeyPart(k) {
+  if (typeof k === 'number') return 'T' + k;
+  const s = String(k);
+  return 'K' + s.length + ':' + s;
+}
+
+function literalLookupKey(t) {
+  const boolInfo = parseBooleanLiteralInfo(t);
+  if (boolInfo) return '\u0000B' + (boolInfo.value ? '1' : '0');
+
+  const numInfo = parseNumericLiteralInfo(t);
+  if (numInfo) {
+    if (numInfo.kind === 'bigint') return '\u0000N' + numInfo.dt + '\u0000' + numInfo.value.toString();
+
+    const n = numInfo.value;
+    // Normal unification intentionally does not make NaN value-equal to NaN;
+    // only identical lexical literals match through the ordinary __tid path.
+    if (!Number.isNaN(n)) return '\u0000N' + numInfo.dt + '\u0000' + String(n);
+  }
+
+  // Covers exact literals plus plain string / xsd:string canonicalization, which
+  // Literal construction already normalizes into a shared __tid.
+  return termFastKey(t);
+}
+
+function termLookupKey(t) {
+  // Lookup keys summarize the equality accepted by ordinary unifyTerm(), not
+  // merely object identity.  This keeps literal-index pruning complete for
+  // value-equivalent booleans/numerics such as true/"1"^^xsd:boolean and
+  // 1.0/1.00, while preserving exact fast ids for IRIs, blanks, and strings.
+  if (t instanceof Iri) {
+    if (t.value === RDF_NIL_IRI) return '\u0000L0';
+    return t.__tid;
+  }
+  if (t instanceof Blank) return t.__tid;
+  if (t instanceof Literal) return literalLookupKey(t);
+
+  if (t instanceof ListTerm) {
+    const cached = t.__lookupKey;
+    if (cached !== undefined) return cached === false ? null : cached;
+
+    const xs = t.elems;
+    if (xs.length === 0) {
+      Object.defineProperty(t, '__lookupKey', { value: '\u0000L0', enumerable: false });
+      return '\u0000L0';
+    }
+
+    const parts = new Array(xs.length);
+    for (let i = 0; i < xs.length; i++) {
+      const k = termLookupKey(xs[i]);
+      if (k === null) {
+        Object.defineProperty(t, '__lookupKey', { value: false, enumerable: false });
+        return null;
+      }
+      parts[i] = encodeLookupKeyPart(k);
+    }
+
+    const key = '\u0000L' + xs.length + '\u0001' + parts.join('\u0001');
+    Object.defineProperty(t, '__lookupKey', { value: key, enumerable: false });
+    return key;
+  }
+
+  return null;
+}
+
 function tripleFastKey(tr) {
   const ks = termFastKey(tr.s);
   const kp = termFastKey(tr.p);
@@ -6600,9 +6675,13 @@ function ensureFactIndexes(facts) {
     facts.__byPred &&
     facts.__byPS &&
     facts.__byPO &&
-    facts.__wildPred &&
-    facts.__wildPS &&
-    facts.__wildPO &&
+    facts.__byPNonFastS &&
+    facts.__byPNonFastO &&
+    facts.__varPred &&
+    facts.__varPredPS &&
+    facts.__varPredPO &&
+    facts.__varPredNonFastS &&
+    facts.__varPredNonFastO &&
     facts.__keySet
   )
     return;
@@ -6622,21 +6701,41 @@ function ensureFactIndexes(facts) {
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPred', {
+  Object.defineProperty(facts, '__byPNonFastS', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__byPNonFastO', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPred', {
     value: [],
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPS', {
+  Object.defineProperty(facts, '__varPredPS', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPO', {
+  Object.defineProperty(facts, '__varPredPO', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
+  Object.defineProperty(facts, '__varPredNonFastS', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPredNonFastO', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(facts, '__keySet', {
     value: new Set(),
     enumerable: false,
@@ -6677,16 +6776,53 @@ function cloneFactIndexesForSnapshot(src, dest) {
   Object.defineProperty(dest, '__byPred', { value: cloneArrayMap(src.__byPred), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPS', { value: cloneNestedArrayMap(src.__byPS), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPO', { value: cloneNestedArrayMap(src.__byPO), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPred', { value: src.__wildPred.slice(), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPS', { value: cloneArrayMap(src.__wildPS), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPO', { value: cloneArrayMap(src.__wildPO), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__byPNonFastS', {
+    value: cloneArrayMap(src.__byPNonFastS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__byPNonFastO', {
+    value: cloneArrayMap(src.__byPNonFastO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPred', { value: src.__varPred.slice(), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__varPredPS', {
+    value: cloneArrayMap(src.__varPredPS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredPO', {
+    value: cloneArrayMap(src.__varPredPO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastS', {
+    value: src.__varPredNonFastS.slice(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastO', {
+    value: src.__varPredNonFastO.slice(),
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(dest, '__keySet', { value: new Set(src.__keySet), enumerable: false, writable: true });
   Object.defineProperty(dest, '__keySetComplete', { value: !!src.__keySetComplete, enumerable: false, writable: true });
 }
 
+function addToIndexArrayMap(map, key, value) {
+  let bucket = map.get(key);
+  if (!bucket) {
+    bucket = [];
+    map.set(key, bucket);
+  }
+  bucket.push(value);
+}
+
 function indexFact(facts, tr, idx, addKeySet = true) {
-  const sk = termFastKey(tr.s);
-  const ok = termFastKey(tr.o);
+  const sk = termLookupKey(tr.s);
+  const ok = termLookupKey(tr.o);
   let pkForKey = null;
 
   if (tr.p instanceof Iri) {
@@ -6707,12 +6843,9 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         ps = new Map();
         facts.__byPS.set(pk, ps);
       }
-      let psb = ps.get(sk);
-      if (!psb) {
-        psb = [];
-        ps.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(ps, sk, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastS, pk, idx);
     }
 
     if (ok !== null) {
@@ -6721,32 +6854,23 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         po = new Map();
         facts.__byPO.set(pk, po);
       }
-      let pob = po.get(ok);
-      if (!pob) {
-        pob = [];
-        po.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(po, ok, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastO, pk, idx);
     }
-  } else {
-    facts.__wildPred.push(idx);
+  } else if (tr.p instanceof Var) {
+    facts.__varPred.push(idx);
 
     if (sk !== null) {
-      let psb = facts.__wildPS.get(sk);
-      if (!psb) {
-        psb = [];
-        facts.__wildPS.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(facts.__varPredPS, sk, idx);
+    } else {
+      facts.__varPredNonFastS.push(idx);
     }
 
     if (ok !== null) {
-      let pob = facts.__wildPO.get(ok);
-      if (!pob) {
-        pob = [];
-        facts.__wildPO.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(facts.__varPredPO, ok, idx);
+    } else {
+      facts.__varPredNonFastO.push(idx);
     }
   }
 
@@ -6756,55 +6880,86 @@ function indexFact(facts, tr, idx, addKeySet = true) {
   }
 }
 
+function mergeIndexBuckets(primary, fallback) {
+  const a = primary && primary.length ? primary : null;
+  const b = fallback && fallback.length ? fallback : null;
+  if (!a && !b) return EMPTY_FACT_INDEX_BUCKET;
+  if (!a) return b;
+  if (!b) return a;
+  const out = new Array(a.length + b.length);
+  for (let i = 0; i < a.length; i++) out[i] = a[i];
+  for (let i = 0; i < b.length; i++) out[a.length + i] = b[i];
+  return out;
+}
+
+function selectPositionIndexedCandidates(all, exactByS, fallbackS, sk, exactByO, fallbackO, ok) {
+  if (sk === null && ok === null) return all && all.length ? all : EMPTY_FACT_INDEX_BUCKET;
+
+  let sBucket = null;
+  if (sk !== null) sBucket = mergeIndexBuckets(exactByS || null, fallbackS || null);
+
+  let oBucket = null;
+  if (ok !== null) oBucket = mergeIndexBuckets(exactByO || null, fallbackO || null);
+
+  if (sk !== null && ok !== null) return sBucket.length <= oBucket.length ? sBucket : oBucket;
+  return sk !== null ? sBucket : oBucket;
+}
+
 function candidateFacts(facts, goal) {
   ensureFactIndexes(facts);
 
   if (goal.p instanceof Iri) {
     const pk = goal.p.__tid;
 
-    const sk = termFastKey(goal.s);
-    const ok = termFastKey(goal.o);
+    const sk = termLookupKey(goal.s);
+    const ok = termLookupKey(goal.o);
 
-    /** @type {number[] | null} */
     let byPS = null;
     if (sk !== null) {
       const ps = facts.__byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
     }
+    const byPNonFastS = sk !== null ? facts.__byPNonFastS.get(pk) || null : null;
 
-    /** @type {number[] | null} */
     let byPO = null;
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
     }
+    const byPNonFastO = ok !== null ? facts.__byPNonFastO.get(pk) || null : null;
 
-    let exact = null;
-    if (byPS && byPO) exact = byPS.length <= byPO.length ? byPS : byPO;
-    else if (byPS) exact = byPS;
-    else if (byPO) exact = byPO;
-    else exact = facts.__byPred.get(pk) || null;
+    const exact = selectPositionIndexedCandidates(
+      facts.__byPred.get(pk) || null,
+      byPS,
+      byPNonFastS,
+      sk,
+      byPO,
+      byPNonFastO,
+      ok,
+    );
 
-    /** @type {number[] | null} */
-    let wildPS = null;
-    if (sk !== null) wildPS = facts.__wildPS.get(sk) || null;
+    let varPredPS = null;
+    if (sk !== null) varPredPS = facts.__varPredPS.get(sk) || null;
 
-    /** @type {number[] | null} */
-    let wildPO = null;
-    if (ok !== null) wildPO = facts.__wildPO.get(ok) || null;
+    let varPredPO = null;
+    if (ok !== null) varPredPO = facts.__varPredPO.get(ok) || null;
 
-    let wild = null;
-    if (wildPS && wildPO) wild = wildPS.length <= wildPO.length ? wildPS : wildPO;
-    else if (wildPS) wild = wildPS;
-    else if (wildPO) wild = wildPO;
-    else wild = facts.__wildPred.length ? facts.__wildPred : null;
+    const wild = selectPositionIndexedCandidates(
+      facts.__varPred,
+      varPredPS,
+      sk !== null ? facts.__varPredNonFastS : null,
+      sk,
+      varPredPO,
+      ok !== null ? facts.__varPredNonFastO : null,
+      ok,
+    );
 
     return {
-      exact: exact || null,
-      wild: wild || null,
-      exactLen: exact ? exact.length : 0,
-      wildLen: wild ? wild.length : 0,
-      totalLen: (exact ? exact.length : 0) + (wild ? wild.length : 0),
+      exact,
+      wild,
+      exactLen: exact.length,
+      wildLen: wild.length,
+      totalLen: exact.length + wild.length,
     };
   }
 
@@ -6822,20 +6977,28 @@ function hasFactIndexed(facts, tr) {
 
   if (tr.p instanceof Iri) {
     const pk = tr.p.__tid;
+    const sk = termLookupKey(tr.s);
+    let best = null;
+
+    if (sk !== null) {
+      const ps = facts.__byPS.get(pk);
+      if (!ps) return false;
+      const psb = ps.get(sk);
+      if (!psb || psb.length === 0) return false;
+      best = psb;
+    }
 
-    const ok = termFastKey(tr.o);
+    const ok = termLookupKey(tr.o);
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
-      if (po) {
-        const pob = po.get(ok) || [];
-        // Facts are all in the same graph. Different blank node labels represent
-        // different existentials unless explicitly connected. Do NOT treat
-        // triples as duplicates modulo blank renaming, or you'll incorrectly
-        // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-        return pob.some((i) => triplesEqual(facts[i], tr));
-      }
+      if (!po) return false;
+      const pob = po.get(ok);
+      if (!pob || pob.length === 0) return false;
+      if (!best || pob.length < best.length) best = pob;
     }
 
+    if (best) return best.some((i) => triplesEqual(facts[i], tr));
+
     const pb = facts.__byPred.get(pk) || [];
     return pb.some((i) => triplesEqual(facts[i], tr));
   }
@@ -6944,11 +7107,25 @@ function mergeSinglePremiseAgendaBuckets() {
   return out;
 }
 
+function termContainsVarForAgenda(t) {
+  if (t instanceof Var) return true;
+  if (t instanceof ListTerm) return t.elems.some(termContainsVarForAgenda);
+  if (t instanceof OpenListTerm) return true;
+  if (t instanceof GraphTerm)
+    return t.triples.some(
+      (tr) =>
+        termContainsVarForAgenda(tr.s) || termContainsVarForAgenda(tr.p) || termContainsVarForAgenda(tr.o),
+    );
+  return false;
+}
+
 function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
   const index = {
     byPred: new Map(),
+    byPredAll: new Map(),
     byPS: new Map(),
     byPO: new Map(),
+    allIriPred: [],
     wildPred: [],
     wildPS: new Map(),
     wildPO: new Map(),
@@ -6970,8 +7147,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     if (!isSinglePremiseAgendaRuleSafe(r, backRules)) continue;
 
     const goal = r.premise[0];
-    const goalSKey = termFastKey(goal.s);
-    const goalOKey = termFastKey(goal.o);
+    const goalSKey = termLookupKey(goal.s);
+    const goalOKey = termLookupKey(goal.o);
     const fastSubjectVar = goal.p instanceof Iri && goal.s instanceof Var && goalOKey !== null ? goal.s.name : null;
     const fastObjectVar = goal.p instanceof Iri && goal.o instanceof Var && goalSKey !== null ? goal.o.name : null;
     const entry = {
@@ -6990,6 +7167,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     index.size += 1;
 
     if (entry.goalPredTid !== null) {
+      addToMapArray(index.byPredAll, entry.goalPredTid, entry);
+      index.allIriPred.push(entry);
       if (entry.goalSKey === null && entry.goalOKey === null) addToMapArray(index.byPred, entry.goalPredTid, entry);
       if (entry.goalSKey !== null) {
         let ps = index.byPS.get(entry.goalPredTid);
@@ -7020,25 +7199,37 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
 function getSinglePremiseAgendaCandidates(index, fact) {
   if (!index || index.size === 0) return null;
 
-  const sk = termFastKey(fact.s);
-  const ok = termFastKey(fact.o);
+  const sk = termLookupKey(fact.s);
+  const ok = termLookupKey(fact.o);
 
   let exact = null;
   if (fact.p instanceof Iri) {
     const pk = fact.p.__tid;
-    const byPred = index.byPred.get(pk) || null;
-    let byPS = null;
-    if (sk !== null) {
+    if ((sk === null && termContainsVarForAgenda(fact.s)) || (ok === null && termContainsVarForAgenda(fact.o))) {
+      // A fact with a variable-bearing subject/object (most importantly a
+      // top-level variable fact such as `?S :p ?O.`) can match rules whose
+      // premise is fixed in that position. The ordinary `(p,s)` / `(p,o)` lookup
+      // would miss those rules, so fall back to all agenda-indexed rules for
+      // this predicate. Do not do this merely for non-fast quoted formulas:
+      // they are not wildcards, and broad fallback would over-fire rules that
+      // rely on protected blank-node/formula unification semantics.
+      exact = index.byPredAll.get(pk) || null;
+    } else {
+      const byPred = index.byPred.get(pk) || null;
+      let byPS = null;
       const ps = index.byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
-    }
-    let byPO = null;
-    if (ok !== null) {
+      let byPO = null;
       const po = index.byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
-    }
 
-    exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+      exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+    }
+  } else if (fact.p instanceof Var) {
+    // A variable-predicate fact can match any IRI-predicate agenda rule.
+    // This is deliberately broad and relies on final unification below; such
+    // facts are uncommon and correctness matters more than over-indexing them.
+    exact = index.allIriPred.length ? index.allIriPred : null;
   }
 
   const wildPred = index.wildPred.length ? index.wildPred : null;
@@ -8388,6 +8579,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     __attachGoalTable(backRules, goalTable);
 
     const captureExplanations = !(opts && opts.captureExplanations === false);
+    const collectDerived = !(opts && opts.collectDerived === false);
+    const hasDerivedCallback = typeof onDerived === 'function';
     const derivedForward = [];
     const varGen = [0];
     const skCounter = [0];
@@ -8566,8 +8759,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           if (!hasFactIndexed(facts, instantiated)) {
             pushFactIndexed(facts, instantiated);
             const df = makeDerivedRecord(instantiated, r, getInstantiatedPremises(), s, captureExplanations);
-            derivedForward.push(df);
-            if (typeof onDerived === 'function') onDerived(df);
+            if (collectDerived) derivedForward.push(df);
+            if (hasDerivedCallback) onDerived(df);
             changedHere = true;
           }
 
@@ -8630,8 +8823,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
         pushFactIndexed(facts, inst);
         const df = makeDerivedRecord(inst, r, getInstantiatedPremises(), s, captureExplanations);
-        derivedForward.push(df);
-        if (typeof onDerived === 'function') onDerived(df);
+        if (collectDerived) derivedForward.push(df);
+        if (hasDerivedCallback) onDerived(df);
 
         changedHere = true;
       }
@@ -9643,15 +9836,6 @@ function isIdentChar(c) {
   return c === ':' || isPnChars(c);
 }
 
-function canContinueAfterDot(next) {
-  // PN_LOCAL allows '.' but it cannot appear at the end.
-  // We include '.' only if it is followed by something that could continue a name.
-  if (next === null) return false;
-  if (isIdentChar(next)) return true;
-  if (next === '%' || next === '\\') return true;
-  return false;
-}
-
 function isForbiddenNoncharacterCodePoint(cp) {
   return (cp & 0xffff) === 0xfffe || (cp & 0xffff) === 0xffff;
 }
@@ -10727,7 +10911,9 @@ function lex(inputText, opts = {}) {
   // Avoid copying large ASCII/BMP inputs into an Array.  Array.from() is
   // only needed when the text contains surrogate pairs and we want the old
   // code-point iteration behavior for non-BMP characters.
-  const chars = /[\uD800-\uDFFF]/.test(inputText) ? Array.from(inputText) : inputText;
+  const hasSurrogates = /[\uD800-\uDFFF]/.test(inputText);
+  const inputMayContainInvalidStringChar = hasSurrogates || /[\u0000\uFFFE\uFFFF]/.test(inputText);
+  const chars = hasSurrogates ? Array.from(inputText) : inputText;
   const n = chars.length;
   let i = 0;
   const tokens = [];
@@ -10762,14 +10948,47 @@ function lex(inputText, opts = {}) {
       // Hard stops: delimiters cannot appear unescaped inside PNAME tokens.
       if (cc === '{' || cc === '}' || cc === '(' || cc === ')' || cc === '[' || cc === ']' || cc === ';' || cc === ',') break;
 
-      // Dot is allowed inside PN_LOCAL, but not at the end.
-      if (cc === '.') {
-        if (!canContinueAfterDot(peek(1))) break;
-        if (out !== null) out.push('.');
+      const code = cc.charCodeAt(0);
+
+      // Common ASCII QName/identifier characters. Keep this branch inline so
+      // ordinary N3 files do not call through the full Unicode PN_CHARS predicate
+      // for every character.
+      if (
+        code === 58 || // ':'
+        code === 95 || // '_'
+        code === 45 || // '-'
+        (code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122)
+      ) {
+        if (out !== null) out.push(cc);
         i++;
         continue;
       }
 
+      // Dot is allowed inside PN_LOCAL, but not at the end.
+      if (cc === '.') {
+        const next = peek(1);
+        if (next === null) break;
+        const ncode = next.charCodeAt(0);
+        if (
+          next === '%' ||
+          next === '\\' ||
+          ncode === 58 ||
+          ncode === 95 ||
+          ncode === 45 ||
+          (ncode >= 48 && ncode <= 57) ||
+          (ncode >= 65 && ncode <= 90) ||
+          (ncode >= 97 && ncode <= 122) ||
+          isIdentChar(next)
+        ) {
+          if (out !== null) out.push('.');
+          i++;
+          continue;
+        }
+        break;
+      }
+
       // Percent escape: %HH
       if (cc === '%') {
         const h1 = peek(1);
@@ -11017,7 +11236,7 @@ function lex(inputText, opts = {}) {
       }
       const rawContent = sChars === null ? sliceChars(contentStart, closed ? i - 1 : i) : sChars.join('');
       const decoded = sChars === null ? rawContent : decodeN3StringEscapes(rawContent, start);
-      assertValidStringLiteralValue(decoded, start);
+      if (sChars !== null || inputMayContainInvalidStringChar) assertValidStringLiteralValue(decoded, start);
       const s = JSON.stringify(decoded); // canonical short quoted form
       tokens.push(new Token('Literal', s, start));
       continue;
@@ -11107,7 +11326,7 @@ function lex(inputText, opts = {}) {
       }
       const rawContent = sChars === null ? sliceChars(contentStart, closed ? i - 1 : i) : sChars.join('');
       const decoded = sChars === null ? rawContent : decodeN3StringEscapes(rawContent, start);
-      assertValidStringLiteralValue(decoded, start);
+      if (sChars !== null || inputMayContainInvalidStringChar) assertValidStringLiteralValue(decoded, start);
       const s = JSON.stringify(decoded); // canonical short quoted form
       tokens.push(new Token('Literal', s, start));
       continue;
@@ -12217,15 +12436,21 @@ class Parser {
 
     while (true) {
       const { verb, invert } = this.parseStatementVerb();
-      const objects = this.parseObjectList();
 
-      // If VERB or OBJECTS contained paths, their helper triples must come
-      // before the triples that consume the path results (Easter depends on this).
-      this.flushPendingTriples(out);
+      while (true) {
+        const o = this.parseTerm();
+        const postTriples = this.pendingTriplesAfter;
+        this.pendingTriplesAfter = [];
+
+        // If VERB or OBJECT contained paths, their helper triples must come
+        // before the triple that consumes the path result (Easter depends on this).
+        this.flushPendingTriples(out);
 
-      for (const { term: o, postTriples } of objects) {
         out.push(new Triple(invert ? o : subject, verb, invert ? subject : o));
-        if (postTriples && postTriples.length) out.push(...postTriples);
+        if (postTriples.length) out.push(...postTriples);
+
+        if (this.peek().typ !== 'Comma') break;
+        this.next();
       }
 
       if (this.peek().typ === 'Semicolon') {
@@ -12239,27 +12464,6 @@ class Parser {
     return out;
   }
 
-  parseObjectList() {
-    // Capture any trailing property-list triples produced while parsing each
-    // object term so we can emit them *after* the triple that references the
-    // term. (See pendingTriplesAfter in the constructor.)
-
-    const objs = [];
-    const readObj = () => {
-      const o = this.parseTerm();
-      const post = this.pendingTriplesAfter;
-      this.pendingTriplesAfter = [];
-      objs.push({ term: o, postTriples: post });
-    };
-
-    readObj();
-    while (this.peek().typ === 'Comma') {
-      this.next();
-      readObj();
-    }
-    return objs;
-  }
-
   makeRule(left, right, isForward) {
     let premiseTerm, conclTerm;