eyeling 1.25.4 → 1.26.0

package/lib/explain.js

@@ -6,7 +6,7 @@
  */
 'use strict';
 
-const { LOG_NS, Literal, Iri, Blank, Var, varsInRule, literalParts } = require('./prelude');
+const { LOG_NS, Literal, Iri, Blank, Var, GraphTerm, varsInRule, literalParts, PrefixEnv } = require('./prelude');
 
 const { termToN3, tripleToN3 } = require('./printing');
 const { parseNumericLiteralInfo, termToJsString } = require('./builtins');
@@ -14,6 +14,8 @@ const { parseNumericLiteralInfo, termToJsString } = require('./builtins');
 function makeExplain(deps) {
   const applySubstTerm = deps.applySubstTerm;
   const skolemKeyFromTerm = deps.skolemKeyFromTerm;
+  const isBuiltinPred = typeof deps.isBuiltinPred === 'function' ? deps.isBuiltinPred : () => false;
+  const findBackwardProofForGoal = typeof deps.findBackwardProofForGoal === 'function' ? deps.findBackwardProofForGoal : null;
 
   function printExplanation(df, prefixes) {
     console.log('# ----------------------------------------------------------------------');
@@ -111,6 +113,282 @@ function makeExplain(deps) {
     console.log('# ----------------------------------------------------------------------\n');
   }
 
+
+  const PE_NS = 'https://eyereasoner.github.io/pe#';
+
+  function n3String(value) {
+    return JSON.stringify(String(value));
+  }
+
+  function lineIndent(text, prefix) {
+    return String(text)
+      .split(/\r?\n/)
+      .map((line) => (line.length ? prefix + line : line))
+      .join('\n');
+  }
+
+  function graphForTriple(tr, prefixes) {
+    const body = tripleToN3(tr, prefixes).trimEnd();
+    if (!body.includes('\n')) return `{ ${body} }`;
+    return `{
+${lineIndent(body, '    ')}
+}`;
+  }
+
+
+  function clonePrefixEnvWithProofVocabulary(prefixes) {
+    const map = { ...(prefixes && prefixes.map ? prefixes.map : {}) };
+    if (!map.pe) map.pe = PE_NS;
+    return new PrefixEnv(map, (prefixes && prefixes.baseIri) || '');
+  }
+
+  function proofTripleKey(tr) {
+    if (!tr) return '';
+    return `${skolemKeyFromTerm(tr.s)}\t${skolemKeyFromTerm(tr.p)}\t${skolemKeyFromTerm(tr.o)}`;
+  }
+
+  function sourceLabelForProof(source) {
+    if (!source || typeof source.label !== 'string' || !source.label) return '<unknown>';
+    // Keep proof output stable when the CLI is invoked with paths such as examples/foo.n3.
+    return source.label.replace(/\\/g, '/').split('/').pop() || source.label;
+  }
+
+  function byBlankNode(kind, source) {
+    const src = source || {};
+    const props = [`pe:${kind} ${n3String(sourceLabelForProof(src))}`];
+    if (Number.isInteger(src.line) && src.line > 0) props.push(`pe:line ${src.line}`);
+    return `[ ${props.join('; ')} ]`;
+  }
+
+  function renderBindingList(df, prefixes) {
+    if (!df || !df.rule || !df.subst) return '';
+    const ruleVars = varsInRule(df.rule);
+    const visibleNames = Object.keys(df.subst)
+      .filter((name) => ruleVars.has(name))
+      .sort();
+    if (!visibleNames.length) return '';
+    const sourceNames = (df.rule && df.rule.__proofVarSourceNames) || null;
+    return visibleNames
+      .map((name) => {
+        const value = applySubstTerm(new Var(name), df.subst);
+        const displayName = sourceNames && sourceNames[name] ? sourceNames[name] : name;
+        return `[ pe:var ${n3String(displayName)}; pe:value ${termToN3(value, prefixes)} ]`;
+      })
+      .join(', ');
+  }
+
+  function proofSourceKey(source) {
+    if (!source) return '';
+    const label = typeof source.label === 'string' ? source.label : '';
+    const line = Number.isInteger(source.line) ? source.line : 0;
+    return `${label}\t${line}`;
+  }
+
+  function proofEntryKey(kind, fact, source, extra) {
+    return `${kind}\t${proofTripleKey(fact)}\t${proofSourceKey(source)}\t${extra || ''}`;
+  }
+
+  function ruleEntryKey(df) {
+    const rule = df && df.rule;
+    const premises = (df && df.premises ? df.premises : []).map((prem) => proofTripleKey(prem)).join('\t');
+    return proofEntryKey('rule', df && df.fact, rule && rule.__source, premises);
+  }
+
+  function collectProofEntries(rootDf, derivedByKey, baseFactByKey, resolveBackwardProof) {
+    const entries = [];
+    const seen = new Set();
+
+    function entryKeyForProof(proof, fallbackTriple) {
+      if (!proof) return proofEntryKey('fact', fallbackTriple, null);
+      if (proof.kind === 'rule') return ruleEntryKey(proof.df);
+      if (proof.kind === 'builtin') return proofEntryKey('builtin', proof.fact || fallbackTriple, null);
+      return proofEntryKey('fact', proof.fact || fallbackTriple, proof.source);
+    }
+
+    function visitProofNode(proof, fallbackTriple) {
+      if (!proof) {
+        visitFactTriple(fallbackTriple);
+        return;
+      }
+      const key = entryKeyForProof(proof, fallbackTriple);
+      if (!key || seen.has(key)) return;
+      if (proof.kind === 'rule' && proof.df) {
+        visitDerivedFact(proof.df, proof.children || null);
+        return;
+      }
+      seen.add(key);
+      if (proof.kind === 'builtin') {
+        entries.push({
+          kind: 'builtin',
+          fact: proof.fact || fallbackTriple,
+          builtin: proof.builtin || (proof.fact && proof.fact.p),
+        });
+      } else {
+        entries.push({ kind: 'fact', fact: proof.fact || fallbackTriple, source: proof.source });
+      }
+    }
+
+    function visitFactTriple(tr) {
+      const tripleKey = proofTripleKey(tr);
+      if (!tripleKey) return;
+      const df = derivedByKey.get(tripleKey);
+      if (df) {
+        visitDerivedFact(df);
+        return;
+      }
+      const base = baseFactByKey.get(tripleKey) || null;
+      if (base) {
+        const key = proofEntryKey('fact', base, base.__source);
+        if (seen.has(key)) return;
+        seen.add(key);
+        entries.push({ kind: 'fact', fact: base, source: base.__source });
+        return;
+      }
+      if (tr && isBuiltinPred(tr.p)) {
+        const key = proofEntryKey('builtin', tr, null);
+        if (seen.has(key)) return;
+        seen.add(key);
+        entries.push({ kind: 'builtin', fact: tr, builtin: tr.p });
+        return;
+      }
+      if (resolveBackwardProof) {
+        const proof = resolveBackwardProof(tr);
+        if (proof) {
+          visitProofNode(proof, tr);
+          return;
+        }
+      }
+      const key = proofEntryKey('fact', tr, null);
+      if (seen.has(key)) return;
+      seen.add(key);
+      entries.push({ kind: 'fact', fact: tr, source: null });
+    }
+
+    function visitDerivedFact(df, children) {
+      const key = ruleEntryKey(df);
+      if (!key || seen.has(key)) return;
+      seen.add(key);
+      entries.push({ kind: 'rule', df });
+
+      if (Array.isArray(children) && children.length) {
+        for (const child of children) visitProofNode(child);
+        return;
+      }
+      for (const prem of df.premises || []) visitFactTriple(prem);
+    }
+
+    visitDerivedFact(rootDf);
+    return entries;
+  }
+
+  function collectProofOutputTriples(outputDerived) {
+    const out = [];
+    const seen = new Set();
+    for (const df of outputDerived || []) {
+      if (!df || !df.fact) continue;
+      const key = proofTripleKey(df.fact);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(df.fact);
+    }
+    return out;
+  }
+
+  function renderProofEntry(entry, prefixes) {
+    if (!entry) return '';
+    if (entry.kind === 'fact') {
+      return `  ${graphForTriple(entry.fact, prefixes)}\n    pe:by ${byBlankNode('fact', entry.source)}.`;
+    }
+    if (entry.kind === 'builtin') {
+      return `  ${graphForTriple(entry.fact, prefixes)}\n    pe:by [ pe:builtin ${termToN3(entry.builtin, prefixes)} ].`;
+    }
+
+    const df = entry.df;
+    const props = [`pe:by ${byBlankNode('rule', df.rule && df.rule.__source)}`];
+    const bindings = renderBindingList(df, prefixes);
+    if (bindings) props.push(`pe:binding ${bindings}`);
+    if (df.premises && df.premises.length) {
+      props.push(`pe:uses ${df.premises.map((prem) => graphForTriple(prem, prefixes)).join(', ')}`);
+    }
+
+    let out = `  ${graphForTriple(df.fact, prefixes)}\n`;
+    for (let i = 0; i < props.length; i++) {
+      out += `    ${props[i]}${i === props.length - 1 ? '.' : ';'}\n`;
+    }
+    return out.trimEnd();
+  }
+
+  function renderProofBlock(rootDf, derivedByKey, baseFactByKey, prefixes, resolveBackwardProof) {
+    const entries = collectProofEntries(rootDf, derivedByKey, baseFactByKey, resolveBackwardProof);
+    const rootGraph = graphForTriple(rootDf.fact, prefixes);
+    const proofBody = entries.map((entry) => renderProofEntry(entry, prefixes)).join('\n\n');
+    const proofGraph = proofBody ? `{
+${proofBody}
+}` : '{}';
+    return `${rootGraph} pe:why ${proofGraph}.`;
+  }
+
+  function renderProofDocument(outputDerived, allDerived, baseFacts, prefixes, backRules) {
+    const selectedDerived = Array.isArray(outputDerived) ? outputDerived.filter((df) => df && df.fact) : [];
+    if (!selectedDerived.length) return '';
+
+    const proofPrefixes = clonePrefixEnvWithProofVocabulary(prefixes);
+    const derivedByKey = new Map();
+    for (const df of allDerived || []) {
+      if (!df || !df.fact) continue;
+      const key = proofTripleKey(df.fact);
+      if (!derivedByKey.has(key)) derivedByKey.set(key, df);
+    }
+    // Do not insert query-wrapper output facts here: those wrappers often derive
+    // the same triple they use, and would hide the underlying fact/rule proof.
+
+    const baseFactByKey = new Map();
+    for (const tr of baseFacts || []) {
+      if (!tr) continue;
+      const key = proofTripleKey(tr);
+      if (!baseFactByKey.has(key)) baseFactByKey.set(key, tr);
+    }
+
+    const resolveBackwardProof = findBackwardProofForGoal
+      ? (tr) => findBackwardProofForGoal(tr, baseFacts || [], backRules || [], { maxDepth: 64 })
+      : null;
+
+    const outputTriples = collectProofOutputTriples(selectedDerived);
+    const proofRelationTriples = [];
+    for (const df of selectedDerived) {
+      proofRelationTriples.push({ s: new GraphTerm([df.fact]), p: new Iri(PE_NS + 'why'), o: new GraphTerm([]) });
+      for (const entry of collectProofEntries(df, derivedByKey, baseFactByKey, resolveBackwardProof)) {
+        const fact = entry.kind === 'rule' ? entry.df.fact : entry.fact;
+        const byObject = entry.kind === 'builtin' && entry.builtin ? entry.builtin : new Iri(PE_NS + 'source');
+        proofRelationTriples.push({ s: new GraphTerm([fact]), p: new Iri(PE_NS + 'by'), o: byObject });
+        if (entry.kind === 'rule') {
+          for (const prem of entry.df.premises || []) proofRelationTriples.push({ s: new GraphTerm([fact]), p: new Iri(PE_NS + 'uses'), o: new GraphTerm([prem]) });
+        }
+      }
+    }
+
+    const usedPrefixes = proofPrefixes.prefixesUsedForOutput(outputTriples.concat(proofRelationTriples));
+    if (!usedPrefixes.some(([pfx]) => pfx === 'pe')) usedPrefixes.push(['pe', PE_NS]);
+    usedPrefixes.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+
+    const parts = [];
+    for (const [pfx, base] of usedPrefixes) {
+      if (!base) continue;
+      if (pfx === '') parts.push(`@prefix : <${base}> .`);
+      else parts.push(`@prefix ${pfx}: <${base}> .`);
+    }
+    if (parts.length) parts.push('');
+
+    parts.push(...outputTriples.map((tr) => tripleToN3(tr, proofPrefixes)));
+    parts.push('');
+    for (let i = 0; i < selectedDerived.length; i++) {
+      if (i > 0) parts.push('');
+      parts.push(renderProofBlock(selectedDerived[i], derivedByKey, baseFactByKey, proofPrefixes, resolveBackwardProof));
+    }
+
+    return parts.join('\n').replace(/[ \t]+$/gm, '').replace(/\s*$/g, '') + '\n';
+  }
+
   // ===========================================================================
   // CLI entry point
   // ===========================================================================
@@ -217,7 +495,7 @@ function makeExplain(deps) {
     return addMarkdownHardBreaks(pairs.map((p) => p.text).join(''));
   }
 
-  return { printExplanation, collectOutputStringsFromFacts };
+  return { printExplanation, renderProofDocument, collectOutputStringsFromFacts };
 }
 
 module.exports = { makeExplain };

package/lib/multisource.js

@@ -31,6 +31,67 @@ function emptyParsedDocument() {
   };
 }
 
+function lineStartsForText(text) {
+  const s = String(text);
+  const starts = [0];
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 10) starts.push(i + 1); // LF
+    else if (c === 13) { // CR or CRLF
+      if (i + 1 < s.length && s.charCodeAt(i + 1) === 10) i++;
+      starts.push(i + 1);
+    }
+  }
+  return starts;
+}
+
+function offsetToLineFromStarts(offset, lineStarts) {
+  if (typeof offset !== 'number') return null;
+  let lo = 0;
+  let hi = lineStarts.length;
+  while (lo + 1 < hi) {
+    const mid = (lo + hi) >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid;
+  }
+  return lo + 1;
+}
+
+function annotateSourceLocation(obj, label, lineStarts) {
+  if (!obj || typeof obj.__sourceOffset !== 'number') return obj;
+  const line = offsetToLineFromStarts(obj.__sourceOffset, lineStarts);
+  Object.defineProperty(obj, '__source', {
+    value: { label, line },
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return obj;
+}
+
+function annotateParsedSourceLocations(doc, text, label) {
+  const lineStarts = lineStartsForText(text);
+  for (const tr of doc.triples || []) annotateSourceLocation(tr, label, lineStarts);
+  for (const r of doc.frules || []) annotateSourceLocation(r, label, lineStarts);
+  for (const r of doc.brules || []) annotateSourceLocation(r, label, lineStarts);
+  for (const r of doc.logQueryRules || []) annotateSourceLocation(r, label, lineStarts);
+}
+
+function copySourceMetadata(from, to) {
+  if (!from || !to) return to;
+  for (const key of ['__sourceOffset', '__source']) {
+    if (Object.prototype.hasOwnProperty.call(from, key)) {
+      Object.defineProperty(to, key, {
+        value: from[key],
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+  }
+  return to;
+}
+
 function prefixesUsedInTokens(tokens, prefEnv) {
   const used = new Set();
   const toks = Array.isArray(tokens) ? tokens : [];
@@ -108,6 +169,7 @@ function parseN3Text(text, opts = {}) {
     label = '<input>',
     keepSourceArtifacts = true,
     collectUsedPrefixes = false,
+    collectSourceLocations = true,
     rdf = false,
   } = opts || {};
   const tokens = lex(text, { rdf });
@@ -116,6 +178,7 @@ function parseN3Text(text, opts = {}) {
   const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
 
   const doc = { prefixes, triples, frules, brules, logQueryRules, label };
+  if (collectSourceLocations) annotateParsedSourceLocations(doc, text, label);
 
   if (collectUsedPrefixes) {
     Object.defineProperty(doc, 'usedPrefixes', {
@@ -161,7 +224,7 @@ function scopeBlankNodesInDocument(doc, sourceIndex) {
   }
 
   function cloneTriple(triple) {
-    return new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o));
+    return copySourceMetadata(triple, new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o)));
   }
 
   function cloneRule(rule) {
@@ -170,12 +233,15 @@ function scopeBlankNodesInDocument(doc, sourceIndex) {
       for (const label of rule.headBlankLabels) headBlankLabels.add(scopedBlankLabel(label, sourceIndex, mapping));
     }
 
-    const out = new Rule(
-      (rule.premise || []).map(cloneTriple),
-      (rule.conclusion || []).map(cloneTriple),
-      rule.isForward,
-      rule.isFuse,
-      headBlankLabels,
+    const out = copySourceMetadata(
+      rule,
+      new Rule(
+        (rule.premise || []).map(cloneTriple),
+        (rule.conclusion || []).map(cloneTriple),
+        rule.isForward,
+        rule.isFuse,
+        headBlankLabels,
+      ),
     );
 
     if (rule && Object.prototype.hasOwnProperty.call(rule, '__dynamicConclusionTerm')) {
@@ -303,6 +369,7 @@ function parseN3SourceList(input, opts = {}) {
       label: source.label,
       baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
       collectUsedPrefixes: true,
+      collectSourceLocations: !!opts.collectSourceLocations,
       keepSourceArtifacts: !!opts.keepSourceArtifacts,
       rdf: !!opts.rdf,
     }),

package/lib/parser.js

@@ -42,6 +42,17 @@ function failInvalidKeywordLikeIdent(fail, tok, name) {
   fail(`invalid_keyword(${name})`, tok);
 }
 
+function annotateSourceOffset(obj, offset) {
+  if (!obj || typeof offset !== 'number') return obj;
+  Object.defineProperty(obj, '__sourceOffset', {
+    value: offset,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return obj;
+}
+
 class Parser {
   constructor(tokens) {
     this.toks = tokens;
@@ -166,17 +177,19 @@ class Parser {
         continue;
       }
 
+      const statementToken = this.peek();
+      const statementOffset = statementToken && typeof statementToken.offset === 'number' ? statementToken.offset : null;
       const first = this.parseTerm();
       if (this.peek().typ === 'OpImplies') {
         this.next();
         const second = this.parseTerm();
         this.expectDot();
-        forwardRules.push(this.makeRule(first, second, true));
+        forwardRules.push(annotateSourceOffset(this.makeRule(first, second, true), statementOffset));
       } else if (this.peek().typ === 'OpImpliedBy') {
         this.next();
         const second = this.parseTerm();
         this.expectDot();
-        backwardRules.push(this.makeRule(first, second, false));
+        backwardRules.push(annotateSourceOffset(this.makeRule(first, second, false), statementOffset));
       } else {
         let more;
 
@@ -194,16 +207,17 @@ class Parser {
         }
 
         // normalize explicit log:implies / log:impliedBy at top-level
-        for (const tr of more) {
+        for (const tr0 of more) {
+          const tr = annotateSourceOffset(tr0, statementOffset);
           if (isLogImplies(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-            forwardRules.push(this.makeRule(tr.s, tr.o, true));
+            forwardRules.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, true), statementOffset));
           } else if (isLogImpliedBy(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-            backwardRules.push(this.makeRule(tr.s, tr.o, false));
+            backwardRules.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, false), statementOffset));
           } else if (isLogQuery(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
             // Output-selection directive: { premise } log:query { conclusion }.
             // When present at top-level, eyeling prints only the instantiated conclusion
             // triples (unique) instead of all newly derived facts.
-            logQueries.push(this.makeRule(tr.s, tr.o, true));
+            logQueries.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, true), statementOffset));
           } else {
             triples.push(tr);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.25.4",
+  "version": "1.26.0",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/api.test.js

@@ -454,7 +454,7 @@ ${U('x')} ${U('age')} "42".
 ${U('s')} ${U('p')} ${U('o')}.
 `,
     expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
-    notExpect: [/^#/m],
+    notExpect: [/pe:why/m],
   },
   {
     name: '11 negative entailment: rule derives false (expect exit 65 => throws)',
@@ -1038,23 +1038,23 @@ ${U('a')} ${U('p')} ${U('b')}.
     expect: [new RegExp(`${EX}a>\\s+<${EX}q2>\\s+<${EX}b>\\s*\\.`)],
   },
   {
-    name: '30 sanity: proofComments:true enables proof comments',
-    opt: { proofComments: true },
+    name: '30 sanity: proof:true enables N3 proof explanations',
+    opt: { proof: true },
     input: `
 { ${U('s')} ${U('p')} ${U('o')}. } => { ${U('s')} ${U('q')} ${U('o')}. }.
 ${U('s')} ${U('p')} ${U('o')}.
 `,
-    expect: [/^#/m, new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
+    expect: [/pe:why/m, /pe:by/m, new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
   },
   {
-    name: '31 sanity: -n suppresses proof comments',
+    name: '31 sanity: default output has no proof explanations',
     opt: ['-n'],
     input: `
 { ${U('s')} ${U('p')} ${U('o')}. } => { ${U('s')} ${U('q')} ${U('o')}. }.
 ${U('s')} ${U('p')} ${U('o')}.
 `,
     expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
-    notExpect: [/^#/m],
+    notExpect: [/pe:why/m],
   },
 
   // -------------------------
@@ -2496,6 +2496,26 @@ _:b a ex:Person ; ex:name "B" .
     ],
     notExpect: [/:result\s+:sumX\s+"329"\^\^xsd:decimal\s*\./, /:result\s+:meanX\s+"47"\^\^xsd:decimal\s*\./],
   },
+  {
+    name: '244 regression: scoped collectAllIn is stratified after scoped notIncludes',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:a :x 1 .
+:b :x 1 .
+
+{ ?s :x 1 . ?X log:notIncludes { ?s :marked ?X } } => { ?s :marked true } .
+{ ( ?s { ?s :marked true } ?all ) log:collectAllIn ?scope } => { :result :marked ?all } .
+`,
+    expect: [
+      /^:a\s+:marked\s+true\s*\./m,
+      /^:b\s+:marked\s+true\s*\./m,
+      /^:result\s+:marked\s+\(:a\s+:b\)\s*\./m,
+    ],
+    notExpect: [/^:result\s+:marked\s+\(\)\s*\./m],
+  },
+
   {
     name: '244 regression: log:dtlit recognizes shorthand numeric and boolean literals',
     opt: { proofComments: false },

package/tools/bundle.js

@@ -158,6 +158,9 @@ function buildBundleSource({ autoRunMain }) {
   out.push(
     '      if (typeof __entry.printExplanation === "function") __outerSelf.printExplanation = __entry.printExplanation;',
   );
+  out.push(
+    '      if (typeof __entry.renderProofDocument === "function") __outerSelf.renderProofDocument = __entry.renderProofDocument;',
+  );
   out.push('      if (typeof __entry.tripleToN3 === "function") __outerSelf.tripleToN3 = __entry.tripleToN3;');
   out.push(
     '      if (typeof __entry.collectOutputStringsFromFacts === "function") __outerSelf.collectOutputStringsFromFacts = __entry.collectOutputStringsFromFacts;',