eyeling 1.9.1 → 1.9.2

package/eyeling.js

@@ -2484,948 +2484,620 @@ function reorderPremiseForConstraints(premise) {
 // @ts-nocheck
 /* eslint-disable */
 // ===========================================================================
-// Unification + substitution
+// BUILTINS
 // ===========================================================================
-function containsVarTerm(t, v) {
-    if (t instanceof Var)
-        return t.name === v;
-    if (t instanceof ListTerm)
-        return t.elems.some((e) => containsVarTerm(e, v));
-    if (t instanceof OpenListTerm)
-        return t.prefix.some((e) => containsVarTerm(e, v)) || t.tailVar === v;
-    if (t instanceof GraphTerm)
-        return t.triples.some((tr) => containsVarTerm(tr.s, v) || containsVarTerm(tr.p, v) || containsVarTerm(tr.o, v));
-    return false;
+function literalParts(lit) {
+    const cached = __literalPartsCache.get(lit);
+    if (cached)
+        return cached;
+    // Split a literal into lexical form and datatype IRI (if any).
+    // Also strip an optional language tag from the lexical form:
+    //   "\"hello\"@en"  -> "\"hello\""
+    //   "\"hello\"@en^^<...>" is rejected earlier in the parser.
+    const idx = lit.indexOf('^^');
+    let lex = lit;
+    let dt = null;
+    if (idx >= 0) {
+        lex = lit.slice(0, idx);
+        dt = lit.slice(idx + 2).trim();
+        if (dt.startsWith('<') && dt.endsWith('>')) {
+            dt = dt.slice(1, -1);
+        }
+    }
+    // Strip LANGTAG from the lexical form when present.
+    if (lex.length >= 2 && lex[0] === '"') {
+        const lastQuote = lex.lastIndexOf('"');
+        if (lastQuote > 0 && lastQuote < lex.length - 1 && lex[lastQuote + 1] === '@') {
+            const lang = lex.slice(lastQuote + 2);
+            if (/^[A-Za-z]+(?:-[A-Za-z0-9]+)*$/.test(lang)) {
+                lex = lex.slice(0, lastQuote + 1);
+            }
+        }
+    }
+    const res = [lex, dt];
+    __literalPartsCache.set(lit, res);
+    return res;
 }
-function isGroundTermInGraph(t) {
-    // variables inside graph terms are treated as local placeholders,
-    // so they don't make the *surrounding triple* non-ground.
-    if (t instanceof OpenListTerm)
+function literalHasLangTag(lit) {
+    // True iff the literal is a quoted string literal with a language tag suffix,
+    // e.g. "hello"@en or """hello"""@en.
+    // (The parser rejects language tags combined with datatypes.)
+    if (typeof lit !== 'string')
         return false;
-    if (t instanceof ListTerm)
-        return t.elems.every((e) => isGroundTermInGraph(e));
-    if (t instanceof GraphTerm)
-        return t.triples.every((tr) => isGroundTripleInGraph(tr));
-    // Iri/Literal/Blank/Var are all OK inside formulas
-    return true;
-}
-function isGroundTripleInGraph(tr) {
-    return isGroundTermInGraph(tr.s) && isGroundTermInGraph(tr.p) && isGroundTermInGraph(tr.o);
-}
-function isGroundTerm(t) {
-    if (t instanceof Var)
+    if (lit.indexOf('^^') >= 0)
         return false;
-    if (t instanceof ListTerm)
-        return t.elems.every((e) => isGroundTerm(e));
-    if (t instanceof OpenListTerm)
+    if (!lit.startsWith('"'))
         return false;
-    if (t instanceof GraphTerm)
-        return t.triples.every((tr) => isGroundTripleInGraph(tr));
-    return true;
+    if (lit.startsWith('"""')) {
+        const end = lit.lastIndexOf('"""');
+        if (end < 0)
+            return false;
+        const after = end + 3;
+        return after < lit.length && lit[after] === '@';
+    }
+    const lastQuote = lit.lastIndexOf('"');
+    if (lastQuote < 0)
+        return false;
+    const after = lastQuote + 1;
+    return after < lit.length && lit[after] === '@';
 }
-function isGroundTriple(tr) {
-    return isGroundTerm(tr.s) && isGroundTerm(tr.p) && isGroundTerm(tr.o);
+function isPlainStringLiteralValue(lit) {
+    // Plain string literal: quoted, no datatype, no lang.
+    if (typeof lit !== 'string')
+        return false;
+    if (lit.indexOf('^^') >= 0)
+        return false;
+    if (!isQuotedLexical(lit))
+        return false;
+    return !literalHasLangTag(lit);
 }
-// Canonical JSON-ish encoding for use as a Skolem cache key.
-// We only *call* this on ground terms in log:skolem, but it is
-// robust to seeing vars/open lists anyway.
-function skolemKeyFromTerm(t) {
-    function enc(u) {
-        if (u instanceof Iri)
-            return ['I', u.value];
-        if (u instanceof Literal)
-            return ['L', u.value];
-        if (u instanceof Blank)
-            return ['B', u.label];
-        if (u instanceof Var)
-            return ['V', u.name];
-        if (u instanceof ListTerm)
-            return ['List', u.elems.map(enc)];
-        if (u instanceof OpenListTerm)
-            return ['OpenList', u.prefix.map(enc), u.tailVar];
-        if (u instanceof GraphTerm)
-            return ['Graph', u.triples.map((tr) => [enc(tr.s), enc(tr.p), enc(tr.o)])];
-        return ['Other', String(u)];
-    }
-    return JSON.stringify(enc(t));
+function literalsEquivalentAsXsdString(aLit, bLit) {
+    // Treat "abc" and "abc"^^xsd:string as equal, but do NOT conflate language-tagged strings.
+    if (typeof aLit !== 'string' || typeof bLit !== 'string')
+        return false;
+    const [alex, adt] = literalParts(aLit);
+    const [blex, bdt] = literalParts(bLit);
+    if (alex !== blex)
+        return false;
+    const aPlain = adt === null && isPlainStringLiteralValue(aLit);
+    const bPlain = bdt === null && isPlainStringLiteralValue(bLit);
+    const aXsdStr = adt === XSD_NS + 'string';
+    const bXsdStr = bdt === XSD_NS + 'string';
+    return (aPlain && bXsdStr) || (bPlain && aXsdStr);
 }
-function applySubstTerm(t, s) {
-    // Common case: variable
-    if (t instanceof Var) {
-        // Fast path: unbound variable → no change
-        const first = s[t.name];
-        if (first === undefined) {
-            return t;
-        }
-        // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
-        let cur = first;
-        const seen = new Set([t.name]);
-        while (cur instanceof Var) {
-            const name = cur.name;
-            if (seen.has(name))
-                break; // cycle
-            seen.add(name);
-            const nxt = s[name];
-            if (!nxt)
-                break;
-            cur = nxt;
-        }
-        if (cur instanceof Var) {
-            // Still a var: keep it as is (no need to clone)
-            return cur;
-        }
-        // Bound to a non-var term: apply substitution recursively in case it
-        // contains variables inside.
-        return applySubstTerm(cur, s);
+function normalizeLiteralForFastKey(lit) {
+    // Canonicalize so that "abc" and "abc"^^xsd:string share the same index/dedup key.
+    if (typeof lit !== 'string')
+        return lit;
+    const [lex, dt] = literalParts(lit);
+    if (dt === XSD_NS + 'string') {
+        return `${lex}^^<${XSD_NS}string>`;
     }
-    // Non-variable terms
-    if (t instanceof ListTerm) {
-        return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
+    if (dt === null && isPlainStringLiteralValue(lit)) {
+        return `${lex}^^<${XSD_NS}string>`;
     }
-    if (t instanceof OpenListTerm) {
-        const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
-        const tailTerm = s[t.tailVar];
-        if (tailTerm !== undefined) {
-            const tailApplied = applySubstTerm(tailTerm, s);
-            if (tailApplied instanceof ListTerm) {
-                return new ListTerm(newPrefix.concat(tailApplied.elems));
-            }
-            else if (tailApplied instanceof OpenListTerm) {
-                return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
-            }
-            else {
-                return new OpenListTerm(newPrefix, t.tailVar);
-            }
-        }
-        else {
-            return new OpenListTerm(newPrefix, t.tailVar);
-        }
+    return lit;
+}
+function stripQuotes(lex) {
+    if (typeof lex !== 'string')
+        return lex;
+    // Handle both short ('...' / "...") and long ('''...''' / """...""") forms.
+    if (lex.length >= 6) {
+        if (lex.startsWith('"""') && lex.endsWith('"""'))
+            return lex.slice(3, -3);
+        if (lex.startsWith("'''") && lex.endsWith("'''"))
+            return lex.slice(3, -3);
     }
-    if (t instanceof GraphTerm) {
-        return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
+    if (lex.length >= 2) {
+        const a = lex[0];
+        const b = lex[lex.length - 1];
+        if ((a === '"' && b === '"') || (a === "'" && b === "'"))
+            return lex.slice(1, -1);
     }
-    return t;
-}
-function applySubstTriple(tr, s) {
-    return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
-}
-function iriValue(t) {
-    return t instanceof Iri ? t.value : null;
+    return lex;
 }
-function unifyOpenWithList(prefix, tailv, ys, subst) {
-    if (ys.length < prefix.length)
+function termToJsXsdStringNoLang(t) {
+    // Strict xsd:string extraction *without* language tags.
+    // Accept:
+    //   - plain string literals ("...")
+    //   - "..."^^xsd:string
+    // Reject:
+    //   - language-tagged strings ("..."@en)
+    //   - any other datatype
+    if (!(t instanceof Literal))
         return null;
-    let s2 = { ...subst };
-    for (let i = 0; i < prefix.length; i++) {
-        s2 = unifyTerm(prefix[i], ys[i], s2);
-        if (s2 === null)
-            return null;
-    }
-    const rest = new ListTerm(ys.slice(prefix.length));
-    s2 = unifyTerm(new Var(tailv), rest, s2);
-    if (s2 === null)
+    if (literalHasLangTag(t.value))
         return null;
-    return s2;
-}
-function unifyGraphTriples(xs, ys, subst) {
-    if (xs.length !== ys.length)
+    const [lex, dt] = literalParts(t.value);
+    if (!isQuotedLexical(lex))
         return null;
-    // Fast path: exact same sequence.
-    if (triplesListEqual(xs, ys))
-        return { ...subst };
-    // Backtracking match (order-insensitive), *threading* the substitution through.
-    const used = new Array(ys.length).fill(false);
-    function step(i, s) {
-        if (i >= xs.length)
-            return s;
-        const x = xs[i];
-        for (let j = 0; j < ys.length; j++) {
-            if (used[j])
-                continue;
-            const y = ys[j];
-            // Cheap pruning when both predicates are IRIs.
-            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
-                continue;
-            const s2 = unifyTriple(x, y, s); // IMPORTANT: use `s`, not {}
-            if (s2 === null)
-                continue;
-            used[j] = true;
-            const s3 = step(i + 1, s2);
-            if (s3 !== null)
-                return s3;
-            used[j] = false;
-        }
+    if (dt !== null && dt !== XSD_NS + 'string' && dt !== 'xsd:string')
+        return null;
+    return decodeN3StringEscapes(stripQuotes(lex));
+}
+function termToJsString(t) {
+    // Domain is xsd:string for SWAP/N3 string builtins (string:*).
+    //
+    // Per the N3 Builtins spec, when the domain is xsd:string we must be able to
+    // cast *any* IRI or literal value (incl. numeric, boolean, dateTime, anyURI,
+    // rdf:langString, and plain literals) to a string.
+    //
+    // We implement this as:
+    //   - IRI    -> its IRI string
+    //   - Literal:
+    //       * quoted lexical form: decode N3/Turtle escapes and strip quotes
+    //       * unquoted lexical form: use as-is (e.g., 1234, true, 1971-..., 1.23E4)
+    //   - Everything else (blank nodes, lists, formulas, vars) -> fail
+    if (t instanceof Iri)
+        return t.value;
+    if (!(t instanceof Literal))
         return null;
+    const [lex, _dt] = literalParts(t.value);
+    if (isQuotedLexical(lex)) {
+        // Interpret N3/Turtle string escapes (\" \n \uXXXX \UXXXXXXXX …)
+        // to obtain the actual string value.
+        return decodeN3StringEscapes(stripQuotes(lex));
     }
-    return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
+    // Unquoted lexical (numbers/booleans/dateTimes, etc.)
+    return typeof lex === 'string' ? lex : String(lex);
 }
-function unifyTerm(a, b, subst) {
-    return unifyTermWithOptions(a, b, subst, {
-        boolValueEq: true,
-        intDecimalEq: false,
-    });
+function makeStringLiteral(str) {
+    // JSON.stringify gives us a valid N3/Turtle-style quoted string
+    // (with proper escaping for quotes, backslashes, newlines, …).
+    return internLiteral(JSON.stringify(str));
 }
-function unifyTermListAppend(a, b, subst) {
-    // Keep list:append behavior: allow integer<->decimal exact equality,
-    // but do NOT add boolean-value equivalence (preserves current semantics).
-    return unifyTermWithOptions(a, b, subst, {
-        boolValueEq: false,
-        intDecimalEq: true,
-    });
+function termToJsStringDecoded(t) {
+    // Like termToJsString, but for short literals it *also* interprets escapes
+    // (\" \n \uXXXX …) by attempting JSON.parse on the quoted lexical form.
+    if (!(t instanceof Literal))
+        return null;
+    const [lex, _dt] = literalParts(t.value);
+    // Long strings: """ ... """ are taken verbatim.
+    if (lex.length >= 6 && lex.startsWith('"""') && lex.endsWith('"""')) {
+        return lex.slice(3, -3);
+    }
+    // Short strings: try to decode escapes (this makes "{\"a\":1}" usable too).
+    if (lex.length >= 2 && lex[0] === '"' && lex[lex.length - 1] === '"') {
+        try {
+            return JSON.parse(lex);
+        }
+        catch (e) {
+            /* fall through */
+        }
+        return stripQuotes(lex);
+    }
+    return stripQuotes(lex);
 }
-function unifyTermWithOptions(a, b, subst, opts) {
-    a = applySubstTerm(a, subst);
-    b = applySubstTerm(b, subst);
-    // Variable binding
-    if (a instanceof Var) {
-        const v = a.name;
-        const t = b;
-        if (t instanceof Var && t.name === v)
-            return { ...subst };
-        if (containsVarTerm(t, v))
+function jsonPointerUnescape(seg) {
+    // RFC6901: ~1 -> '/', ~0 -> '~'
+    let out = '';
+    for (let i = 0; i < seg.length; i++) {
+        const c = seg[i];
+        if (c !== '~') {
+            out += c;
+            continue;
+        }
+        if (i + 1 >= seg.length)
             return null;
-        const s2 = { ...subst };
-        s2[v] = t;
-        return s2;
-    }
-    if (b instanceof Var) {
-        return unifyTermWithOptions(b, a, subst, opts);
+        const n = seg[i + 1];
+        if (n === '0')
+            out += '~';
+        else if (n === '1')
+            out += '/';
+        else
+            return null;
+        i++;
     }
-    // Exact matches
-    if (a instanceof Iri && b instanceof Iri && a.value === b.value)
-        return { ...subst };
-    if (a instanceof Literal && b instanceof Literal && a.value === b.value)
-        return { ...subst };
-    if (a instanceof Blank && b instanceof Blank && a.label === b.label)
-        return { ...subst };
-    // Plain string vs xsd:string equivalence
-    if (a instanceof Literal && b instanceof Literal) {
-        if (literalsEquivalentAsXsdString(a.value, b.value))
-            return { ...subst };
+    return out;
+}
+function jsonToTerm(v) {
+    if (v === null)
+        return makeStringLiteral('null');
+    if (typeof v === 'string')
+        return makeStringLiteral(v);
+    if (typeof v === 'number')
+        return internLiteral(String(v));
+    if (typeof v === 'boolean')
+        return internLiteral(v ? 'true' : 'false');
+    if (Array.isArray(v))
+        return new ListTerm(v.map(jsonToTerm));
+    if (v && typeof v === 'object') {
+        return makeRdfJsonLiteral(JSON.stringify(v));
     }
-    // Boolean-value equivalence (ONLY for normal unifyTerm)
-    if (opts.boolValueEq && a instanceof Literal && b instanceof Literal) {
-        const ai = parseBooleanLiteralInfo(a);
-        const bi = parseBooleanLiteralInfo(b);
-        if (ai && bi && ai.value === bi.value)
-            return { ...subst };
+    return null;
+}
+function jsonPointerLookup(jsonText, pointer) {
+    let ptr = pointer;
+    // Support URI fragment form "#/a/b"
+    if (ptr.startsWith('#')) {
+        try {
+            ptr = decodeURIComponent(ptr.slice(1));
+        }
+        catch {
+            return null;
+        }
     }
-    // Numeric-value match:
-    // - always allow equality when datatype matches (existing behavior)
-    // - optionally allow integer<->decimal exact equality (list:append only)
-    if (a instanceof Literal && b instanceof Literal) {
-        const ai = parseNumericLiteralInfo(a);
-        const bi = parseNumericLiteralInfo(b);
-        if (ai && bi) {
-            if (ai.dt === bi.dt) {
-                if (ai.kind === 'bigint' && bi.kind === 'bigint') {
-                    if (ai.value === bi.value)
-                        return { ...subst };
-                }
-                else {
-                    const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-                    const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-                    if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn)
-                        return { ...subst };
-                }
-            }
-            if (opts.intDecimalEq) {
-                const intDt = XSD_NS + 'integer';
-                const decDt = XSD_NS + 'decimal';
-                if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
-                    const intInfo = ai.dt === intDt ? ai : bi; // bigint
-                    const decInfo = ai.dt === decDt ? ai : bi; // number + lexStr
-                    const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
-                    if (dec) {
-                        const scaledInt = intInfo.value * pow10n(dec.scale);
-                        if (scaledInt === dec.num)
-                            return { ...subst };
-                    }
-                }
-            }
+    let entry = jsonPointerCache.get(jsonText);
+    if (!entry) {
+        let parsed = null;
+        try {
+            parsed = JSON.parse(jsonText);
+        }
+        catch {
+            parsed = null;
         }
+        entry = { parsed, ptrCache: new Map() };
+        jsonPointerCache.set(jsonText, entry);
     }
-    // Open list vs concrete list
-    if (a instanceof OpenListTerm && b instanceof ListTerm) {
-        return unifyOpenWithList(a.prefix, a.tailVar, b.elems, subst);
+    if (entry.parsed === null)
+        return null;
+    if (entry.ptrCache.has(ptr))
+        return entry.ptrCache.get(ptr);
+    let cur = entry.parsed;
+    if (ptr === '') {
+        const t = jsonToTerm(cur);
+        entry.ptrCache.set(ptr, t);
+        return t;
     }
-    if (a instanceof ListTerm && b instanceof OpenListTerm) {
-        return unifyOpenWithList(b.prefix, b.tailVar, a.elems, subst);
+    if (!ptr.startsWith('/')) {
+        entry.ptrCache.set(ptr, null);
+        return null;
     }
-    // Open list vs open list
-    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
-        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
+    const parts = ptr.split('/').slice(1);
+    for (const raw of parts) {
+        const seg = jsonPointerUnescape(raw);
+        if (seg === null) {
+            entry.ptrCache.set(ptr, null);
             return null;
-        let s2 = { ...subst };
-        for (let i = 0; i < a.prefix.length; i++) {
-            s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
-            if (s2 === null)
+        }
+        if (Array.isArray(cur)) {
+            if (!/^(0|[1-9]\d*)$/.test(seg)) {
+                entry.ptrCache.set(ptr, null);
+                return null;
+            }
+            const idx = Number(seg);
+            if (idx < 0 || idx >= cur.length) {
+                entry.ptrCache.set(ptr, null);
                 return null;
+            }
+            cur = cur[idx];
         }
-        return s2;
-    }
-    // List terms
-    if (a instanceof ListTerm && b instanceof ListTerm) {
-        if (a.elems.length !== b.elems.length)
-            return null;
-        let s2 = { ...subst };
-        for (let i = 0; i < a.elems.length; i++) {
-            s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
-            if (s2 === null)
+        else if (cur !== null && typeof cur === 'object') {
+            if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
+                entry.ptrCache.set(ptr, null);
                 return null;
+            }
+            cur = cur[seg];
+        }
+        else {
+            entry.ptrCache.set(ptr, null);
+            return null;
         }
-        return s2;
     }
-    // Graphs
-    if (a instanceof GraphTerm && b instanceof GraphTerm) {
-        if (alphaEqGraphTriples(a.triples, b.triples))
-            return { ...subst };
-        return unifyGraphTriples(a.triples, b.triples, subst);
-    }
-    return null;
-}
-function unifyTriple(pat, fact, subst) {
-    // Predicates are usually the cheapest and most selective
-    const s1 = unifyTerm(pat.p, fact.p, subst);
-    if (s1 === null)
-        return null;
-    const s2 = unifyTerm(pat.s, fact.s, s1);
-    if (s2 === null)
-        return null;
-    const s3 = unifyTerm(pat.o, fact.o, s2);
-    return s3;
+    const out = jsonToTerm(cur);
+    entry.ptrCache.set(ptr, out);
+    return out;
 }
-function composeSubst(outer, delta) {
-    if (!delta || Object.keys(delta).length === 0) {
-        return { ...outer };
-    }
-    const out = { ...outer };
-    for (const [k, v] of Object.entries(delta)) {
-        if (out.hasOwnProperty(k)) {
-            if (!termsEqual(out[k], v))
-                return null;
-        }
-        else {
-            out[k] = v;
+// Tiny subset of sprintf: supports only %s and %%.
+// Good enough for most N3 string:format use cases that just splice strings.
+function simpleStringFormat(fmt, args) {
+    let out = '';
+    let argIndex = 0;
+    for (let i = 0; i < fmt.length; i++) {
+        const ch = fmt[i];
+        if (ch === '%' && i + 1 < fmt.length) {
+            const spec = fmt[i + 1];
+            if (spec === 's') {
+                const arg = argIndex < args.length ? args[argIndex++] : '';
+                out += arg;
+                i++;
+                continue;
+            }
+            if (spec === '%') {
+                out += '%';
+                i++;
+                continue;
+            }
+            // Unsupported specifier (like %d, %f, …) ⇒ fail the builtin.
+            return null;
         }
+        out += ch;
     }
     return out;
 }
-// ===========================================================================
-// BUILTINS
-// ===========================================================================
-function literalParts(lit) {
-    const cached = __literalPartsCache.get(lit);
-    if (cached)
-        return cached;
-    // Split a literal into lexical form and datatype IRI (if any).
-    // Also strip an optional language tag from the lexical form:
-    //   "\"hello\"@en"  -> "\"hello\""
-    //   "\"hello\"@en^^<...>" is rejected earlier in the parser.
-    const idx = lit.indexOf('^^');
-    let lex = lit;
-    let dt = null;
-    if (idx >= 0) {
-        lex = lit.slice(0, idx);
-        dt = lit.slice(idx + 2).trim();
-        if (dt.startsWith('<') && dt.endsWith('>')) {
-            dt = dt.slice(1, -1);
-        }
+// -----------------------------------------------------------------------------
+// SWAP/N3 regex compatibility helper
+// -----------------------------------------------------------------------------
+function regexNeedsUnicodeMode(pattern) {
+    // JS requires /u for Unicode property escapes and code point escapes.
+    return /\\[pP]\{/.test(pattern) || /\\u\{/.test(pattern);
+}
+function sanitizeForUnicodeMode(pattern) {
+    // In JS Unicode mode, “identity escapes” like \! are a SyntaxError.
+    // In Perl-ish regexes they commonly mean “literal !”. So drop the redundant "\".
+    // Keep escapes that are regex-syntax or are commonly needed in char classes.
+    const KEEP = '^$\\.*+?()[]{}|/-';
+    return pattern.replace(/\\([^A-Za-z0-9])/g, (m, ch) => {
+        return KEEP.includes(ch) ? m : ch;
+    });
+}
+function compileSwapRegex(pattern, extraFlags) {
+    const needU = regexNeedsUnicodeMode(pattern);
+    const flags = (extraFlags || '') + (needU ? 'u' : '');
+    try {
+        return new RegExp(pattern, flags);
     }
-    // Strip LANGTAG from the lexical form when present.
-    if (lex.length >= 2 && lex[0] === '"') {
-        const lastQuote = lex.lastIndexOf('"');
-        if (lastQuote > 0 && lastQuote < lex.length - 1 && lex[lastQuote + 1] === '@') {
-            const lang = lex.slice(lastQuote + 2);
-            if (/^[A-Za-z]+(?:-[A-Za-z0-9]+)*$/.test(lang)) {
-                lex = lex.slice(0, lastQuote + 1);
+    catch (e) {
+        if (needU) {
+            const p2 = sanitizeForUnicodeMode(pattern);
+            if (p2 !== pattern) {
+                try {
+                    return new RegExp(p2, flags);
+                }
+                catch (_e2) { }
             }
         }
+        return null;
     }
-    const res = [lex, dt];
-    __literalPartsCache.set(lit, res);
-    return res;
 }
-function literalHasLangTag(lit) {
-    // True iff the literal is a quoted string literal with a language tag suffix,
-    // e.g. "hello"@en or """hello"""@en.
-    // (The parser rejects language tags combined with datatypes.)
-    if (typeof lit !== 'string')
-        return false;
-    if (lit.indexOf('^^') >= 0)
-        return false;
-    if (!lit.startsWith('"'))
-        return false;
-    if (lit.startsWith('"""')) {
-        const end = lit.lastIndexOf('"""');
-        if (end < 0)
-            return false;
-        const after = end + 3;
-        return after < lit.length && lit[after] === '@';
+// -----------------------------------------------------------------------------
+// Strict numeric literal parsing for math: builtins
+// -----------------------------------------------------------------------------
+const XSD_DECIMAL_DT = XSD_NS + 'decimal';
+const XSD_DOUBLE_DT = XSD_NS + 'double';
+const XSD_FLOAT_DT = XSD_NS + 'float';
+const XSD_INTEGER_DT = XSD_NS + 'integer';
+// Integer-derived datatypes from XML Schema Part 2 (and commonly used ones).
+const XSD_INTEGER_DERIVED_DTS = new Set([
+    XSD_INTEGER_DT,
+    XSD_NS + 'nonPositiveInteger',
+    XSD_NS + 'negativeInteger',
+    XSD_NS + 'long',
+    XSD_NS + 'int',
+    XSD_NS + 'short',
+    XSD_NS + 'byte',
+    XSD_NS + 'nonNegativeInteger',
+    XSD_NS + 'unsignedLong',
+    XSD_NS + 'unsignedInt',
+    XSD_NS + 'unsignedShort',
+    XSD_NS + 'unsignedByte',
+    XSD_NS + 'positiveInteger',
+]);
+function parseBooleanLiteralInfo(t) {
+    if (!(t instanceof Literal))
+        return null;
+    const boolDt = XSD_NS + 'boolean';
+    const v = t.value;
+    const [lex, dt] = literalParts(v);
+    // Typed xsd:boolean: accept "true"/"false"/"1"/"0"
+    if (dt !== null) {
+        if (dt !== boolDt)
+            return null;
+        const s = stripQuotes(lex);
+        if (s === 'true' || s === '1')
+            return { dt: boolDt, value: true };
+        if (s === 'false' || s === '0')
+            return { dt: boolDt, value: false };
+        return null;
     }
-    const lastQuote = lit.lastIndexOf('"');
-    if (lastQuote < 0)
-        return false;
-    const after = lastQuote + 1;
-    return after < lit.length && lit[after] === '@';
+    // Untyped boolean token: true/false
+    if (v === 'true')
+        return { dt: boolDt, value: true };
+    if (v === 'false')
+        return { dt: boolDt, value: false };
+    return null;
 }
-function isPlainStringLiteralValue(lit) {
-    // Plain string literal: quoted, no datatype, no lang.
-    if (typeof lit !== 'string')
-        return false;
-    if (lit.indexOf('^^') >= 0)
-        return false;
-    if (!isQuotedLexical(lit))
-        return false;
-    return !literalHasLangTag(lit);
+function parseXsdFloatSpecialLex(s) {
+    if (s === 'INF' || s === '+INF')
+        return Infinity;
+    if (s === '-INF')
+        return -Infinity;
+    if (s === 'NaN')
+        return NaN;
+    return null;
 }
-function literalsEquivalentAsXsdString(aLit, bLit) {
-    // Treat "abc" and "abc"^^xsd:string as equal, but do NOT conflate language-tagged strings.
-    if (typeof aLit !== 'string' || typeof bLit !== 'string')
+// ===========================================================================
+// Math builtin helpers
+// ===========================================================================
+function formatXsdFloatSpecialLex(n) {
+    if (n === Infinity)
+        return 'INF';
+    if (n === -Infinity)
+        return '-INF';
+    if (Number.isNaN(n))
+        return 'NaN';
+    return null;
+}
+function isQuotedLexical(lex) {
+    // Accept both Turtle/N3 quoting styles:
+    //   short:  "..."  or  '...'
+    //   long:   """..."""  or  '''...'''
+    if (typeof lex !== 'string')
         return false;
-    const [alex, adt] = literalParts(aLit);
-    const [blex, bdt] = literalParts(bLit);
-    if (alex !== blex)
+    const n = lex.length;
+    if (n >= 6 && ((lex.startsWith('"""') && lex.endsWith('"""')) || (lex.startsWith("'''") && lex.endsWith("'''"))))
+        return true;
+    if (n >= 2) {
+        const a = lex[0];
+        const b = lex[n - 1];
+        return (a === '"' && b === '"') || (a === "'" && b === "'");
+    }
+    return false;
+}
+function isXsdNumericDatatype(dt) {
+    if (dt === null)
         return false;
-    const aPlain = adt === null && isPlainStringLiteralValue(aLit);
-    const bPlain = bdt === null && isPlainStringLiteralValue(bLit);
-    const aXsdStr = adt === XSD_NS + 'string';
-    const bXsdStr = bdt === XSD_NS + 'string';
-    return (aPlain && bXsdStr) || (bPlain && aXsdStr);
+    return dt === XSD_DECIMAL_DT || dt === XSD_DOUBLE_DT || dt === XSD_FLOAT_DT || XSD_INTEGER_DERIVED_DTS.has(dt);
 }
-function normalizeLiteralForFastKey(lit) {
-    // Canonicalize so that "abc" and "abc"^^xsd:string share the same index/dedup key.
-    if (typeof lit !== 'string')
-        return lit;
-    const [lex, dt] = literalParts(lit);
-    if (dt === XSD_NS + 'string') {
-        return `${lex}^^<${XSD_NS}string>`;
-    }
-    if (dt === null && isPlainStringLiteralValue(lit)) {
-        return `${lex}^^<${XSD_NS}string>`;
-    }
-    return lit;
+function isXsdIntegerDatatype(dt) {
+    if (dt === null)
+        return false;
+    return XSD_INTEGER_DERIVED_DTS.has(dt);
 }
-function stripQuotes(lex) {
-    if (typeof lex !== 'string')
-        return lex;
-    // Handle both short ('...' / "...") and long ('''...''' / """...""") forms.
-    if (lex.length >= 6) {
-        if (lex.startsWith('"""') && lex.endsWith('"""'))
-            return lex.slice(3, -3);
-        if (lex.startsWith("'''") && lex.endsWith("'''"))
-            return lex.slice(3, -3);
-    }
-    if (lex.length >= 2) {
-        const a = lex[0];
-        const b = lex[lex.length - 1];
-        if ((a === '"' && b === '"') || (a === "'" && b === "'"))
-            return lex.slice(1, -1);
-    }
-    return lex;
+function looksLikeUntypedNumericTokenLex(lex) {
+    // We only treat *unquoted* tokens as "untyped numeric" (Turtle/N3 numeric literal).
+    // Quoted literals without datatype are strings, never numbers.
+    if (isQuotedLexical(lex))
+        return false;
+    // integer
+    if (/^[+-]?\d+$/.test(lex))
+        return true;
+    // decimal (no exponent)
+    if (/^[+-]?(?:\d+\.\d*|\.\d+)$/.test(lex))
+        return true;
+    // double (with exponent)
+    if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)$/.test(lex))
+        return true;
+    return false;
 }
-function termToJsXsdStringNoLang(t) {
-    // Strict xsd:string extraction *without* language tags.
-    // Accept:
-    //   - plain string literals ("...")
-    //   - "..."^^xsd:string
-    // Reject:
-    //   - language-tagged strings ("..."@en)
-    //   - any other datatype
+function parseNum(t) {
+    // Parse as JS Number, but ONLY for xsd numeric datatypes or untyped numeric tokens.
+    // For xsd:float/xsd:double, accept INF/-INF/NaN (and +INF).
     if (!(t instanceof Literal))
         return null;
-    if (literalHasLangTag(t.value))
-        return null;
-    const [lex, dt] = literalParts(t.value);
-    if (!isQuotedLexical(lex))
-        return null;
-    if (dt !== null && dt !== XSD_NS + 'string' && dt !== 'xsd:string')
+    const key = t.value;
+    if (__parseNumCache.has(key))
+        return __parseNumCache.get(key);
+    const [lex, dt] = literalParts(key);
+    // Typed literals: must be xsd numeric.
+    if (dt !== null) {
+        if (!isXsdNumericDatatype(dt)) {
+            __parseNumCache.set(key, null);
+            return null;
+        }
+        const val = stripQuotes(lex);
+        // float/double: allow INF/-INF/NaN and allow +/-Infinity results
+        if (dt === XSD_FLOAT_DT || dt === XSD_DOUBLE_DT) {
+            const sp = parseXsdFloatSpecialLex(val);
+            if (sp !== null) {
+                __parseNumCache.set(key, sp);
+                return sp;
+            }
+            const n = Number(val);
+            if (Number.isNaN(n)) {
+                __parseNumCache.set(key, null);
+                return null;
+            }
+            __parseNumCache.set(key, n);
+            return n; // may be finite, +/-Infinity
+        }
+        // decimal/integer-derived: keep strict finite parsing
+        const n = Number(val);
+        if (!Number.isFinite(n)) {
+            __parseNumCache.set(key, null);
+            return null;
+        }
+        __parseNumCache.set(key, n);
+        return n;
+    }
+    // Untyped literals: accept only unquoted numeric tokens.
+    if (!looksLikeUntypedNumericTokenLex(lex)) {
+        __parseNumCache.set(key, null);
         return null;
-    return decodeN3StringEscapes(stripQuotes(lex));
-}
-function termToJsString(t) {
-    // Domain is xsd:string for SWAP/N3 string builtins (string:*).
-    //
-    // Per the N3 Builtins spec, when the domain is xsd:string we must be able to
-    // cast *any* IRI or literal value (incl. numeric, boolean, dateTime, anyURI,
-    // rdf:langString, and plain literals) to a string.
-    //
-    // We implement this as:
-    //   - IRI    -> its IRI string
-    //   - Literal:
-    //       * quoted lexical form: decode N3/Turtle escapes and strip quotes
-    //       * unquoted lexical form: use as-is (e.g., 1234, true, 1971-..., 1.23E4)
-    //   - Everything else (blank nodes, lists, formulas, vars) -> fail
-    if (t instanceof Iri)
-        return t.value;
-    if (!(t instanceof Literal))
+    }
+    const n = Number(lex);
+    if (!Number.isFinite(n)) {
+        __parseNumCache.set(key, null);
         return null;
-    const [lex, _dt] = literalParts(t.value);
-    if (isQuotedLexical(lex)) {
-        // Interpret N3/Turtle string escapes (\" \n \uXXXX \UXXXXXXXX …)
-        // to obtain the actual string value.
-        return decodeN3StringEscapes(stripQuotes(lex));
     }
-    // Unquoted lexical (numbers/booleans/dateTimes, etc.)
-    return typeof lex === 'string' ? lex : String(lex);
-}
-function makeStringLiteral(str) {
-    // JSON.stringify gives us a valid N3/Turtle-style quoted string
-    // (with proper escaping for quotes, backslashes, newlines, …).
-    return internLiteral(JSON.stringify(str));
+    __parseNumCache.set(key, n);
+    return n;
 }
-function termToJsStringDecoded(t) {
-    // Like termToJsString, but for short literals it *also* interprets escapes
-    // (\" \n \uXXXX …) by attempting JSON.parse on the quoted lexical form.
+function parseIntLiteral(t) {
+    // Parse as BigInt if (and only if) it is an integer literal in an integer datatype,
+    // or an untyped integer token.
     if (!(t instanceof Literal))
         return null;
-    const [lex, _dt] = literalParts(t.value);
-    // Long strings: """ ... """ are taken verbatim.
-    if (lex.length >= 6 && lex.startsWith('"""') && lex.endsWith('"""')) {
-        return lex.slice(3, -3);
-    }
-    // Short strings: try to decode escapes (this makes "{\"a\":1}" usable too).
-    if (lex.length >= 2 && lex[0] === '"' && lex[lex.length - 1] === '"') {
-        try {
-            return JSON.parse(lex);
-        }
-        catch (e) {
-            /* fall through */
-        }
-        return stripQuotes(lex);
-    }
-    return stripQuotes(lex);
-}
-function jsonPointerUnescape(seg) {
-    // RFC6901: ~1 -> '/', ~0 -> '~'
-    let out = '';
-    for (let i = 0; i < seg.length; i++) {
-        const c = seg[i];
-        if (c !== '~') {
-            out += c;
-            continue;
-        }
-        if (i + 1 >= seg.length)
-            return null;
-        const n = seg[i + 1];
-        if (n === '0')
-            out += '~';
-        else if (n === '1')
-            out += '/';
-        else
+    const key = t.value;
+    if (__parseIntCache.has(key))
+        return __parseIntCache.get(key);
+    const [lex, dt] = literalParts(key);
+    if (dt !== null) {
+        if (!isXsdIntegerDatatype(dt)) {
+            __parseIntCache.set(key, null);
             return null;
-        i++;
-    }
-    return out;
-}
-function jsonToTerm(v) {
-    if (v === null)
-        return makeStringLiteral('null');
-    if (typeof v === 'string')
-        return makeStringLiteral(v);
-    if (typeof v === 'number')
-        return internLiteral(String(v));
-    if (typeof v === 'boolean')
-        return internLiteral(v ? 'true' : 'false');
-    if (Array.isArray(v))
-        return new ListTerm(v.map(jsonToTerm));
-    if (v && typeof v === 'object') {
-        return makeRdfJsonLiteral(JSON.stringify(v));
-    }
-    return null;
-}
-function jsonPointerLookup(jsonText, pointer) {
-    let ptr = pointer;
-    // Support URI fragment form "#/a/b"
-    if (ptr.startsWith('#')) {
-        try {
-            ptr = decodeURIComponent(ptr.slice(1));
         }
-        catch {
+        const val = stripQuotes(lex);
+        if (!/^[+-]?\d+$/.test(val)) {
+            __parseIntCache.set(key, null);
             return null;
         }
-    }
-    let entry = jsonPointerCache.get(jsonText);
-    if (!entry) {
-        let parsed = null;
         try {
-            parsed = JSON.parse(jsonText);
+            const out = BigInt(val);
+            __parseIntCache.set(key, out);
+            return out;
         }
         catch {
-            parsed = null;
+            __parseIntCache.set(key, null);
+            return null;
         }
-        entry = { parsed, ptrCache: new Map() };
-        jsonPointerCache.set(jsonText, entry);
     }
-    if (entry.parsed === null)
+    // Untyped: only accept unquoted integer tokens.
+    if (isQuotedLexical(lex)) {
+        __parseIntCache.set(key, null);
         return null;
-    if (entry.ptrCache.has(ptr))
-        return entry.ptrCache.get(ptr);
-    let cur = entry.parsed;
-    if (ptr === '') {
-        const t = jsonToTerm(cur);
-        entry.ptrCache.set(ptr, t);
-        return t;
     }
-    if (!ptr.startsWith('/')) {
-        entry.ptrCache.set(ptr, null);
+    if (!/^[+-]?\d+$/.test(lex)) {
+        __parseIntCache.set(key, null);
         return null;
     }
-    const parts = ptr.split('/').slice(1);
-    for (const raw of parts) {
-        const seg = jsonPointerUnescape(raw);
-        if (seg === null) {
-            entry.ptrCache.set(ptr, null);
-            return null;
-        }
-        if (Array.isArray(cur)) {
-            if (!/^(0|[1-9]\d*)$/.test(seg)) {
-                entry.ptrCache.set(ptr, null);
-                return null;
-            }
-            const idx = Number(seg);
-            if (idx < 0 || idx >= cur.length) {
-                entry.ptrCache.set(ptr, null);
-                return null;
-            }
-            cur = cur[idx];
-        }
-        else if (cur !== null && typeof cur === 'object') {
-            if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
-                entry.ptrCache.set(ptr, null);
-                return null;
-            }
-            cur = cur[seg];
-        }
-        else {
-            entry.ptrCache.set(ptr, null);
-            return null;
-        }
+    try {
+        const out = BigInt(lex);
+        __parseIntCache.set(key, out);
+        return out;
     }
-    const out = jsonToTerm(cur);
-    entry.ptrCache.set(ptr, out);
-    return out;
-}
-// Tiny subset of sprintf: supports only %s and %%.
-// Good enough for most N3 string:format use cases that just splice strings.
-function simpleStringFormat(fmt, args) {
-    let out = '';
-    let argIndex = 0;
-    for (let i = 0; i < fmt.length; i++) {
-        const ch = fmt[i];
-        if (ch === '%' && i + 1 < fmt.length) {
-            const spec = fmt[i + 1];
-            if (spec === 's') {
-                const arg = argIndex < args.length ? args[argIndex++] : '';
-                out += arg;
-                i++;
-                continue;
-            }
-            if (spec === '%') {
-                out += '%';
-                i++;
-                continue;
-            }
-            // Unsupported specifier (like %d, %f, …) ⇒ fail the builtin.
-            return null;
-        }
-        out += ch;
+    catch {
+        __parseIntCache.set(key, null);
+        return null;
     }
-    return out;
-}
-// -----------------------------------------------------------------------------
-// SWAP/N3 regex compatibility helper
-// -----------------------------------------------------------------------------
-function regexNeedsUnicodeMode(pattern) {
-    // JS requires /u for Unicode property escapes and code point escapes.
-    return /\\[pP]\{/.test(pattern) || /\\u\{/.test(pattern);
 }
-function sanitizeForUnicodeMode(pattern) {
-    // In JS Unicode mode, “identity escapes” like \! are a SyntaxError.
-    // In Perl-ish regexes they commonly mean “literal !”. So drop the redundant "\".
-    // Keep escapes that are regex-syntax or are commonly needed in char classes.
-    const KEEP = '^$\\.*+?()[]{}|/-';
-    return pattern.replace(/\\([^A-Za-z0-9])/g, (m, ch) => {
-        return KEEP.includes(ch) ? m : ch;
-    });
+function formatNum(n) {
+    return String(n);
 }
-function compileSwapRegex(pattern, extraFlags) {
-    const needU = regexNeedsUnicodeMode(pattern);
-    const flags = (extraFlags || '') + (needU ? 'u' : '');
-    try {
-        return new RegExp(pattern, flags);
+function parseXsdDecimalToBigIntScale(s) {
+    let t = String(s).trim();
+    let sign = 1n;
+    if (t.startsWith('+'))
+        t = t.slice(1);
+    else if (t.startsWith('-')) {
+        sign = -1n;
+        t = t.slice(1);
     }
-    catch (e) {
-        if (needU) {
-            const p2 = sanitizeForUnicodeMode(pattern);
-            if (p2 !== pattern) {
-                try {
-                    return new RegExp(p2, flags);
-                }
-                catch (_e2) { }
-            }
-        }
+    // xsd:decimal lexical: (\d+(\.\d*)?|\.\d+)
+    if (!/^(?:\d+(?:\.\d*)?|\.\d+)$/.test(t))
         return null;
+    let intPart = '0';
+    let fracPart = '';
+    if (t.includes('.')) {
+        const parts = t.split('.');
+        intPart = parts[0] === '' ? '0' : parts[0];
+        fracPart = parts[1] || '';
     }
-}
-// -----------------------------------------------------------------------------
-// Strict numeric literal parsing for math: builtins
-// -----------------------------------------------------------------------------
-const XSD_DECIMAL_DT = XSD_NS + 'decimal';
-const XSD_DOUBLE_DT = XSD_NS + 'double';
-const XSD_FLOAT_DT = XSD_NS + 'float';
-const XSD_INTEGER_DT = XSD_NS + 'integer';
-// Integer-derived datatypes from XML Schema Part 2 (and commonly used ones).
-const XSD_INTEGER_DERIVED_DTS = new Set([
-    XSD_INTEGER_DT,
-    XSD_NS + 'nonPositiveInteger',
-    XSD_NS + 'negativeInteger',
-    XSD_NS + 'long',
-    XSD_NS + 'int',
-    XSD_NS + 'short',
-    XSD_NS + 'byte',
-    XSD_NS + 'nonNegativeInteger',
-    XSD_NS + 'unsignedLong',
-    XSD_NS + 'unsignedInt',
-    XSD_NS + 'unsignedShort',
-    XSD_NS + 'unsignedByte',
-    XSD_NS + 'positiveInteger',
-]);
-function parseBooleanLiteralInfo(t) {
-    if (!(t instanceof Literal))
-        return null;
-    const boolDt = XSD_NS + 'boolean';
-    const v = t.value;
-    const [lex, dt] = literalParts(v);
-    // Typed xsd:boolean: accept "true"/"false"/"1"/"0"
-    if (dt !== null) {
-        if (dt !== boolDt)
-            return null;
-        const s = stripQuotes(lex);
-        if (s === 'true' || s === '1')
-            return { dt: boolDt, value: true };
-        if (s === 'false' || s === '0')
-            return { dt: boolDt, value: false };
-        return null;
+    else {
+        intPart = t;
     }
-    // Untyped boolean token: true/false
-    if (v === 'true')
-        return { dt: boolDt, value: true };
-    if (v === 'false')
-        return { dt: boolDt, value: false };
-    return null;
+    // normalize
+    intPart = intPart.replace(/^0+(?=\d)/, '');
+    fracPart = fracPart.replace(/0+$/, ''); // drop trailing zeros
+    const scale = fracPart.length;
+    const digits = intPart + fracPart || '0';
+    return { num: sign * BigInt(digits), scale };
 }
-function parseXsdFloatSpecialLex(s) {
-    if (s === 'INF' || s === '+INF')
-        return Infinity;
-    if (s === '-INF')
-        return -Infinity;
-    if (s === 'NaN')
-        return NaN;
-    return null;
+function pow10n(k) {
+    return 10n ** BigInt(k);
 }
 // ===========================================================================
-// Math builtin helpers
+// Time & duration builtin helpers
 // ===========================================================================
-function formatXsdFloatSpecialLex(n) {
-    if (n === Infinity)
-        return 'INF';
-    if (n === -Infinity)
-        return '-INF';
-    if (Number.isNaN(n))
-        return 'NaN';
-    return null;
-}
-function isQuotedLexical(lex) {
-    // Accept both Turtle/N3 quoting styles:
-    //   short:  "..."  or  '...'
-    //   long:   """..."""  or  '''...'''
-    if (typeof lex !== 'string')
-        return false;
-    const n = lex.length;
-    if (n >= 6 && ((lex.startsWith('"""') && lex.endsWith('"""')) || (lex.startsWith("'''") && lex.endsWith("'''"))))
-        return true;
-    if (n >= 2) {
-        const a = lex[0];
-        const b = lex[n - 1];
-        return (a === '"' && b === '"') || (a === "'" && b === "'");
-    }
-    return false;
-}
-function isXsdNumericDatatype(dt) {
-    if (dt === null)
-        return false;
-    return dt === XSD_DECIMAL_DT || dt === XSD_DOUBLE_DT || dt === XSD_FLOAT_DT || XSD_INTEGER_DERIVED_DTS.has(dt);
-}
-function isXsdIntegerDatatype(dt) {
-    if (dt === null)
-        return false;
-    return XSD_INTEGER_DERIVED_DTS.has(dt);
-}
-function looksLikeUntypedNumericTokenLex(lex) {
-    // We only treat *unquoted* tokens as "untyped numeric" (Turtle/N3 numeric literal).
-    // Quoted literals without datatype are strings, never numbers.
-    if (isQuotedLexical(lex))
-        return false;
-    // integer
-    if (/^[+-]?\d+$/.test(lex))
-        return true;
-    // decimal (no exponent)
-    if (/^[+-]?(?:\d+\.\d*|\.\d+)$/.test(lex))
-        return true;
-    // double (with exponent)
-    if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)$/.test(lex))
-        return true;
-    return false;
-}
-function parseNum(t) {
-    // Parse as JS Number, but ONLY for xsd numeric datatypes or untyped numeric tokens.
-    // For xsd:float/xsd:double, accept INF/-INF/NaN (and +INF).
+function parseXsdDateTerm(t) {
     if (!(t instanceof Literal))
         return null;
-    const key = t.value;
-    if (__parseNumCache.has(key))
-        return __parseNumCache.get(key);
-    const [lex, dt] = literalParts(key);
-    // Typed literals: must be xsd numeric.
-    if (dt !== null) {
-        if (!isXsdNumericDatatype(dt)) {
-            __parseNumCache.set(key, null);
-            return null;
-        }
-        const val = stripQuotes(lex);
-        // float/double: allow INF/-INF/NaN and allow +/-Infinity results
-        if (dt === XSD_FLOAT_DT || dt === XSD_DOUBLE_DT) {
-            const sp = parseXsdFloatSpecialLex(val);
-            if (sp !== null) {
-                __parseNumCache.set(key, sp);
-                return sp;
-            }
-            const n = Number(val);
-            if (Number.isNaN(n)) {
-                __parseNumCache.set(key, null);
-                return null;
-            }
-            __parseNumCache.set(key, n);
-            return n; // may be finite, +/-Infinity
-        }
-        // decimal/integer-derived: keep strict finite parsing
-        const n = Number(val);
-        if (!Number.isFinite(n)) {
-            __parseNumCache.set(key, null);
-            return null;
-        }
-        __parseNumCache.set(key, n);
-        return n;
-    }
-    // Untyped literals: accept only unquoted numeric tokens.
-    if (!looksLikeUntypedNumericTokenLex(lex)) {
-        __parseNumCache.set(key, null);
+    const [lex, dt] = literalParts(t.value);
+    if (dt !== XSD_NS + 'date')
         return null;
-    }
-    const n = Number(lex);
-    if (!Number.isFinite(n)) {
-        __parseNumCache.set(key, null);
-        return null;
-    }
-    __parseNumCache.set(key, n);
-    return n;
-}
-function parseIntLiteral(t) {
-    // Parse as BigInt if (and only if) it is an integer literal in an integer datatype,
-    // or an untyped integer token.
-    if (!(t instanceof Literal))
-        return null;
-    const key = t.value;
-    if (__parseIntCache.has(key))
-        return __parseIntCache.get(key);
-    const [lex, dt] = literalParts(key);
-    if (dt !== null) {
-        if (!isXsdIntegerDatatype(dt)) {
-            __parseIntCache.set(key, null);
-            return null;
-        }
-        const val = stripQuotes(lex);
-        if (!/^[+-]?\d+$/.test(val)) {
-            __parseIntCache.set(key, null);
-            return null;
-        }
-        try {
-            const out = BigInt(val);
-            __parseIntCache.set(key, out);
-            return out;
-        }
-        catch {
-            __parseIntCache.set(key, null);
-            return null;
-        }
-    }
-    // Untyped: only accept unquoted integer tokens.
-    if (isQuotedLexical(lex)) {
-        __parseIntCache.set(key, null);
-        return null;
-    }
-    if (!/^[+-]?\d+$/.test(lex)) {
-        __parseIntCache.set(key, null);
-        return null;
-    }
-    try {
-        const out = BigInt(lex);
-        __parseIntCache.set(key, out);
-        return out;
-    }
-    catch {
-        __parseIntCache.set(key, null);
-        return null;
-    }
-}
-function formatNum(n) {
-    return String(n);
-}
-function parseXsdDecimalToBigIntScale(s) {
-    let t = String(s).trim();
-    let sign = 1n;
-    if (t.startsWith('+'))
-        t = t.slice(1);
-    else if (t.startsWith('-')) {
-        sign = -1n;
-        t = t.slice(1);
-    }
-    // xsd:decimal lexical: (\d+(\.\d*)?|\.\d+)
-    if (!/^(?:\d+(?:\.\d*)?|\.\d+)$/.test(t))
-        return null;
-    let intPart = '0';
-    let fracPart = '';
-    if (t.includes('.')) {
-        const parts = t.split('.');
-        intPart = parts[0] === '' ? '0' : parts[0];
-        fracPart = parts[1] || '';
-    }
-    else {
-        intPart = t;
-    }
-    // normalize
-    intPart = intPart.replace(/^0+(?=\d)/, '');
-    fracPart = fracPart.replace(/0+$/, ''); // drop trailing zeros
-    const scale = fracPart.length;
-    const digits = intPart + fracPart || '0';
-    return { num: sign * BigInt(digits), scale };
-}
-function pow10n(k) {
-    return 10n ** BigInt(k);
-}
-// ===========================================================================
-// Time & duration builtin helpers
-// ===========================================================================
-function parseXsdDateTerm(t) {
-    if (!(t instanceof Literal))
-        return null;
-    const [lex, dt] = literalParts(t.value);
-    if (dt !== XSD_NS + 'date')
-        return null;
-    const val = stripQuotes(lex);
-    const d = new Date(val + 'T00:00:00Z');
-    if (Number.isNaN(d.getTime()))
+    const val = stripQuotes(lex);
+    const d = new Date(val + 'T00:00:00Z');
+    if (Number.isNaN(d.getTime()))
         return null;
     return d;
 }
@@ -6094,6 +5766,336 @@ function isBuiltinPred(p) {
         v.startsWith(TIME_NS) ||
         v.startsWith(LIST_NS));
 }
+// @ts-nocheck
+/* eslint-disable */
+// ===========================================================================
+// Unification + substitution
+// ===========================================================================
+function containsVarTerm(t, v) {
+    if (t instanceof Var)
+        return t.name === v;
+    if (t instanceof ListTerm)
+        return t.elems.some((e) => containsVarTerm(e, v));
+    if (t instanceof OpenListTerm)
+        return t.prefix.some((e) => containsVarTerm(e, v)) || t.tailVar === v;
+    if (t instanceof GraphTerm)
+        return t.triples.some((tr) => containsVarTerm(tr.s, v) || containsVarTerm(tr.p, v) || containsVarTerm(tr.o, v));
+    return false;
+}
+function isGroundTermInGraph(t) {
+    // variables inside graph terms are treated as local placeholders,
+    // so they don't make the *surrounding triple* non-ground.
+    if (t instanceof OpenListTerm)
+        return false;
+    if (t instanceof ListTerm)
+        return t.elems.every((e) => isGroundTermInGraph(e));
+    if (t instanceof GraphTerm)
+        return t.triples.every((tr) => isGroundTripleInGraph(tr));
+    // Iri/Literal/Blank/Var are all OK inside formulas
+    return true;
+}
+function isGroundTripleInGraph(tr) {
+    return isGroundTermInGraph(tr.s) && isGroundTermInGraph(tr.p) && isGroundTermInGraph(tr.o);
+}
+function isGroundTerm(t) {
+    if (t instanceof Var)
+        return false;
+    if (t instanceof ListTerm)
+        return t.elems.every((e) => isGroundTerm(e));
+    if (t instanceof OpenListTerm)
+        return false;
+    if (t instanceof GraphTerm)
+        return t.triples.every((tr) => isGroundTripleInGraph(tr));
+    return true;
+}
+function isGroundTriple(tr) {
+    return isGroundTerm(tr.s) && isGroundTerm(tr.p) && isGroundTerm(tr.o);
+}
+// Canonical JSON-ish encoding for use as a Skolem cache key.
+// We only *call* this on ground terms in log:skolem, but it is
+// robust to seeing vars/open lists anyway.
+function skolemKeyFromTerm(t) {
+    function enc(u) {
+        if (u instanceof Iri)
+            return ['I', u.value];
+        if (u instanceof Literal)
+            return ['L', u.value];
+        if (u instanceof Blank)
+            return ['B', u.label];
+        if (u instanceof Var)
+            return ['V', u.name];
+        if (u instanceof ListTerm)
+            return ['List', u.elems.map(enc)];
+        if (u instanceof OpenListTerm)
+            return ['OpenList', u.prefix.map(enc), u.tailVar];
+        if (u instanceof GraphTerm)
+            return ['Graph', u.triples.map((tr) => [enc(tr.s), enc(tr.p), enc(tr.o)])];
+        return ['Other', String(u)];
+    }
+    return JSON.stringify(enc(t));
+}
+function applySubstTerm(t, s) {
+    // Common case: variable
+    if (t instanceof Var) {
+        // Fast path: unbound variable → no change
+        const first = s[t.name];
+        if (first === undefined) {
+            return t;
+        }
+        // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
+        let cur = first;
+        const seen = new Set([t.name]);
+        while (cur instanceof Var) {
+            const name = cur.name;
+            if (seen.has(name))
+                break; // cycle
+            seen.add(name);
+            const nxt = s[name];
+            if (!nxt)
+                break;
+            cur = nxt;
+        }
+        if (cur instanceof Var) {
+            // Still a var: keep it as is (no need to clone)
+            return cur;
+        }
+        // Bound to a non-var term: apply substitution recursively in case it
+        // contains variables inside.
+        return applySubstTerm(cur, s);
+    }
+    // Non-variable terms
+    if (t instanceof ListTerm) {
+        return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
+    }
+    if (t instanceof OpenListTerm) {
+        const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
+        const tailTerm = s[t.tailVar];
+        if (tailTerm !== undefined) {
+            const tailApplied = applySubstTerm(tailTerm, s);
+            if (tailApplied instanceof ListTerm) {
+                return new ListTerm(newPrefix.concat(tailApplied.elems));
+            }
+            else if (tailApplied instanceof OpenListTerm) {
+                return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
+            }
+            else {
+                return new OpenListTerm(newPrefix, t.tailVar);
+            }
+        }
+        else {
+            return new OpenListTerm(newPrefix, t.tailVar);
+        }
+    }
+    if (t instanceof GraphTerm) {
+        return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
+    }
+    return t;
+}
+function applySubstTriple(tr, s) {
+    return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
+}
+function iriValue(t) {
+    return t instanceof Iri ? t.value : null;
+}
+function unifyOpenWithList(prefix, tailv, ys, subst) {
+    if (ys.length < prefix.length)
+        return null;
+    let s2 = { ...subst };
+    for (let i = 0; i < prefix.length; i++) {
+        s2 = unifyTerm(prefix[i], ys[i], s2);
+        if (s2 === null)
+            return null;
+    }
+    const rest = new ListTerm(ys.slice(prefix.length));
+    s2 = unifyTerm(new Var(tailv), rest, s2);
+    if (s2 === null)
+        return null;
+    return s2;
+}
+function unifyGraphTriples(xs, ys, subst) {
+    if (xs.length !== ys.length)
+        return null;
+    // Fast path: exact same sequence.
+    if (triplesListEqual(xs, ys))
+        return { ...subst };
+    // Backtracking match (order-insensitive), *threading* the substitution through.
+    const used = new Array(ys.length).fill(false);
+    function step(i, s) {
+        if (i >= xs.length)
+            return s;
+        const x = xs[i];
+        for (let j = 0; j < ys.length; j++) {
+            if (used[j])
+                continue;
+            const y = ys[j];
+            // Cheap pruning when both predicates are IRIs.
+            if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value)
+                continue;
+            const s2 = unifyTriple(x, y, s); // IMPORTANT: use `s`, not {}
+            if (s2 === null)
+                continue;
+            used[j] = true;
+            const s3 = step(i + 1, s2);
+            if (s3 !== null)
+                return s3;
+            used[j] = false;
+        }
+        return null;
+    }
+    return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
+}
+function unifyTerm(a, b, subst) {
+    return unifyTermWithOptions(a, b, subst, {
+        boolValueEq: true,
+        intDecimalEq: false,
+    });
+}
+function unifyTermListAppend(a, b, subst) {
+    // Keep list:append behavior: allow integer<->decimal exact equality,
+    // but do NOT add boolean-value equivalence (preserves current semantics).
+    return unifyTermWithOptions(a, b, subst, {
+        boolValueEq: false,
+        intDecimalEq: true,
+    });
+}
+function unifyTermWithOptions(a, b, subst, opts) {
+    a = applySubstTerm(a, subst);
+    b = applySubstTerm(b, subst);
+    // Variable binding
+    if (a instanceof Var) {
+        const v = a.name;
+        const t = b;
+        if (t instanceof Var && t.name === v)
+            return { ...subst };
+        if (containsVarTerm(t, v))
+            return null;
+        const s2 = { ...subst };
+        s2[v] = t;
+        return s2;
+    }
+    if (b instanceof Var) {
+        return unifyTermWithOptions(b, a, subst, opts);
+    }
+    // Exact matches
+    if (a instanceof Iri && b instanceof Iri && a.value === b.value)
+        return { ...subst };
+    if (a instanceof Literal && b instanceof Literal && a.value === b.value)
+        return { ...subst };
+    if (a instanceof Blank && b instanceof Blank && a.label === b.label)
+        return { ...subst };
+    // Plain string vs xsd:string equivalence
+    if (a instanceof Literal && b instanceof Literal) {
+        if (literalsEquivalentAsXsdString(a.value, b.value))
+            return { ...subst };
+    }
+    // Boolean-value equivalence (ONLY for normal unifyTerm)
+    if (opts.boolValueEq && a instanceof Literal && b instanceof Literal) {
+        const ai = parseBooleanLiteralInfo(a);
+        const bi = parseBooleanLiteralInfo(b);
+        if (ai && bi && ai.value === bi.value)
+            return { ...subst };
+    }
+    // Numeric-value match:
+    // - always allow equality when datatype matches (existing behavior)
+    // - optionally allow integer<->decimal exact equality (list:append only)
+    if (a instanceof Literal && b instanceof Literal) {
+        const ai = parseNumericLiteralInfo(a);
+        const bi = parseNumericLiteralInfo(b);
+        if (ai && bi) {
+            if (ai.dt === bi.dt) {
+                if (ai.kind === 'bigint' && bi.kind === 'bigint') {
+                    if (ai.value === bi.value)
+                        return { ...subst };
+                }
+                else {
+                    const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
+                    const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
+                    if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn)
+                        return { ...subst };
+                }
+            }
+            if (opts.intDecimalEq) {
+                const intDt = XSD_NS + 'integer';
+                const decDt = XSD_NS + 'decimal';
+                if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
+                    const intInfo = ai.dt === intDt ? ai : bi; // bigint
+                    const decInfo = ai.dt === decDt ? ai : bi; // number + lexStr
+                    const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
+                    if (dec) {
+                        const scaledInt = intInfo.value * pow10n(dec.scale);
+                        if (scaledInt === dec.num)
+                            return { ...subst };
+                    }
+                }
+            }
+        }
+    }
+    // Open list vs concrete list
+    if (a instanceof OpenListTerm && b instanceof ListTerm) {
+        return unifyOpenWithList(a.prefix, a.tailVar, b.elems, subst);
+    }
+    if (a instanceof ListTerm && b instanceof OpenListTerm) {
+        return unifyOpenWithList(b.prefix, b.tailVar, a.elems, subst);
+    }
+    // Open list vs open list
+    if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
+        if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length)
+            return null;
+        let s2 = { ...subst };
+        for (let i = 0; i < a.prefix.length; i++) {
+            s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
+            if (s2 === null)
+                return null;
+        }
+        return s2;
+    }
+    // List terms
+    if (a instanceof ListTerm && b instanceof ListTerm) {
+        if (a.elems.length !== b.elems.length)
+            return null;
+        let s2 = { ...subst };
+        for (let i = 0; i < a.elems.length; i++) {
+            s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
+            if (s2 === null)
+                return null;
+        }
+        return s2;
+    }
+    // Graphs
+    if (a instanceof GraphTerm && b instanceof GraphTerm) {
+        if (alphaEqGraphTriples(a.triples, b.triples))
+            return { ...subst };
+        return unifyGraphTriples(a.triples, b.triples, subst);
+    }
+    return null;
+}
+function unifyTriple(pat, fact, subst) {
+    // Predicates are usually the cheapest and most selective
+    const s1 = unifyTerm(pat.p, fact.p, subst);
+    if (s1 === null)
+        return null;
+    const s2 = unifyTerm(pat.s, fact.s, s1);
+    if (s2 === null)
+        return null;
+    const s3 = unifyTerm(pat.o, fact.o, s2);
+    return s3;
+}
+function composeSubst(outer, delta) {
+    if (!delta || Object.keys(delta).length === 0) {
+        return { ...outer };
+    }
+    const out = { ...outer };
+    for (const [k, v] of Object.entries(delta)) {
+        if (out.hasOwnProperty(k)) {
+            if (!termsEqual(out[k], v))
+                return null;
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
 // ===========================================================================
 // Backward proof (SLD-style)
 // ===========================================================================