eyeleng 1.0.7 → 1.0.9

package/src/analyze.js

@@ -11,9 +11,7 @@ function analyze(program, options = {}) {
 
   program.rules.forEach((rule, index) => {
     const name = ruleName(rule, index);
-    const label = displayRuleName(name, program.prefixes || {});
     const bound = boundVariables(rule.body);
-    const positive = positiveVariables(rule.body);
     const head = new Set();
     for (const triple of rule.head) collectTripleVars(triple, head);
 
@@ -23,7 +21,7 @@ function analyze(program, options = {}) {
           code: 'unsafe-head-variable',
           severity: 'error',
           rule: name,
-          message: `${label} has unbound head variable ?${variable}`,
+          message: `${displayRuleName(name, program.prefixes || {})} has unbound head variable ?${variable}`,
         });
       }
     }
@@ -34,19 +32,19 @@ function analyze(program, options = {}) {
           code: 'invalid-head-predicate',
           severity: 'error',
           rule: name,
-          message: `${label} has a non-IRI/non-variable predicate in the head`,
+          message: `${displayRuleName(name, program.prefixes || {})} has a non-IRI/non-variable predicate in the head`,
         });
       }
     }
 
-    diagnostics.push(...sequentialWellFormednessDiagnostics(rule.body, name, label));
+    diagnostics.push(...sequentialWellFormednessDiagnostics(rule.body, name, program.prefixes || {}));
 
     if (rule.runOnce && recursiveIndexes.has(index)) {
       diagnostics.push({
         code: 'recursive-assignment-rule',
         severity: 'warning',
         rule: name,
-        message: `${label} is a run-once rule in a recursive dependency cycle`,
+        message: `${displayRuleName(name, program.prefixes || {})} is a run-once rule in a recursive dependency cycle`,
       });
     }
 
@@ -402,7 +400,7 @@ function stronglyConnectedComponents(size, edges) {
   return components;
 }
 
-function sequentialWellFormednessDiagnostics(clauses, ruleNameValue, label) {
+function sequentialWellFormednessDiagnostics(clauses, ruleNameValue, prefixes = {}) {
   const diagnostics = [];
 
   function visit(items, initialBound, scopeLabel) {
@@ -417,7 +415,7 @@ function sequentialWellFormednessDiagnostics(clauses, ruleNameValue, label) {
               code: 'unbound-filter-variable',
               severity: 'error',
               rule: ruleNameValue,
-              message: `${label} FILTER uses ?${variable} before it is bound${scopeLabel}`,
+              message: `${displayRuleName(ruleNameValue, prefixes)} FILTER uses ?${variable} before it is bound${scopeLabel}`,
             });
           }
         }
@@ -427,7 +425,7 @@ function sequentialWellFormednessDiagnostics(clauses, ruleNameValue, label) {
             code: 'assignment-variable-already-bound',
             severity: 'error',
             rule: ruleNameValue,
-            message: `${label} SET assigns ?${clause.variable}, but that variable is already bound${scopeLabel}`,
+            message: `${displayRuleName(ruleNameValue, prefixes)} SET assigns ?${clause.variable}, but that variable is already bound${scopeLabel}`,
           });
         }
         for (const variable of expressionVariables(clause.expr)) {
@@ -436,7 +434,7 @@ function sequentialWellFormednessDiagnostics(clauses, ruleNameValue, label) {
               code: 'unbound-assignment-variable',
               severity: 'error',
               rule: ruleNameValue,
-              message: `${label} SET expression uses ?${variable} before it is bound${scopeLabel}`,
+              message: `${displayRuleName(ruleNameValue, prefixes)} SET expression uses ?${variable} before it is bound${scopeLabel}`,
             });
           }
         }

package/src/builtins.js

@@ -28,6 +28,8 @@ const XSD_DAYTIME_DURATION = 'http://www.w3.org/2001/XMLSchema#dayTimeDuration';
 const RDF_LANGSTRING = `${RDF_NS}langString`;
 const RDF_DIRLANGSTRING = `${RDF_NS}dirLangString`;
 const NUMERIC_DATATYPES = new Set([XSD_INTEGER, XSD_DECIMAL, XSD_DOUBLE]);
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
 
 // This table is intentionally shaped by the SHACL 1.2 Rules grammar production BuiltInCall.
 // Keys are the canonical spellings used by the draft; lookup is case-insensitive so examples
@@ -187,7 +189,7 @@ function toBigIntInteger(value) {
 }
 
 function fromIntegerResult(value) {
-  if (value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER)) return Number(value);
+  if (value <= MAX_SAFE_INTEGER_BIGINT && value >= MIN_SAFE_INTEGER_BIGINT) return Number(value);
   return value;
 }
 

package/src/engine.js

@@ -32,6 +32,18 @@ function evaluate(program, options = {}) {
     layerIndexes,
     analysis.dependency ? analysis.dependency.edges : [],
   );
+  const baseContext = {
+    ...evalOptions,
+    maxIterations,
+    inputKeys,
+    inferred,
+    trace,
+    perRule,
+    layer: 0,
+    iteration: 0,
+    startingIterations: 0,
+    recursiveLayer: false,
+  };
 
   for (let layerIndex = 0; layerIndex < layerIndexes.length; layerIndex += 1) {
     const layer = layerIndexes[layerIndex];
@@ -41,30 +53,17 @@ function evaluate(program, options = {}) {
     if (runOnce.length > 0) {
       iterations += 1;
       for (const ruleIndex of runOnce) {
-        const added = applyRuleOnce(program, store, ruleIndex, {
-          ...evalOptions,
-          inputKeys,
-          inferred,
-          trace,
-          perRule,
-          layer: layerIndex + 1,
-          iteration: iterations,
-        });
+        baseContext.layer = layerIndex + 1;
+        baseContext.iteration = iterations;
+        const added = applyRuleOnce(program, store, ruleIndex, baseContext);
         ruleApplications += added.applications;
       }
     }
 
-    const ordinaryResult = runRulesToFixpoint(program, store, ordinary, {
-      ...evalOptions,
-      maxIterations,
-      inputKeys,
-      inferred,
-      trace,
-      perRule,
-      layer: layerIndex + 1,
-      startingIterations: iterations,
-      recursiveLayer: recursiveLayerFlags[layerIndex],
-    });
+    baseContext.layer = layerIndex + 1;
+    baseContext.startingIterations = iterations;
+    baseContext.recursiveLayer = recursiveLayerFlags[layerIndex];
+    const ordinaryResult = runRulesToFixpoint(program, store, ordinary, baseContext);
     iterations = ordinaryResult.iterations;
     ruleApplications += ordinaryResult.ruleApplications;
   }
@@ -95,10 +94,8 @@ function runRulesToFixpoint(program, store, ruleIndexes, context) {
     const iteration = context.startingIterations + 1;
     let ruleApplications = 0;
     for (const ruleIndex of ruleIndexes) {
-      const applied = applyRuleOnce(program, store, ruleIndex, {
-        ...context,
-        iteration,
-      });
+      context.iteration = iteration;
+      const applied = applyRuleOnce(program, store, ruleIndex, context);
       ruleApplications += applied.applications;
     }
     return { iterations: iteration, ruleApplications };
@@ -114,10 +111,8 @@ function runRulesToFixpoint(program, store, ruleIndexes, context) {
     let addedInIteration = 0;
 
     for (const ruleIndex of ruleIndexes) {
-      const applied = applyRuleOnce(program, store, ruleIndex, {
-        ...context,
-        iteration: iterations,
-      });
+      context.iteration = iterations;
+      const applied = applyRuleOnce(program, store, ruleIndex, context);
       addedInIteration += applied.added;
       ruleApplications += applied.applications;
     }
@@ -146,16 +141,24 @@ function computeRecursiveLayerFlags(layerIndexes, edges = []) {
   return flags;
 }
 
+
 function applyRuleOnce(program, store, ruleIndex, context) {
   const rule = program.rules[ruleIndex];
   let applications = 0;
   let added = 0;
-  const seenBindings = new Set();
+  const dedupeBindings = rule.body.some((clause) => clause.type === 'path');
+  const seenBindings = dedupeBindings ? new Set() : null;
 
-  for (const binding of evaluateBodyStream(rule.body, store, {}, context)) {
-    const key = bindingKey(binding);
-    if (seenBindings.has(key)) continue;
-    seenBindings.add(key);
+  const bodyBindings = rule.body.length === 1 && rule.body[0].type === 'triple'
+    ? store.match(rule.body[0].triple, {})
+    : evaluateBodyStream(rule.body, store, {}, context);
+
+  for (const binding of bodyBindings) {
+    if (seenBindings) {
+      const key = bindingKey(binding);
+      if (seenBindings.has(key)) continue;
+      seenBindings.add(key);
+    }
     applications += 1;
     context.perRule[ruleIndex].applications += 1;
 

package/src/parser.js

@@ -764,7 +764,7 @@ class Parser {
   peekN(n) { return this.tokens[this.pos + n] || this.tokens[this.tokens.length - 1]; }
   previous() { return this.tokens[this.pos - 1]; }
   strictGrammar() { return !!this.options.strictGrammar; }
-  error(message, token = this.peek()) { return new SyntaxErrorWithLocation(message, token); }
+  error(message, token = this.peek()) { return new SyntaxErrorWithLocation(message, token && token.filename ? token : { ...token, filename: this.options.filename || '<input>' }); }
 }
 
 

package/src/store.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { tripleKey, termKey, termEquals, cloneTerm } = require('./term.js');
+const { tripleKey, termKey, termEquals } = require('./term.js');
 
 class TripleStore {
   constructor(triples = []) {
@@ -109,7 +109,7 @@ function smallerValues(left, right) {
 }
 
 function normalizeTriple(triple) {
-  return { s: cloneTerm(triple.s), p: cloneTerm(triple.p), o: cloneTerm(triple.o) };
+  return { s: triple.s, p: triple.p, o: triple.o };
 }
 
 function bindingKey(binding) {

package/src/term.js

@@ -17,11 +17,13 @@ function iri(value) {
 }
 
 function variable(name) {
-  return { type: 'var', value: String(name).replace(/^[?$]/, '') };
+  const value = String(name);
+  return { type: 'var', value: value[0] === '?' || value[0] === '$' ? value.slice(1) : value };
 }
 
 function blankNode(value) {
-  return { type: 'blank', value: String(value).replace(/^_:/, '') };
+  const label = String(value);
+  return { type: 'blank', value: label.startsWith('_:') ? label.slice(2) : label };
 }
 
 function literal(value, datatype = null, lang = null, langDir = null) {

package/src/tokenizer.js

@@ -20,7 +20,7 @@ function tokenize(source, filenameOrOptions = '<input>') {
 
   function current() { return source[i]; }
   function peek(n = 1) { return source[i + n]; }
-  function startsWith(text) { return source.slice(i, i + text.length) === text; }
+  function startsWith(text) { return source.startsWith(text, i); }
   function advance() {
     const ch = source[i++];
     if (ch === '\n') { line += 1; column = 1; }
@@ -28,7 +28,7 @@ function tokenize(source, filenameOrOptions = '<input>') {
     return ch;
   }
   function token(type, value, startLine, startColumn, extra = {}) {
-    tokens.push({ type, value, line: startLine, column: startColumn, filename, ...extra });
+    tokens.push({ type, value, line: startLine, column: startColumn, ...extra });
   }
   function syntax(message, startLine, startColumn) {
     throw new SyntaxErrorWithLocation(message, { line: startLine, column: startColumn, filename });
@@ -36,19 +36,21 @@ function tokenize(source, filenameOrOptions = '<input>') {
 
   function readNumericLiteral() {
     let value = '';
-    while (i < source.length && /[0-9]/.test(current())) value += advance();
-    if (current() === '.' && /[0-9]/.test(peek())) {
-      value += advance();
-      while (i < source.length && /[0-9]/.test(current())) value += advance();
+    const start = i;
+    while (i < source.length && isDigitCode(source.charCodeAt(i))) { i += 1; column += 1; }
+    if (source[i] === '.' && isDigitCode(source.charCodeAt(i + 1))) {
+      i += 1; column += 1;
+      while (i < source.length && isDigitCode(source.charCodeAt(i))) { i += 1; column += 1; }
     }
+    value = source.slice(start, i);
     if (current() === 'e' || current() === 'E') {
       const saveI = i;
       const saveLine = line;
       const saveColumn = column;
       let exponent = advance();
       if (current() === '+' || current() === '-') exponent += advance();
-      if (/[0-9]/.test(current())) {
-        while (i < source.length && /[0-9]/.test(current())) exponent += advance();
+      if (isDigitCode(source.charCodeAt(i))) {
+        while (i < source.length && isDigitCode(source.charCodeAt(i))) exponent += advance();
         value += exponent;
       } else {
         i = saveI;
@@ -66,7 +68,7 @@ function tokenize(source, filenameOrOptions = '<input>') {
       const length = esc === 'u' ? 4 : 8;
       let hex = '';
       for (let j = 0; j < length; j += 1) {
-        if (!/[0-9A-Fa-f]/.test(current() || '')) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
+        if (!isHexCode(source.charCodeAt(i))) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
         hex += advance();
       }
       const codePoint = Number.parseInt(hex, 16);
@@ -85,7 +87,7 @@ function tokenize(source, filenameOrOptions = '<input>') {
       const length = esc === 'u' ? 4 : 8;
       let hex = '';
       for (let j = 0; j < length; j += 1) {
-        if (!/[0-9A-Fa-f]/.test(current() || '')) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
+        if (!isHexCode(source.charCodeAt(i))) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
         hex += advance();
       }
       const codePoint = Number.parseInt(hex, 16);
@@ -99,7 +101,7 @@ function tokenize(source, filenameOrOptions = '<input>') {
 
   while (i < source.length) {
     const ch = current();
-    if (/\s/.test(ch)) { advance(); continue; }
+    if (isWhitespaceCode(source.charCodeAt(i))) { advance(); continue; }
     if (ch === '#') {
       while (i < source.length && current() !== '\n') advance();
       continue;
@@ -185,18 +187,21 @@ function tokenize(source, filenameOrOptions = '<input>') {
     }
 
     if (ch === '@') {
-      let value = advance();
-      while (i < source.length && /[A-Za-z0-9-]/.test(current())) value += advance();
+      const wordStart = i;
+      advance();
+      while (i < source.length && isLangTagCode(source.charCodeAt(i))) { i += 1; column += 1; }
+      const value = source.slice(wordStart, i);
       if (!/^@[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--[A-Za-z]+)?$/.test(value)) syntax(`Invalid language tag ${value}`, startLine, startColumn);
       token('word', value, startLine, startColumn);
       continue;
     }
 
     if (ch === '?' || ch === '$') {
-      let value = advance();
-      while (i < source.length && /[A-Za-z0-9_\-]/.test(current())) value += advance();
-      if (value.length === 1) syntax('Expected variable name', startLine, startColumn);
-      token('variable', value.slice(1), startLine, startColumn);
+      const varStart = i;
+      advance();
+      while (i < source.length && isVarNameCode(source.charCodeAt(i))) { i += 1; column += 1; }
+      if (i - varStart === 1) syntax('Expected variable name', startLine, startColumn);
+      token('variable', source.slice(varStart + 1, i), startLine, startColumn);
       continue;
     }
 
@@ -223,24 +228,27 @@ function tokenize(source, filenameOrOptions = '<input>') {
       continue;
     }
 
-    let value = '';
+    const wordStart = i;
     while (i < source.length) {
-      const c = current();
-      if (c === '\\' && peek() !== undefined) {
-        value += advance();
-        value += advance();
+      const c = source[i];
+      if (c === '\\' && source[i + 1] !== undefined) {
+        i += 2;
+        column += 2;
         continue;
       }
-      if (/\s/.test(c) || '{}()[],;|'.includes(c) || '=<>+-*/!^~'.includes(c)) break;
+      const code = source.charCodeAt(i);
+      if (isWhitespaceCode(code) || '{}()[],;|'.includes(c) || '=<>+-*/!^~'.includes(c)) break;
       if (c === '.') {
-        const n = peek();
-        if (n === undefined || /\s/.test(n) || '{}()[],;|'.includes(n) || '=<>+-*/!^~'.includes(n)) break;
+        const n = source[i + 1];
+        if (n === undefined || isWhitespaceCode(n.charCodeAt(0)) || '{}()[],;|'.includes(n) || '=<>+-*/!^~'.includes(n)) break;
       }
       if (c === '#') break;
-      value += advance();
+      i += 1;
+      column += 1;
     }
-    if (value.length === 0) syntax(`Unexpected character ${JSON.stringify(ch)}`, startLine, startColumn);
+    if (i === wordStart) syntax(`Unexpected character ${JSON.stringify(ch)}`, startLine, startColumn);
 
+    const value = source.slice(wordStart, i);
     if (/^[+-]?(?:(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+|\d+)$/.test(value)) token('number', Number(value), startLine, startColumn);
     else token('word', value, startLine, startColumn);
   }
@@ -249,11 +257,32 @@ function tokenize(source, filenameOrOptions = '<input>') {
   return tokens;
 }
 
+
+function isDigitCode(code) {
+  return code >= 48 && code <= 57;
+}
+
+function isHexCode(code) {
+  return (code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102);
+}
+
+function isWhitespaceCode(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
+}
+
+function isLangTagCode(code) {
+  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57) || code === 45;
+}
+
+function isVarNameCode(code) {
+  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57) || code === 95 || code === 45;
+}
+
 function startsNumericLiteral(source, i) {
   const ch = source[i];
   const next = source[i + 1];
-  if (/[0-9]/.test(ch)) return true;
-  if (ch === '.' && /[0-9]/.test(next)) return true;
+  if (isDigitCode(ch.charCodeAt(0))) return true;
+  if (ch === '.' && next !== undefined && isDigitCode(next.charCodeAt(0))) return true;
   return false;
 }
 

package/test/browser-bundle.test.js

@@ -44,4 +44,12 @@ test('playground inline scripts are syntactically valid', () => {
   assert.ok(checked > 0, 'expected at least one inline playground script');
 });
 
+
+test('playground loads version from package.json at runtime', () => {
+  const html = fs.readFileSync(path.join(root, 'playground.html'), 'utf8');
+  assert.equal(/window\.__EYELENG_VERSION__/.test(html), false, 'playground.html must not hard-code the package version');
+  assert.match(html, /fetch\(new URL\(['"]package\.json['"],\s*window\.location\.href\)/);
+  assert.match(html, /id=["']version-label["'][^>]*>v…<\/span>/);
+});
+
 main();

package/test/perf-baseline.json

@@ -0,0 +1,39 @@
+{
+  "version": 1,
+  "generatedBy": "npm run bench:update",
+  "note": "Machine-dependent performance baseline. Use npm run bench:update to refresh intentionally.",
+  "tolerance": {
+    "relative": 1.35,
+    "absoluteMs": 1000
+  },
+  "cases": [
+    {
+      "name": "deep-taxonomy-100000.srl",
+      "file": "examples/deep-taxonomy-100000.srl",
+      "repeat": 1,
+      "baselineMs": 5427.8,
+      "outputBytes": 5068161
+    },
+    {
+      "name": "fibonacci.srl",
+      "file": "examples/fibonacci.srl",
+      "repeat": 1,
+      "baselineMs": 1409.4,
+      "outputBytes": 10810713
+    },
+    {
+      "name": "fft32-numeric.srl",
+      "file": "examples/fft32-numeric.srl",
+      "repeat": 3,
+      "baselineMs": 182.2,
+      "outputBytes": 466351
+    },
+    {
+      "name": "path-discovery.srl",
+      "file": "examples/path-discovery.srl",
+      "repeat": 5,
+      "baselineMs": 1317.7,
+      "outputBytes": 736870
+    }
+  ]
+}

package/test/shacl12-rules.test.js

@@ -10,7 +10,6 @@ const {
   isW3cRequired,
   runShacl12RulesManifest,
   formatShacl12RulesProgressLine,
-  writeShacl12RulesEarlReport,
 } = require('../src/shacl12RulesManifest.js');
 
 const rootManifestUrl = process.env.EYELENG_SHACL12_RULES_MANIFEST || defaultShacl12RulesManifestUrl;
@@ -46,13 +45,6 @@ async function main() {
     return;
   }
 
-  try {
-    const reportPath = writeShacl12RulesEarlReport(result);
-    console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
-  } catch (err) {
-    console.error(`Failed to write SHACL Rules EARL report: ${err.message}`);
-    result.counts.fail += 1;
-  }
 
   for (const section of result.bySection) {
     summaryLine(section.failed === 0 ? 'ok' : 'fail', section.passed, section.total, null, { label: section.section });

package/test/w3c-rdf.test.js

@@ -9,7 +9,6 @@ const {
   defaultW3cRdfManifestUrls,
   runW3cRdfManifests,
   formatW3cRdfProgressLine,
-  writeRdfEarlReport,
 } = require('../src/rdfManifest.js');
 const { parseNQuads, parseN3 } = require('../src/rdfSyntax.js');
 const { evaluateEntailmentTest, entails } = require('../src/rdfEntailment.js');
@@ -186,8 +185,6 @@ test('official W3C RDF manifests run with streaming progress when reachable', as
   }
   assert.equal(result.counts.fail, 0, `${result.counts.fail} W3C RDF failure(s)`);
   assert.ok(result.counts.pass > 0, 'expected at least one W3C RDF parser test to pass');
-  const reportPath = writeRdfEarlReport(result);
-  console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
   summaryLine('ok', result.counts.pass, result.counts.total, result.durationMs, {
     skipped: result.counts.skip,
     label: 'W3C RDF manifests',

package/tools/bundle.js

@@ -57,22 +57,6 @@ function js(value) {
 }
 
 
-function packageVersion() {
-  const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-  if (!packageJson.version) throw new Error('package.json is missing a version');
-  return packageJson.version;
-}
-
-function syncPlaygroundVersion() {
-  const version = packageVersion();
-  const outPath = path.join(root, playgroundOutput);
-  const html = fs.readFileSync(outPath, 'utf8');
-  const pattern = /(window\.__EYELENG_VERSION__\s*=\s*)["'][^"']*["']\s*;/;
-  if (!pattern.test(html)) throw new Error('Could not find window.__EYELENG_VERSION__ in playground.html');
-  const next = html.replace(pattern, `$1${js(version)};`);
-  fs.writeFileSync(outPath, next, 'utf8');
-  console.log(`wrote ${playgroundOutput} version ${version}`);
-}
 
 function ensureParentDir(filename) {
   fs.mkdirSync(path.dirname(filename), { recursive: true });
@@ -172,4 +156,3 @@ function indent(source, spaces) {
 
 buildCli();
 buildBrowser();
-syncPlaygroundVersion();