eyeprolog 1.5.35 → 1.5.36

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.35",
+  "version": "1.5.36",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/parser.js

@@ -238,6 +238,12 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
   }
   return state;
 }
+// Pre-compiled character-class regexes used in the lexer hot path.
+const RE_OCTAL_DIGIT = /^[0-7]$/;
+const RE_HEX_DIGIT = /^[0-9A-Fa-f]$/;
+const RE_DECIMAL_DIGIT = /^[0-9]$/;
+const RE_BINARY_DIGIT = /^[01]$/;
+
 
 class Parser {
   constructor(source, options = {}) {
@@ -480,7 +486,7 @@ class Parser {
 
     if (escaped === 'x') {
       let digits = '';
-      while (/^[0-9A-Fa-f]$/.test(peekChar())) digits += takeChar();
+      while (RE_HEX_DIGIT.test(peekChar())) digits += takeChar();
       if (!digits || takeChar() !== '\\') throw new Error(`parse line ${line}: bad hexadecimal escape`);
       const code = Number.parseInt(digits, 16);
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
@@ -489,9 +495,9 @@ class Parser {
       if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
-    if (/^[0-7]$/.test(escaped)) {
+    if (RE_OCTAL_DIGIT.test(escaped)) {
       let digits = escaped;
-      while (/^[0-7]$/.test(peekChar())) digits += takeChar();
+      while (RE_OCTAL_DIGIT.test(peekChar())) digits += takeChar();
       if (takeChar() !== '\\') throw new Error(`parse line ${line}: bad octal escape`);
       const code = Number.parseInt(digits, 8);
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
@@ -503,7 +509,7 @@ class Parser {
     // A backslash followed by a decimal digit is numeric-escape syntax, but
     // ISO octal digits are limited to 0..7.  Do not reinterpret \8 or \9 as
     // implementation-specific one-character escapes.
-    if (/^[0-9]$/.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
+    if (RE_DECIMAL_DIGIT.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
 
     // The only remaining ISO meta escapes are the four meta characters from
     // 6.5.5.  Forms such as \c, \d, \e, \u or \. are not quoted
@@ -652,9 +658,9 @@ class Parser {
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }
       const radixKind = this.peek() === '0' ? this.peek(1) : '';
-      const radixHasDigit = radixKind === 'b' ? /^[01]$/.test(this.peek(2))
-        : radixKind === 'o' ? /^[0-7]$/.test(this.peek(2))
-        : radixKind === 'x' ? /^[0-9A-Fa-f]$/.test(this.peek(2))
+      const radixHasDigit = radixKind === 'b' ? RE_BINARY_DIGIT.test(this.peek(2))
+        : radixKind === 'o' ? RE_OCTAL_DIGIT.test(this.peek(2))
+        : radixKind === 'x' ? RE_HEX_DIGIT.test(this.peek(2))
         : false;
       if (radixHasDigit) {
         this.take();
@@ -1816,14 +1822,14 @@ export function parseNumberTokenText(text, options = {}) {
         value = controls[escaped];
       } else if (escaped === 'x') {
         let digits = '';
-        while (/^[0-9A-Fa-f]$/.test(source[position] ?? '')) digits += source[position++];
+        while (RE_HEX_DIGIT.test(source[position] ?? '')) digits += source[position++];
         if (!digits || source[position++] !== '\\') throw invalidNumberTokenError;
         const code = Number.parseInt(digits, 16);
         if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw invalidNumberTokenError;
         value = String.fromCodePoint(code);
-      } else if (/^[0-7]$/.test(escaped)) {
+      } else if (RE_OCTAL_DIGIT.test(escaped)) {
         let digits = escaped;
-        while (/^[0-7]$/.test(source[position] ?? '')) digits += source[position++];
+        while (RE_OCTAL_DIGIT.test(source[position] ?? '')) digits += source[position++];
         if (source[position++] !== '\\') throw invalidNumberTokenError;
         const code = Number.parseInt(digits, 8);
         if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw invalidNumberTokenError;

package/src/program-analysis.js

@@ -65,7 +65,9 @@ function reachableIndexesTransposed(target, deps, candidates) {
   const reverse = new Map();
   for (const from of candidates) {
     if (!reverse.has(from)) reverse.set(from, []);
-    for (const to of deps[from]) {
+    const edges = deps[from];
+    if (edges == null) continue;
+    for (const to of edges) {
       if (!candidates.has(to)) continue;
       let bucket = reverse.get(to);
       if (bucket == null) { bucket = []; reverse.set(to, bucket); }

package/src/program.js

@@ -29,9 +29,12 @@ import {
 } from './program-indexing.js';
 export { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import {
+
   componentHasNegativeEdge, componentHasCut, reachableIndexes, datalogDependencyClauseCount, isFiniteDatalogGroup, isRangeRestrictedFiniteDatalogGroup, isFiniteWfsDatalogGroup, inferStructuralInputPositions, hasStrictListTailRecursion, hasLinearNumericRecursion, isPiAccumulator, isPortableBetweenGenerator, directGoalDependencyKey, collectGoalDependencies, stronglyConnectedComponents, computeNegationStrata,
 } from './program-analysis.js';
 
+const RE_DECIMAL_INT = /^\d+$/;
+
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
@@ -303,7 +306,7 @@ export class Program {
     const positions = [];
     for (let index = 0; index < template.args.length; index++) {
       const spec = template.args[index];
-      if ((spec.type === 'number' && /^\d+$/.test(spec.name)) ||
+      if ((spec.type === 'number' && RE_DECIMAL_INT.test(spec.name)) ||
           (spec.type === ATOM && spec.name === ':')) positions.push(index);
     }
     const definitions = this.moduleMetaPredicates.get(module) ?? new Map();
@@ -1653,7 +1656,7 @@ function moduleExportIndicators(term) {
     if (item.type === COMPOUND && item.name === 'op' && item.arity === 3) {
       const [priority, specifier, names] = item.args;
       const operatorNames = names.type === ATOM ? [names] : properListItems(names, new Env());
-      if (priority.type !== NUMBER || !/^\d+$/.test(priority.name) || Number(priority.name) > 1200 ||
+      if (priority.type !== NUMBER || !RE_DECIMAL_INT.test(priority.name) || Number(priority.name) > 1200 ||
           specifier.type !== ATOM || !['fx', 'fy', 'xf', 'yf', 'xfx', 'xfy', 'yfx'].includes(specifier.name) ||
           operatorNames == null || operatorNames.some((name) => name.type !== ATOM)) return null;
       continue;
@@ -1832,7 +1835,7 @@ function staticProcedureModificationError(name, arity) {
 
 function predicateIndicator(name, arity) {
   if (name?.type !== ATOM || arity?.type !== 'number') return null;
-  if (!/^\d+$/.test(arity.name)) return null;
+  if (!RE_DECIMAL_INT.test(arity.name)) return null;
   const arityNumber = Number(arity.name);
   return { name: name.name, arity: arityNumber, key: `${name.name}/${arityNumber}` };
 }

package/src/term.js

@@ -72,7 +72,7 @@ export class CompactListTerm {
   mayContainVariable(name, env = null) {
     if (String(name).startsWith(this._variablePrefix)) {
       const indexText = String(name).slice(this._variablePrefix.length);
-      if (/^\d+$/.test(indexText)) {
+      if (RE_DIGIT_STR.test(indexText)) {
         const index = BigInt(indexText);
         if (index >= this._offset && index < this._offset + this._compactLength) return true;
       }
@@ -1268,17 +1268,22 @@ export function copyResolved(term, env) {
 }
 
 export function termIsGround(term, env = new Env()) {
+  // Defer the cycle-guard Set until we encounter a compound term, since
+  // the overwhelming majority of ground checks are on acyclic clause data.
   const pending = [term];
-  const seen = new Set();
+  let seen = null;
   while (pending.length > 0) {
     const resolved = deref(pending.pop(), env);
     if (resolved.type === VAR) return false;
+    const arity = resolved.args.length;
+    if (arity === 0) continue;
+    if (seen == null) seen = new Set();
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     // Visit leftmost arguments first. Lists and other recursive structures
     // commonly carry their first unbound variable there, allowing a
     // non-ground check to finish without walking the complete tail.
-    for (let index = resolved.args.length - 1; index >= 0; index--) {
+    for (let index = arity - 1; index >= 0; index--) {
       pending.push(resolved.args[index]);
     }
   }
@@ -1287,11 +1292,18 @@ export function termIsGround(term, env = new Env()) {
 
 const graphicAtomChars = new Set('!#$&*+-/<=>@^~\\'.split(''));
 
+const RE_LOWER_IDENT = /^[a-z][A-Za-z0-9_]*$/;
+const RE_UPPER_IDENT = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
+const RE_LEGACY_VAR = /^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/;
+const RE_FLOAT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const RE_DIGIT_STR = /^\d+$/;
+const RE_SANITIZE_VAR = /[^A-Za-z0-9_]/g;
+const RE_UPPER_START = /^[A-Z_]/;
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
   if (name === '\\+' || name === '+' || name === '-' || name === '\\') return true;
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
+  if (RE_LOWER_IDENT.test(name)) return false;
   for (const ch of name) if (!graphicAtomChars.has(ch)) return true;
   return false;
 }
@@ -1322,11 +1334,11 @@ function legacyVariableToIso(name) {
 
 function writeVariable(name) {
   name = String(name ?? '');
-  if (/^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/.test(name)) return legacyVariableToIso(name);
-  if (/^(?:_|[A-Z_][A-Za-z0-9_]*)$/.test(name)) return name;
-  const sanitized = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (RE_LEGACY_VAR.test(name)) return legacyVariableToIso(name);
+  if (RE_UPPER_IDENT.test(name)) return name;
+  const sanitized = name.replace(RE_SANITIZE_VAR, '_');
   if (!sanitized) return '_';
-  return /^[A-Z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+  return RE_UPPER_START.test(sanitized) ? sanitized : `_${sanitized}`;
 }
 
 function writeString(value, quoteStrings) {
@@ -1363,7 +1375,7 @@ function quotedListSplice(term, env, doubleQuotes) {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
       characters.push(item.name);
     } else {
-      if (item.type !== NUMBER || !/^\d+$/.test(item.name)) return null;
+      if (item.type !== NUMBER || !RE_DIGIT_STR.test(item.name)) return null;
       const code = BigInt(item.name);
       if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return null;
       characters.push(String.fromCodePoint(Number(code)));
@@ -1558,12 +1570,16 @@ function variableRank(name, ranks) {
   return rank;
 }
 
+// ISO standard order: variables < numbers < atoms < strings < compound.
+// Defined once to avoid allocating a fresh object literal on every comparison.
+const TYPE_ORDER = { [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 };
+const EMPTY_ENV = new Env();
+
 function compareTermsWithRanks(left, right, variableRanks) {
-  const rank = (term) => ({ [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 })[term.type];
-  left = deref(left, new Env());
-  right = deref(right, new Env());
-  const lr = rank(left);
-  const rr = rank(right);
+  left = deref(left, EMPTY_ENV);
+  right = deref(right, EMPTY_ENV);
+  const lr = TYPE_ORDER[left.type] ?? 0;
+  const rr = TYPE_ORDER[right.type] ?? 0;
   if (lr !== rr) return lr < rr ? -1 : 1;
   if (left.type === NUMBER) {
     const leftInteger = isDecimalInteger(left.name);
@@ -1587,8 +1603,9 @@ function compareTermsWithRanks(left, right, variableRanks) {
   return 0;
 }
 
+const RE_DECIMAL_INTEGER = /^-?\d+$/;
 export function isDecimalInteger(text) {
-  return /^-?\d+$/.test(text ?? '');
+  return RE_DECIMAL_INTEGER.test(text ?? '');
 }
 
 export function compareIntegerText(left, right) {
@@ -1599,7 +1616,7 @@ export function compareIntegerText(left, right) {
 
 export function parseFiniteNumber(text) {
   if (text == null || text === '') return null;
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text)) return null;
+  if (!RE_FLOAT.test(text)) return null;
   const n = Number(text);
   return Number.isFinite(n) ? n : null;
 }

package/src/wfs.js

@@ -21,9 +21,15 @@ import {
   resolvePatternTerm,
 } from './datalog-common.js';
 
+const _wfsScalarKeyCache = new WeakMap();
 function scalarKey(term) {
-  if (term.type === 'number') return `number\u0000${numberValueKey(term.name)}`;
-  return `${term.type}\u0000${term.name}`;
+  const cached = _wfsScalarKeyCache.get(term);
+  if (cached != null) return cached;
+  const key = term.type === 'number'
+    ? `number\u0000${numberValueKey(term.name)}`
+    : `${term.type}\u0000${term.name}`;
+  _wfsScalarKeyCache.set(term, key);
+  return key;
 }
 
 function sameScalar(left, right) {

package/src/write.js

@@ -6,6 +6,13 @@ import {
 
 const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
 const compactInfixOperators = new Set([':', '..']);
+const RE_LOWER_WORD = /^[a-z][A-Za-z0-9_]*$/;
+const RE_ALNUM_IDENT = /^[A-Za-z0-9_]$/;
+const RE_DIGITS_ONLY = /^\d+$/;
+const RE_LEGACY_VAR_W = /^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/;
+const RE_UPPER_IDENT_W = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
+const RE_SANITIZE_W = /[^A-Za-z0-9_]/g;
+const RE_UPPER_START_W = /^[A-Z_]/;
 
 function quotedControlEscape(ch) {
   if (ch === '\x00') return '\\0\\';
@@ -38,7 +45,7 @@ function atomNeedsQuotes(name) {
   // be read as a bracketed comment and therefore still requires quoting.
   if (name === '.') return true;
   if (name.startsWith('/*')) return true;
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
+  if (RE_LOWER_WORD.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;
   return false;
 }
@@ -80,12 +87,12 @@ function compactBoundaryNeedsSpace(left, right) {
   // neighbouring identifier/number token.  Most predefined word operators
   // are handled explicitly below; this also protects quoted/custom cases that
   // render without punctuation.
-  if (/^[A-Za-z0-9_]$/.test(a) && /^[A-Za-z0-9_]$/.test(b)) return true;
+  if (RE_ALNUM_IDENT.test(a) && RE_ALNUM_IDENT.test(b)) return true;
   return false;
 }
 
 function isWordOperatorToken(token) {
-  return /^[a-z][A-Za-z0-9_]*$/.test(token);
+  return RE_LOWER_WORD.test(token);
 }
 
 function compactPrefixOperator(token, argument) {
@@ -99,7 +106,7 @@ function compactPrefixOperator(token, argument) {
 }
 
 function quotedOperatorAfterNumericNeedsSpace(left, token) {
-  if (!token.startsWith("'") || !/^[0-9]+$/.test(left)) return false;
+  if (!token.startsWith("'") || !RE_DIGITS_ONLY.test(left)) return false;
   const value = Number(left);
   // `0'X` starts character-code notation and bases 2..36 start based-number
   // notation. Base 1 and values above 36 do not, so they need no layout
@@ -135,11 +142,11 @@ function legacyVariableToIso(name) {
 
 function writeVariable(name) {
   name = String(name ?? '');
-  if (/^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/.test(name)) return legacyVariableToIso(name);
-  if (/^(?:_|[A-Z_][A-Za-z0-9_]*)$/.test(name)) return name;
-  const sanitized = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (RE_LEGACY_VAR_W.test(name)) return legacyVariableToIso(name);
+  if (RE_UPPER_IDENT_W.test(name)) return name;
+  const sanitized = name.replace(RE_SANITIZE_W, '_');
   if (!sanitized) return '_';
-  return /^[A-Z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+  return RE_UPPER_START_W.test(sanitized) ? sanitized : `_${sanitized}`;
 }
 
 function writeString(value) {
@@ -157,7 +164,7 @@ function quotedListCharacter(item, doubleQuotes) {
     return item.name;
   }
   if (doubleQuotes === 'codes') {
-    if (item.type !== NUMBER || !/^\d+$/.test(item.name)) return null;
+    if (item.type !== NUMBER || !RE_DIGITS_ONLY.test(item.name)) return null;
     const code = BigInt(item.name);
     if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return null;
     return String.fromCodePoint(Number(code));
@@ -197,7 +204,7 @@ function operatorName(name) {
   // output must use the unquoted `|` token (WG17 #181/#290).
   if (name === '|') return '|';
   if (name === '.' || name.startsWith('/*')) return quoteAtom(name);
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return name;
+  if (RE_LOWER_WORD.test(name)) return name;
   if (/^[!#$&*+\-./<=>?@^~\\;:]+$/.test(name)) return name;
   return quoteAtom(name);
 }
@@ -334,7 +341,7 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
 
   if (options.numbervars && resolved.type === COMPOUND && resolved.name === '$VAR' && resolved.arity === 1) {
     const index = deref(resolved.args[0], env);
-    if (index.type === NUMBER && /^\d+$/.test(index.name)) {
+    if (index.type === NUMBER && RE_DIGITS_ONLY.test(index.name)) {
       const name = writeNumberedVariable(Number(index.name));
       if (name != null) return name;
     }
@@ -404,7 +411,7 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         const childNumbervar = options.numbervars && child.type === COMPOUND &&
           child.name === '$VAR' && child.arity === 1 && (() => {
             const index = deref(child.args[0], env);
-            return index.type === NUMBER && /^\d+$/.test(index.name) &&
+            return index.type === NUMBER && RE_DIGITS_ONLY.test(index.name) &&
               writeNumberedVariable(Number(index.name)) != null;
           })();
         const childUsesSpecialNotation = isCons(child) ||