eyeling 1.31.0 → 1.32.1

package/eyeling.js

@@ -19,6 +19,8 @@
 
 const {
   RDF_NS,
+  RDFS_NS,
+  OWL_NS,
   XSD_NS,
   CRYPTO_NS,
   MATH_NS,
@@ -1046,6 +1048,9 @@ const XSD_HEX_BINARY_DT = XSD_NS + 'hexBinary';
 const XSD_BASE64_BINARY_DT = XSD_NS + 'base64Binary';
 const XSD_ANY_URI_DT = XSD_NS + 'anyURI';
 const RDF_LANGSTRING_DT = RDF_NS + 'langString';
+const RDF_PLAIN_LITERAL_DT = RDF_NS + 'PlainLiteral';
+const RDF_XML_LITERAL_DT = RDF_NS + 'XMLLiteral';
+const RDFS_LITERAL_DT = RDFS_NS + 'Literal';
 
 const XSD_STRING_LIKE_DTS = new Set([
   XSD_STRING_DT,
@@ -1074,6 +1079,9 @@ const XSD_INTEGER_BOUNDS = new Map([
 
 const XSD_DATATYPE_BUILTIN_DTS = new Set([
   RDF_LANGSTRING_DT,
+  RDF_PLAIN_LITERAL_DT,
+  RDF_XML_LITERAL_DT,
+  RDFS_LITERAL_DT,
   XSD_STRING_DT,
   XSD_NS + 'normalizedString',
   XSD_NS + 'token',
@@ -1095,6 +1103,11 @@ const XSD_DATATYPE_BUILTIN_DTS = new Set([
 ]);
 
 
+const XSD_FLOAT_MAX_VALUE = 3.4028234663852886e38;
+const XSD_FLOAT_MIN_POSITIVE_VALUE = 1.401298464324817e-45;
+const XSD_DOUBLE_MAX_VALUE = Number.MAX_VALUE;
+const XSD_DOUBLE_MIN_POSITIVE_VALUE = Number.MIN_VALUE;
+
 // Integer-derived datatypes from XML Schema Part 2 (and commonly used ones).
 const XSD_INTEGER_DERIVED_DTS = new Set([
   XSD_INTEGER_DT,
@@ -1153,13 +1166,31 @@ function inferDatatypeForShorthandLexical(lex) {
 
 function extractLiteralLanguageTag(litVal) {
   if (typeof litVal !== 'string' || !literalHasLangTag(litVal)) return null;
-  const lastQuote = litVal.lastIndexOf('"');
+
+  let lastQuote;
+  let quoteLen;
+  if (litVal.startsWith('\"\"\"')) {
+    lastQuote = litVal.lastIndexOf('\"\"\"');
+    quoteLen = 3;
+  } else {
+    lastQuote = litVal.lastIndexOf('"');
+    quoteLen = 1;
+  }
+
   if (lastQuote < 0) return null;
-  const after = lastQuote + 1;
+  const after = lastQuote + quoteLen;
   if (after >= litVal.length || litVal[after] !== '@') return null;
   const tag = litVal.slice(after + 1);
-  if (!/^[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--(?:ltr|rtl))?$/.test(tag)) return null;
-  return tag;
+  if (!isValidLanguageTag(tag, true)) return null;
+  return tag.toLowerCase();
+}
+
+function isValidLanguageTag(tag, allowDirectionalSuffix) {
+  if (typeof tag !== 'string') return false;
+  const pattern = allowDirectionalSuffix
+    ? /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*(?:--(?:ltr|rtl))?$/
+    : /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/;
+  return pattern.test(tag);
 }
 
 function literalLexicalValue(litVal) {
@@ -1218,17 +1249,18 @@ function canonicalFloatDoubleLex(n) {
 }
 
 function parseStringLikeDatatypeValue(lexical, dt) {
-  let value = String(lexical);
+  const value = String(lexical);
 
   if (dt === XSD_NS + 'normalizedString') {
-    value = value.replace(/[\t\n\r]/g, ' ');
+    if (/[\t\n\r]/.test(value)) return null;
   } else if (dt !== XSD_STRING_DT) {
-    value = value.replace(/[\t\n\r ]+/g, ' ').trim();
+    // String-derived datatypes with whitespace facet collapse are considered
+    // lexically valid only when the spelling is already in collapsed form.
+    if (/[\t\n\r]/.test(value) || /^ | $/.test(value) || / {2,}/.test(value)) return null;
   }
 
   if (dt === XSD_NS + 'language') {
-    if (!/^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/.test(value)) return null;
-    value = value.toLowerCase();
+    if (!isValidLanguageTag(value, false)) return null;
   } else if (dt === XSD_NS + 'Name') {
     if (!/^[:_\p{L}][:_\p{L}\p{N}.\-\u00B7\u0300-\u036F\u203F-\u2040]*$/u.test(value)) return null;
   } else if (dt === XSD_NS + 'NCName') {
@@ -1240,9 +1272,51 @@ function parseStringLikeDatatypeValue(lexical, dt) {
   return {
     family: 'string',
     dt,
-    value,
-    canonicalLex: value,
-    canonicalLiteral: makeDatatypeTypedLiteral(value, dt),
+    value: dt === XSD_NS + 'language' ? value.toLowerCase() : value,
+    canonicalLex: dt === XSD_NS + 'language' ? value.toLowerCase() : value,
+    canonicalLiteral: makeDatatypeTypedLiteral(dt === XSD_NS + 'language' ? value.toLowerCase() : value, dt),
+    comparable: true,
+  };
+}
+
+function parsePlainLiteralDatatypeValue(lexical) {
+  const parsed = splitPlainLiteralLexical(lexical);
+  if (!parsed) return null;
+  const canonicalLex = `${parsed.text}@${parsed.lang}`;
+  return {
+    family: 'plainLiteral',
+    dt: RDF_PLAIN_LITERAL_DT,
+    value: parsed.text,
+    lang: parsed.lang,
+    canonicalLex,
+    canonicalLiteral: makeDatatypeTypedLiteral(canonicalLex, RDF_PLAIN_LITERAL_DT),
+    comparable: true,
+  };
+}
+
+function splitPlainLiteralLexical(lexical) {
+  const s = String(lexical);
+  const at = s.lastIndexOf('@');
+  // rdf:PlainLiteral lexical forms encode the literal as text + "@" +
+  // language-tag.  The language tag may be empty, e.g. "abc@".
+  // A lexical with no separator at all, e.g. "abc", is ill-typed.
+  if (at < 0) return null;
+  const text = s.slice(0, at);
+  const lang = s.slice(at + 1);
+  if (lang !== '' && !isValidLanguageTag(lang, false)) return null;
+  return { text, lang: lang.toLowerCase() };
+}
+
+function parseXmlLiteralDatatypeValue(lexical) {
+  const s = String(lexical);
+  if (!isWellFormedXmlFragment(s)) return null;
+  const canonicalLex = s.trim();
+  return {
+    family: 'xmlLiteral',
+    dt: RDF_XML_LITERAL_DT,
+    value: canonicalLex,
+    canonicalLex,
+    canonicalLiteral: makeDatatypeTypedLiteral(canonicalLex, RDF_XML_LITERAL_DT),
     comparable: true,
   };
 }
@@ -1330,6 +1404,11 @@ function parseFloatDoubleDatatypeValue(lexical, dt) {
   const special = parseXsdFloatSpecialLex(s);
   const value = special !== null ? special : Number(s);
   if (Number.isNaN(value) && s !== 'NaN') return null;
+  if (Number.isFinite(value)) {
+    const abs = Math.abs(value);
+    if (dt === XSD_FLOAT_DT && abs > 0 && (abs > XSD_FLOAT_MAX_VALUE || abs < XSD_FLOAT_MIN_POSITIVE_VALUE)) return null;
+    if (dt === XSD_DOUBLE_DT && abs > 0 && (abs > XSD_DOUBLE_MAX_VALUE || abs < XSD_DOUBLE_MIN_POSITIVE_VALUE)) return null;
+  }
   const canonicalLex = canonicalFloatDoubleLex(value);
   return {
     family: 'numeric',
@@ -1419,7 +1498,11 @@ function parseBinaryDatatypeValue(lexical, dt) {
 
 function parseAnyUriDatatypeValue(lexical) {
   const value = String(lexical);
-  if (/[\u0000-\u001F\u007F]/.test(value)) return null;
+  if (/[^\u0021-\u007E]/.test(value) || /[<>"{}|\\^`]/.test(value)) return null;
+  for (let i = 0; i < value.length; i += 1) {
+    if (value[i] === '%' && !/^[0-9A-Fa-f]{2}$/.test(value.slice(i + 1, i + 3))) return null;
+  }
+  if (!isValidIriReferenceLexical(value)) return null;
   return {
     family: 'anyURI',
     dt: XSD_ANY_URI_DT,
@@ -1430,6 +1513,116 @@ function parseAnyUriDatatypeValue(lexical) {
   };
 }
 
+function isValidIriReferenceLexical(value) {
+  // Minimal RFC 3987/3986 structural check for IRI references.  In
+  // particular, a relative reference may not start with a colon-bearing first
+  // path segment such as ":abc"; this is the OWL 2 RL anyURI illtyped case.
+  // Empty references and fragment-only references are allowed.
+  const s = String(value);
+  if (s === '') return true;
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(s)) return true; // absolute scheme
+  if (s.startsWith('//') || s.startsWith('/') || s.startsWith('?') || s.startsWith('#')) return true;
+  const cut = s.search(/[/?#]/);
+  const firstSegment = cut < 0 ? s : s.slice(0, cut);
+  return !firstSegment.includes(':');
+}
+
+function isWellFormedXmlFragment(input) {
+  const source = String(input).trim();
+  if (!source) return false;
+  const stack = [];
+  let seenElement = false;
+  let position = 0;
+
+  while (position < source.length) {
+    const open = source.indexOf('<', position);
+    if (open < 0) return stack.length === 0 && isValidXmlText(source.slice(position)) && seenElement;
+    if (!isValidXmlText(source.slice(position, open))) return false;
+
+    if (source.startsWith('<!--', open)) {
+      const close = source.indexOf('-->', open + 4);
+      if (close < 0 || source.slice(open + 4, close).includes('--')) return false;
+      position = close + 3;
+      continue;
+    }
+
+    if (source.startsWith('<![CDATA[', open)) {
+      const close = source.indexOf(']]>', open + 9);
+      if (close < 0) return false;
+      position = close + 3;
+      continue;
+    }
+
+    if (source.startsWith('<?', open)) {
+      const close = source.indexOf('?>', open + 2);
+      if (close < 0) return false;
+      position = close + 2;
+      continue;
+    }
+
+    if (source.startsWith('</', open)) {
+      const close = source.indexOf('>', open + 2);
+      if (close < 0) return false;
+      const name = source.slice(open + 2, close).trim();
+      if (!isValidXmlName(name) || stack.pop() !== name) return false;
+      position = close + 1;
+      continue;
+    }
+
+    const close = findXmlTagEnd(source, open + 1);
+    if (close < 0) return false;
+    const raw = source.slice(open + 1, close);
+    const selfClosing = /\/\s*$/.test(raw);
+    const content = selfClosing ? raw.replace(/\/\s*$/, '').trim() : raw.trim();
+    const nameMatch = /^([^\s/>]+)/.exec(content);
+    if (!nameMatch || !isValidXmlName(nameMatch[1]) || !areValidXmlAttributes(content.slice(nameMatch[0].length))) return false;
+    seenElement = true;
+    if (!selfClosing) stack.push(nameMatch[1]);
+    position = close + 1;
+  }
+
+  return stack.length === 0 && seenElement;
+}
+
+function findXmlTagEnd(source, start) {
+  let quote = null;
+  for (let i = start; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === '>') {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function areValidXmlAttributes(source) {
+  let rest = String(source).trim();
+  const seen = new Set();
+  while (rest) {
+    const m = /^([A-Za-z_:\u0080-\uFFFF][A-Za-z0-9_.:\-\u0080-\uFFFF]*)\s*=\s*("[^"]*"|'[^']*')\s*/u.exec(rest);
+    if (!m || seen.has(m[1]) || !isValidXmlAttributeValue(m[2].slice(1, -1))) return false;
+    seen.add(m[1]);
+    rest = rest.slice(m[0].length).trim();
+  }
+  return true;
+}
+
+function isValidXmlAttributeValue(value) {
+  return !/[<]/.test(value) && isValidXmlText(value);
+}
+
+function isValidXmlText(value) {
+  return !/[<&]/.test(String(value).replace(/&(?:amp|lt|gt|quot|apos|#\d+|#x[0-9A-Fa-f]+);/g, ''));
+}
+
+function isValidXmlName(name) {
+  return /^[A-Za-z_:\u0080-\uFFFF][A-Za-z0-9_.:\-\u0080-\uFFFF]*$/u.test(name) && !/^xml$/i.test(name);
+}
+
 function isLeapYearBigInt(year) {
   if (year % 400n === 0n) return true;
   if (year % 100n === 0n) return false;
@@ -1586,11 +1779,33 @@ function parseLangStringDatatypeValue(t, lexical) {
   };
 }
 
+function literalTermDatatypeKey(t) {
+  return `${literalLexicalValue(t.value)}^^${literalDatatypeIri(t) || ''}`;
+}
+
 function parseDatatypeValueForDatatype(t, dt) {
   if (!(t instanceof Literal) || typeof dt !== 'string' || !isSupportedDatatypeIri(dt)) return null;
+
+  if (dt === RDFS_LITERAL_DT) {
+    const ownDt = literalDatatypeIri(t);
+    if (ownDt === null || !isSupportedDatatypeIri(ownDt)) return null;
+    const ownValue = parseDatatypeValueForDatatype(t, ownDt);
+    if (!ownValue) return null;
+    return {
+      family: 'literal',
+      dt: RDFS_LITERAL_DT,
+      value: literalTermDatatypeKey(t),
+      canonicalLex: literalLexicalValue(t.value),
+      canonicalLiteral: t,
+      comparable: false,
+    };
+  }
+
   const lexical = literalLexicalValue(t.value);
 
   if (dt === RDF_LANGSTRING_DT) return parseLangStringDatatypeValue(t, lexical);
+  if (dt === RDF_PLAIN_LITERAL_DT) return parsePlainLiteralDatatypeValue(lexical);
+  if (dt === RDF_XML_LITERAL_DT) return parseXmlLiteralDatatypeValue(lexical);
   if (literalHasLangTag(t.value)) return null;
   if (XSD_STRING_LIKE_DTS.has(dt)) return parseStringLikeDatatypeValue(lexical, dt);
   if (dt === XSD_BOOLEAN_DT) return parseBooleanDatatypeValue(lexical);
@@ -1616,10 +1831,11 @@ function compareDecimalExactValues(a, b) {
 
 function datatypeValuesSame(a, b) {
   if (!a || !b || !a.comparable || !b.comparable) return false;
-  if (a.family === 'langString' || b.family === 'langString') {
+  if (a.family === 'langString' || b.family === 'langString' || a.family === 'plainLiteral' || b.family === 'plainLiteral') {
     return a.family === b.family && a.value === b.value && a.lang === b.lang;
   }
   if (a.family === 'string' && b.family === 'string') return a.value === b.value;
+  if (a.family === 'xmlLiteral' && b.family === 'xmlLiteral') return a.value === b.value;
   if (a.family === 'boolean' && b.family === 'boolean') return a.value === b.value;
   if (a.family === 'anyURI' && b.family === 'anyURI') return a.value === b.value;
   if (a.family === 'binary' && b.family === 'binary') {
@@ -1646,7 +1862,9 @@ function datatypeValuesSame(a, b) {
 function datatypeValuesComparable(a, b) {
   if (!a || !b || !a.comparable || !b.comparable) return false;
   if (a.family === 'dateTime' && b.family === 'dateTime' && a.hasTimezone !== b.hasTimezone) return false;
+  if (a.family === 'numeric' && b.family === 'numeric') return true;
   if (a.family === 'langString' || b.family === 'langString') return a.family === b.family;
+  if (a.family === 'plainLiteral' || b.family === 'plainLiteral') return a.family === b.family;
   if (a.family === 'string' || b.family === 'string') return a.family === b.family;
   return a.family === b.family;
 }
@@ -1670,6 +1888,17 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
+    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
+
+    // OWL 2 RL datatype rules often need common string literals to also
+    // participate in generic literal comparisons, while application rules still
+    // ask for their precise datatype explicitly.  When the datatype output is
+    // unbound, expose rdfs:Literal as an additional super-datatype answer for
+    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
+    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
+      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
+    }
+    return out;
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -1738,6 +1967,57 @@ function evalDatatypeValueComparisonBuiltin(g, subst, same) {
   return [];
 }
 
+function evalOwlSameAsBuiltin(g, subst, facts, maxResults) {
+  const out = [];
+  const seen = new Set();
+  const limit = typeof maxResults === 'number' && maxResults > 0 ? maxResults : Infinity;
+
+  function addPair(left, right) {
+    if (out.length >= limit) return true;
+    const key = `${termFastKey ? termFastKey(left) : termToN3(left)} ${termFastKey ? termFastKey(right) : termToN3(right)}`;
+    if (seen.has(key)) return false;
+    let s2 = unifyTerm(g.s, left, subst);
+    if (s2 === null) return false;
+    s2 = unifyTerm(g.o, right, s2);
+    if (s2 === null) return false;
+    seen.add(key);
+    out.push(s2);
+    return out.length >= limit;
+  }
+
+  function addReflexive(term) {
+    return addPair(term, term);
+  }
+
+  const sameAsIri = OWL_NS + 'sameAs';
+  const differentFromIri = OWL_NS + 'differentFrom';
+
+  for (const tr of facts || []) {
+    if (tr && tr.p instanceof Iri && tr.p.value === sameAsIri) {
+      if (addPair(tr.s, tr.o)) return out;
+    }
+  }
+
+  // owl:sameAs is reflexive.  Avoid enumerating the entire active term universe
+  // for fully-unbound goals; only add the reflexive pairs that are immediately
+  // needed to detect explicit self-diversity (?x owl:differentFrom ?x).
+  if (!(g.s instanceof Var) && !(g.o instanceof Var)) {
+    if (termsEqual(g.s, g.o)) addReflexive(g.s);
+  } else if (!(g.s instanceof Var)) {
+    addReflexive(g.s);
+  } else if (!(g.o instanceof Var)) {
+    addReflexive(g.o);
+  } else {
+    for (const tr of facts || []) {
+      if (tr && tr.p instanceof Iri && tr.p.value === differentFromIri && termsEqual(tr.s, tr.o)) {
+        if (addReflexive(tr.s)) return out;
+      }
+    }
+  }
+
+  return out;
+}
+
 // ===========================================================================
 // Math builtin helpers
 // ===========================================================================
@@ -2877,6 +3157,8 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   const pv = iriValue(g.p);
   if (pv === null) return null;
 
+  if (pv === OWL_NS + 'sameAs') return evalOwlSameAsBuiltin(g, subst, facts, maxResults);
+
   // Super restricted mode: disable *all* builtins except => / <= (log:implies / log:impliedBy)
   if (typeof getSuperRestrictedMode === 'function' && getSuperRestrictedMode()) {
     const allow1 = LOG_NS + 'implies';
@@ -5219,6 +5501,7 @@ function isBuiltinPred(p) {
   }
 
   if (__customBuiltinHandlers.has(v)) return true;
+  if (v === OWL_NS + 'sameAs') return true;
 
   return (
     v.startsWith(CRYPTO_NS) ||
@@ -16909,7 +17192,8 @@ function termEquals(self, other) {
       !!self.datatype &&
       typeof self.datatype.equals === 'function' &&
       self.datatype.equals(other.datatype) &&
-      self.language === (other.language || '')
+      self.language === (other.language || '') &&
+      (self.direction || '') === (other.direction || '')
     );
   }
 
@@ -16974,6 +17258,7 @@ class Literal {
     this.termType = 'Literal';
     this.value = String(value);
     this.language = '';
+    this.direction = '';
     this.datatype = null;
 
     if (typeof languageOrDatatype === 'string') {
@@ -16981,6 +17266,10 @@ class Literal {
       this.datatype = new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
     } else if (isRdfJsTerm(languageOrDatatype)) {
       this.datatype = languageOrDatatype;
+    } else if (languageOrDatatype && typeof languageOrDatatype === 'object') {
+      this.language = String(languageOrDatatype.language || '');
+      this.direction = languageOrDatatype.direction || '';
+      this.datatype = new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
     } else {
       this.datatype = new NamedNode(XSD_NS + 'string');
     }
@@ -17027,6 +17316,38 @@ const dataFactory = {
   quad(subject, predicate, object, graph) {
     return new Quad(subject, predicate, object, graph || defaultGraphSingleton);
   },
+  fromTerm(original) {
+    if (!isRdfJsTerm(original)) throw new TypeError('Expected an RDF/JS term');
+
+    switch (original.termType) {
+      case 'NamedNode':
+        return new NamedNode(original.value);
+      case 'BlankNode':
+        return new BlankNode(original.value);
+      case 'Literal':
+        if (original.language || original.direction) {
+          return new Literal(original.value, { language: original.language || '', direction: original.direction || '' });
+        }
+        return new Literal(original.value, original.datatype ? dataFactory.fromTerm(original.datatype) : undefined);
+      case 'Variable':
+        return new Variable(original.value);
+      case 'DefaultGraph':
+        return defaultGraphSingleton;
+      case 'Quad':
+        return dataFactory.fromQuad(original);
+      default:
+        throw new TypeError(`Unsupported RDF/JS termType ${JSON.stringify(original.termType)}`);
+    }
+  },
+  fromQuad(original) {
+    if (!isRdfJsQuad(original)) throw new TypeError('Expected an RDF/JS Quad');
+    return new Quad(
+      dataFactory.fromTerm(original.subject),
+      dataFactory.fromTerm(original.predicate),
+      dataFactory.fromTerm(original.object),
+      dataFactory.fromTerm(original.graph),
+    );
+  },
 };
 
 function getDataFactory(factory) {