eyeleng 1.0.8 → 1.0.9

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/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/tools/perf-bench.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { performance } = require('node:perf_hooks');
+const { pathToFileURL, fileURLToPath } = require('node:url');
+const { runToString } = require('../src/index.js');
+
+const root = path.join(__dirname, '..');
+const baselinePath = path.join(root, 'test', 'perf-baseline.json');
+const DEFAULT_RELATIVE_TOLERANCE = 1.35;
+const DEFAULT_ABSOLUTE_TOLERANCE_MS = 1000;
+
+const defaultCases = [
+  { name: 'deep-taxonomy-100000.srl', file: 'examples/deep-taxonomy-100000.srl', repeat: 1 },
+  { name: 'fibonacci.srl', file: 'examples/fibonacci.srl', repeat: 1 },
+  { name: 'fft32-numeric.srl', file: 'examples/fft32-numeric.srl', repeat: 3 },
+  { name: 'path-discovery.srl', file: 'examples/path-discovery.srl', repeat: 5 },
+];
+
+function parseArgs(argv) {
+  const options = {
+    mode: 'check',
+    json: false,
+    cases: [],
+    repeat: null,
+    baseline: baselinePath,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--check') options.mode = 'check';
+    else if (arg === '--update') options.mode = 'update';
+    else if (arg === '--report') options.mode = 'report';
+    else if (arg === '--json') options.json = true;
+    else if (arg === '--case') {
+      i += 1;
+      if (i >= argv.length) throw new Error('--case requires a benchmark name or file');
+      options.cases.push(argv[i]);
+    } else if (arg === '--repeat') {
+      i += 1;
+      if (i >= argv.length) throw new Error('--repeat requires a positive integer');
+      options.repeat = Number(argv[i]);
+      if (!Number.isInteger(options.repeat) || options.repeat < 1) throw new Error('--repeat requires a positive integer');
+    } else if (arg === '--baseline') {
+      i += 1;
+      if (i >= argv.length) throw new Error('--baseline requires a path');
+      options.baseline = path.resolve(argv[i]);
+    } else if (arg === '-h' || arg === '--help') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown option ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function help() {
+  return `Usage: node tools/perf-bench.js [--check|--update|--report] [options]\n\nRuns selected large examples and checks them against test/perf-baseline.json.\nThis is intentionally separate from npm test so normal correctness tests do not\nfail because of machine-dependent timings.\n\nOptions:\n  --check             Fail if a benchmark exceeds its budget (default)\n  --update            Rewrite the baseline with the current timings\n  --report            Print timings without checking or updating\n  --json              Print JSON output\n  --case NAME         Run only a case by name or file; may be repeated\n  --repeat N          Override per-case repeat count\n  --baseline FILE     Use a different baseline file\n  -h, --help          Print this help\n\nEnvironment overrides:\n  EYELENG_BENCH_RELATIVE_TOLERANCE       default ${DEFAULT_RELATIVE_TOLERANCE}\n  EYELENG_BENCH_ABSOLUTE_TOLERANCE_MS    default ${DEFAULT_ABSOLUTE_TOLERANCE_MS}\n  EYELENG_BENCH_REPEAT                   override repeat count\n`;
+}
+
+function loadBaseline(filename) {
+  if (!fs.existsSync(filename)) return null;
+  return JSON.parse(fs.readFileSync(filename, 'utf8'));
+}
+
+function baselineCases(baseline) {
+  if (!baseline || !Array.isArray(baseline.cases)) return null;
+  return baseline.cases.map((item) => ({
+    name: item.name,
+    file: item.file,
+    repeat: item.repeat || 1,
+    baselineMs: item.baselineMs,
+  }));
+}
+
+function selectCases(allCases, requested) {
+  if (requested.length === 0) return allCases;
+  return requested.map((name) => {
+    const found = allCases.find((item) => item.name === name || item.file === name || path.basename(item.file) === name);
+    if (!found) throw new Error(`Unknown benchmark case ${name}`);
+    return found;
+  });
+}
+
+function importResolver(target) {
+  if (!target.startsWith('file:')) throw new Error(`benchmark import resolver only supports file: imports, got ${target}`);
+  const filename = fileURLToPath(target);
+  return {
+    source: fs.readFileSync(filename, 'utf8'),
+    options: { filename, baseIRI: pathToFileURL(filename).href },
+  };
+}
+
+function runOptions(filename) {
+  return {
+    filename,
+    baseIRI: pathToFileURL(filename).href,
+    importResolver,
+    syntax: filename.endsWith('.ttl') ? 'rdf' : undefined,
+    now: new Date('2026-05-15T12:34:56Z'),
+  };
+}
+
+function median(values) {
+  const sorted = values.slice().sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+}
+
+function roundMs(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function runCase(testCase, repeatOverride) {
+  const filename = path.join(root, testCase.file);
+  const source = fs.readFileSync(filename, 'utf8');
+  const repeat = repeatOverride || Number(process.env.EYELENG_BENCH_REPEAT) || testCase.repeat || 1;
+  const samples = [];
+  let outputBytes = 0;
+
+  for (let i = 0; i < repeat; i += 1) {
+    if (global.gc) global.gc();
+    const start = performance.now();
+    const output = runToString(source, runOptions(filename));
+    const elapsed = performance.now() - start;
+    outputBytes = Buffer.byteLength(output, 'utf8');
+    samples.push(elapsed);
+  }
+
+  return {
+    name: testCase.name,
+    file: testCase.file,
+    repeat,
+    samplesMs: samples.map(roundMs),
+    ms: roundMs(median(samples)),
+    outputBytes,
+  };
+}
+
+function toleranceFromEnv(baseline = {}) {
+  const fromBaseline = baseline.tolerance || {};
+  const relative = Number(process.env.EYELENG_BENCH_RELATIVE_TOLERANCE || fromBaseline.relative || DEFAULT_RELATIVE_TOLERANCE);
+  const absoluteMs = Number(process.env.EYELENG_BENCH_ABSOLUTE_TOLERANCE_MS || fromBaseline.absoluteMs || DEFAULT_ABSOLUTE_TOLERANCE_MS);
+  if (!Number.isFinite(relative) || relative < 1) throw new Error('relative tolerance must be >= 1');
+  if (!Number.isFinite(absoluteMs) || absoluteMs < 0) throw new Error('absolute tolerance must be >= 0');
+  return { relative, absoluteMs };
+}
+
+function budgetFor(item, tolerance) {
+  if (!Number.isFinite(item.baselineMs)) return null;
+  return roundMs(item.baselineMs * tolerance.relative + tolerance.absoluteMs);
+}
+
+function printTable(results, checks) {
+  const widths = {
+    name: Math.max('case'.length, ...results.map((item) => item.name.length)),
+    ms: Math.max('ms'.length, ...results.map((item) => String(item.ms).length)),
+    budget: Math.max('budget'.length, ...checks.map((item) => item.budgetMs == null ? 1 : String(item.budgetMs).length)),
+  };
+  console.log(`${'case'.padEnd(widths.name)}  ${'ms'.padStart(widths.ms)}  ${'budget'.padStart(widths.budget)}  status`);
+  console.log(`${'-'.repeat(widths.name)}  ${'-'.repeat(widths.ms)}  ${'-'.repeat(widths.budget)}  ------`);
+  for (const item of results) {
+    const check = checks.find((entry) => entry.name === item.name) || {};
+    const budget = check.budgetMs == null ? '-' : String(check.budgetMs);
+    const status = check.status || 'report';
+    console.log(`${item.name.padEnd(widths.name)}  ${String(item.ms).padStart(widths.ms)}  ${budget.padStart(widths.budget)}  ${status}`);
+  }
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    console.log(help());
+    return;
+  }
+
+  const baseline = loadBaseline(options.baseline);
+  const allCases = baselineCases(baseline) || defaultCases;
+  const selected = selectCases(allCases, options.cases);
+  const repeatOverride = options.repeat || null;
+  const results = selected.map((testCase) => runCase(testCase, repeatOverride));
+  const tolerance = toleranceFromEnv(baseline || {});
+
+  const byBaseline = new Map((baselineCases(baseline) || []).map((item) => [item.name, item]));
+  const checks = results.map((result) => {
+    const baselineCase = byBaseline.get(result.name);
+    const budgetMs = baselineCase ? budgetFor(baselineCase, tolerance) : null;
+    const status = budgetMs == null ? 'no-baseline' : result.ms <= budgetMs ? 'ok' : 'regressed';
+    return { name: result.name, baselineMs: baselineCase ? baselineCase.baselineMs : null, budgetMs, status };
+  });
+
+  if (options.mode === 'update') {
+    const updated = {
+      version: 1,
+      generatedBy: 'npm run bench:update',
+      note: 'Machine-dependent performance baseline. Use npm run bench:update to refresh intentionally.',
+      tolerance,
+      cases: results.map((result) => ({
+        name: result.name,
+        file: result.file,
+        repeat: result.repeat,
+        baselineMs: result.ms,
+        outputBytes: result.outputBytes,
+      })),
+    };
+    fs.mkdirSync(path.dirname(options.baseline), { recursive: true });
+    fs.writeFileSync(options.baseline, `${JSON.stringify(updated, null, 2)}\n`, 'utf8');
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify({ mode: options.mode, tolerance, results, checks }, null, 2));
+  } else {
+    printTable(results, checks);
+    if (options.mode === 'update') console.log(`\nUpdated ${path.relative(root, options.baseline)}`);
+  }
+
+  if (options.mode === 'check') {
+    const regressions = checks.filter((item) => item.status === 'regressed');
+    if (regressions.length > 0) {
+      console.error('\nPerformance regression detected. Run npm run bench:update only after intentionally accepting a new baseline.');
+      process.exitCode = 1;
+    }
+  }
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(err.stack || err.message || String(err));
+  process.exit(1);
+}