graphwise-reactodia 0.0.1-TR10 → 0.0.1-TR11

package/dist/esm/graphwise-reactodia.entry.js

@@ -774,7 +774,7 @@ var global$1 = (typeof global !== "undefined" ? global :
   typeof self !== "undefined" ? self :
   typeof window !== "undefined" ? window : {});
 
-var lookup = [];
+var lookup$1 = [];
 var revLookup = [];
 var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 var inited = false;
@@ -782,7 +782,7 @@ function init () {
   inited = true;
   var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
   for (var i = 0, len = code.length; i < len; ++i) {
-    lookup[i] = code[i];
+    lookup$1[i] = code[i];
     revLookup[code.charCodeAt(i)] = i;
   }
 
@@ -836,7 +836,7 @@ function toByteArray (b64) {
 }
 
 function tripletToBase64 (num) {
-  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
+  return lookup$1[num >> 18 & 0x3F] + lookup$1[num >> 12 & 0x3F] + lookup$1[num >> 6 & 0x3F] + lookup$1[num & 0x3F]
 }
 
 function encodeChunk (uint8, start, end) {
@@ -868,14 +868,14 @@ function fromByteArray (uint8) {
   // pad the end with zeros, but make sure to not forget the extra bytes
   if (extraBytes === 1) {
     tmp = uint8[len - 1];
-    output += lookup[tmp >> 2];
-    output += lookup[(tmp << 4) & 0x3F];
+    output += lookup$1[tmp >> 2];
+    output += lookup$1[(tmp << 4) & 0x3F];
     output += '==';
   } else if (extraBytes === 2) {
     tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
-    output += lookup[tmp >> 10];
-    output += lookup[(tmp >> 4) & 0x3F];
-    output += lookup[(tmp << 2) & 0x3F];
+    output += lookup$1[tmp >> 10];
+    output += lookup$1[(tmp >> 4) & 0x3F];
+    output += lookup$1[(tmp << 2) & 0x3F];
     output += '=';
   }
 
@@ -6398,6 +6398,567 @@ function escapeRegexp(token) {
 	return token.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
 //#endregion
+//#region src/data/sparql/sparqlModels.ts
+function mapSparqlResponseIntoRdfJs(response, factory) {
+	function mapSparqlBinding(binding) {
+		const mapped = {};
+		for (const key in binding) if (Object.prototype.hasOwnProperty.call(binding, key)) {
+			const term = binding[key];
+			switch (term.type) {
+				case "uri":
+					mapped[key] = factory.namedNode(term.value);
+					break;
+				case "bnode":
+					mapped[key] = factory.blankNode(term.value);
+					break;
+				case "literal":
+				case "typed-literal":
+					mapped[key] = factory.literal(term.value, term["xml:lang"] ? term["xml:lang"] : term.datatype ? factory.namedNode(term.datatype) : void 0);
+					break;
+				default: throw new Error(`Unexpected SPARQL term type: "${term.type}"`);
+			}
+		}
+		return mapped;
+	}
+	return {
+		...response,
+		results: {
+			...response.results,
+			bindings: response.results.bindings.map(mapSparqlBinding)
+		}
+	};
+}
+function isRdfIri(term) {
+	return Boolean(term && term.termType === "NamedNode");
+}
+function isRdfBlank(term) {
+	return Boolean(term && term.termType === "BlankNode");
+}
+function isRdfLiteral(term) {
+	return Boolean(term && term.termType === "Literal");
+}
+function isBlankBinding(binding) {
+	const blank = binding;
+	return blank.blankTrgProp !== void 0 || blank.blankTrg !== void 0 || blank.blankSrcProp !== void 0 || blank.blankSrc !== void 0;
+}
+/**
+* IRI prefix for the encoded blank node subtype produced by this module.
+*
+* @see {@link isEncodedBlank}
+*/
+var ENCODED_PREFIX = "urn:reactodia:blank:sparql:";
+/**
+* There is no way to refer to an existing blank node from a SPARQL query, and the labels
+* an endpoint returns for one are local to the response they came in. Instead of trying to
+* address a blank node, the whole statement set which describes it is encoded into the
+* element IRI, which makes the identity content-addressed: the same surrounding graph always
+* yields the same IRI, and every request about such an element can be answered locally by
+* decoding it back, without another round-trip to the endpoint.
+*
+* The trade-off is size: the IRI grows linearly with the number of statements attached to
+* the blank node, at roughly 300 characters per statement. {@link MAX_RECURSION_DEEP} bounds
+* how deep nesting can go, but nothing bounds how wide a single blank node can be, so a long
+* RDF list produces a correspondingly long IRI (measured against the W3C Organization
+* ontology: 380-1650 characters for its OWL axioms; a synthetic 100-member list: ~28 KB).
+*/
+function isEncodedBlank$1(iri) {
+	return iri.startsWith(ENCODED_PREFIX);
+}
+/**
+* Additional output bindings which {@link BLANK_NODE_QUERY} produces, to be added
+* to the outer projection of the lookup query.
+*/
+var BLANK_NODE_QUERY_PARAMETERS = "?blankType ?blankTrgProp ?blankTrg ?blankSrc ?blankSrcProp";
+/**
+* Lookup query addition which describes every blank node in `?inst` by its outgoing
+* statements and the statement pointing at it.
+*
+* The three alternatives handle a plain blank node, an RDF list referenced directly
+* and a cell in the middle of an RDF list (which is resolved to the list head, so that
+* a list appears as a single element rather than one element per cell).
+*/
+var BLANK_NODE_QUERY = `
+    OPTIONAL {
+        FILTER (ISBLANK(?inst)).
+        {
+            ?inst ?blankTrgProp ?blankTrg.
+            ?blankSrc ?blankSrcProp ?inst.
+            FILTER NOT EXISTS { ?inst rdf:first _:smth1 }.
+            BIND("blankNode" as ?blankType)
+        } UNION {
+            ?inst rdf:rest*/rdf:first ?blankTrg.
+            ?blankSrc ?blankSrcProp ?inst.
+            _:smth2 rdf:first ?blankTrg.
+            BIND(?blankSrcProp as ?blankTrgProp)
+            BIND("listHead" as ?blankType)
+            FILTER NOT EXISTS { _:smth3 rdf:rest ?inst }.
+        } UNION {
+            ?listHead rdf:rest* ?inst.
+            FILTER NOT EXISTS { _:smth4 rdf:rest ?listHead }.
+
+            ?listHead rdf:rest*/rdf:first ?blankTrg.
+            ?blankSrc ?blankSrcProp ?listHead.
+            _:smth5 rdf:first ?blankTrg.
+            BIND(?blankSrcProp as ?blankTrgProp)
+            BIND("listHead" as ?blankType)
+        }
+    }
+`;
+var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+function encodeTerm(term) {
+	switch (term.termType) {
+		case "NamedNode": return ["i", term.value];
+		case "BlankNode": return ["b", term.value];
+		case "Literal":
+			if (term.language) return [
+				"l",
+				term.value,
+				term.language
+			];
+			else if (term.datatype && term.datatype.value !== XSD_STRING) return [
+				"d",
+				term.value,
+				term.datatype.value
+			];
+			return ["l", term.value];
+	}
+}
+function decodeTerm(encoded, factory) {
+	switch (encoded[0]) {
+		case "i": return factory.namedNode(encoded[1]);
+		case "b": return factory.blankNode(encoded[1]);
+		case "l": return factory.literal(encoded[1], encoded[2]);
+		case "d": return factory.literal(encoded[1], factory.namedNode(encoded[2]));
+		default: throw new Error(`Unexpected encoded blank node term: ${JSON.stringify(encoded)}`);
+	}
+}
+/**
+* Encodes the statement set which describes a single blank node into an element IRI.
+*
+* Bindings are deduplicated and sorted, so that the same statement set always produces
+* the same IRI regardless of the order the endpoint returned it in. The blank node label
+* itself is deliberately left out: it is local to the response it came from and would make
+* the IRI change between otherwise identical requests.
+*/
+function encodeId(blankBindings, statementLimit) {
+	const bindingSet = /* @__PURE__ */ new Map();
+	for (const binding of blankBindings) {
+		const encoded = {
+			t: binding.blankType.value,
+			p: encodeTerm(binding.blankTrgProp),
+			o: encodeTerm(binding.blankTrg),
+			s: binding.blankSrc ? encodeTerm(binding.blankSrc) : void 0,
+			sp: binding.blankSrcProp ? encodeTerm(binding.blankSrcProp) : void 0,
+			c: binding.class ? encodeTerm(binding.class) : void 0
+		};
+		bindingSet.set(JSON.stringify(encoded), encoded);
+	}
+	const orderedKeys = Array.from(bindingSet.keys()).sort();
+	const normalizedBindings = (typeof statementLimit === "number" ? orderedKeys.slice(0, Math.max(statementLimit, 0)) : orderedKeys).map((key) => bindingSet.get(key));
+	return ENCODED_PREFIX + toBase64Url(JSON.stringify(normalizedBindings));
+}
+/**
+* Encodes the payload as base64url rather than percent-escaping it.
+*
+* A nested blank node is embedded into its parent by its own encoded IRI, and base64url
+* output contains only characters which need no escaping, so nesting costs a flat 4/3 per
+* level. Percent-escaping would escape the escapes, roughly doubling the payload at every
+* level instead.
+*/
+function toBase64Url(text) {
+	const bytes = new TextEncoder().encode(text);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(encoded) {
+	const binary = atob(encoded.replace(/-/g, "+").replace(/_/g, "/"));
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Decodes an element IRI produced by {@link encodeId} back into the statement set it
+* was made from, or returns `undefined` if the IRI is not an encoded blank node or
+* cannot be parsed.
+*/
+function decodeId(id, factory) {
+	if (!isEncodedBlank$1(id)) return;
+	let parsed;
+	try {
+		const encodedPart = id.substring(27);
+		parsed = JSON.parse(fromBase64Url(encodedPart));
+		if (!Array.isArray(parsed)) return;
+	} catch {
+		return;
+	}
+	try {
+		const inst = factory.namedNode(id);
+		return parsed.map((encoded) => {
+			const binding = {
+				inst,
+				blankType: factory.literal(encoded.t),
+				blankTrgProp: decodeTerm(encoded.p, factory),
+				blankTrg: decodeTerm(encoded.o, factory),
+				blankSrc: encoded.s ? decodeTerm(encoded.s, factory) : void 0,
+				blankSrcProp: encoded.sp ? decodeTerm(encoded.sp, factory) : void 0,
+				class: encoded.c ? decodeTerm(encoded.c, factory) : void 0
+			};
+			binding.label = createLabelForBlankBinding(binding, factory);
+			return binding;
+		});
+	} catch {
+		return;
+	}
+}
+function createLabelForBlankBinding(binding, factory) {
+	if (binding.blankType.value === "listHead") return factory.literal("RDFList");
+	const { class: classTerm } = binding;
+	return factory.literal(classTerm ? getLocalName(classTerm.value) ?? classTerm.value : "anonymous");
+}
+/**
+* Deduplicates identical in-flight queries, since the chains being followed
+* often overlap on their leading statements.
+*/
+var QueryExecutor = class {
+	queryFunction;
+	running = /* @__PURE__ */ new Map();
+	constructor(queryFunction) {
+		this.queryFunction = queryFunction;
+	}
+	executeQuery(query) {
+		const existing = this.running.get(query);
+		if (existing) return existing;
+		const execution = this.queryFunction(query).then((response) => {
+			this.running.delete(query);
+			return response;
+		}, (error) => {
+			this.running.delete(query);
+			throw error;
+		});
+		this.running.set(query, execution);
+		return execution;
+	}
+};
+/**
+* Replaces the raw blank node bindings in a lookup response with bindings whose `inst`
+* is an encoded IRI, resolving nested blank nodes along the way.
+*/
+async function updateLookupResults(result, queryFunction, settings, factory) {
+	const completeBindings = [];
+	const blankBindings = [];
+	for (const binding of result.results.bindings) if (isBlankBinding(binding)) blankBindings.push(binding);
+	else completeBindings.push(binding);
+	if (blankBindings.length === 0) return result;
+	const processedBindings = await processBlankBindings(blankBindings, queryFunction, settings, factory);
+	return {
+		...result,
+		results: {
+			...result.results,
+			bindings: completeBindings.concat(processedBindings)
+		}
+	};
+}
+/**
+* Groups raw blank node bindings by the blank node they describe, resolves any nested
+* blank nodes they point at and rewrites both the instance and the nested targets into
+* encoded IRIs.
+*
+* The bindings are mutated in place and returned.
+*/
+async function processBlankBindings(blankBindings, queryFunction, settings, factory) {
+	const bindingGroupsById = /* @__PURE__ */ new Map();
+	for (const binding of blankBindings) {
+		let group = bindingGroupsById.get(binding.inst.value);
+		if (!group) {
+			group = [];
+			bindingGroupsById.set(binding.inst.value, group);
+		}
+		group.push(binding);
+	}
+	const nestedChains = [];
+	for (const binding of blankBindings) if (isRdfBlank(binding.blankTrg)) nestedChains.push([binding]);
+	const loadedGroups = await loadRelatedBlankNodes(nestedChains, new QueryExecutor(queryFunction), settings, factory);
+	const { blankNodeStatementLimit } = settings;
+	const idsMap = getEncodedIdDictionary(loadedGroups, factory, blankNodeStatementLimit);
+	for (const group of bindingGroupsById.values()) {
+		for (const binding of group) {
+			const encodedNestedId = idsMap.get(binding.blankTrg.value);
+			if (encodedNestedId !== void 0) binding.blankTrg = factory.namedNode(encodedNestedId);
+			if (!binding.label) binding.label = createLabelForBlankBinding(binding, factory);
+		}
+		updateGroupIds(group, encodeId(group, blankNodeStatementLimit), factory);
+	}
+	return blankBindings.slice();
+}
+function getEncodedIdDictionary(blankBindingGroups, factory, statementLimit) {
+	const idDictionary = /* @__PURE__ */ new Map();
+	for (const [key, group] of blankBindingGroups) {
+		const encodedId = encodeId(group, statementLimit);
+		idDictionary.set(key, encodedId);
+		updateGroupIds(group, encodedId, factory);
+	}
+	return idDictionary;
+}
+function updateGroupIds(group, newId, factory) {
+	const inst = factory.namedNode(newId);
+	for (const binding of group) binding.inst = inst;
+}
+async function loadRelatedBlankNodes(blankChains, queryExecutor, settings, factory, recursionDeep = 1) {
+	const loadedBlankBindings = /* @__PURE__ */ new Map();
+	if (recursionDeep > 3 || blankChains.length === 0) return loadedBlankBindings;
+	const results = await Promise.all(blankChains.map(async (chain) => ({
+		chain,
+		response: await queryExecutor.executeQuery(getQueryForChain(chain, settings))
+	})));
+	await Promise.all(results.map(async ({ chain, response }) => {
+		const bindings = response.results.bindings;
+		if (bindings.length === 0) return;
+		const nestedChains = [];
+		for (const binding of bindings) if (isRdfBlank(binding.blankTrg)) nestedChains.push(chain.concat([binding]));
+		const idsMap = getEncodedIdDictionary(await loadRelatedBlankNodes(nestedChains, queryExecutor, settings, factory, recursionDeep + 1), factory, settings.blankNodeStatementLimit);
+		for (const binding of bindings) {
+			const encodedNestedId = idsMap.get(binding.blankTrg.value);
+			if (encodedNestedId !== void 0) binding.blankTrg = factory.namedNode(encodedNestedId);
+			binding.label = createLabelForBlankBinding(binding, factory);
+			let group = loadedBlankBindings.get(binding.inst.value);
+			if (!group) {
+				group = [];
+				loadedBlankBindings.set(binding.inst.value, group);
+			}
+			group.push(binding);
+		}
+	}));
+	return loadedBlankBindings;
+}
+/**
+* Builds a query which walks the chain of statements from the named node the chain starts at
+* down to the blank node at its end, and describes that blank node.
+*
+* The chain is expressed entirely in IRIs and predicates, since blank node labels from
+* a previous response cannot be used to address anything in a new query.
+*/
+function getQueryForChain(blankNodes, settings) {
+	function getQueryBlock(blankNode, index, maxIndex) {
+		const trustableTrgProp = index === 0 || blankNode.blankType.value !== "listHead";
+		const sourceId = index > 0 ? `?inst${index - 1}` : formatChainTerm(blankNode.blankSrc, `?blankAnySrc${index}`);
+		const sourcePropId = trustableTrgProp ? index > 0 ? `?blankTrgProp${index - 1}` : formatChainTerm(blankNode.blankSrcProp, `?blankAnySrcProp${index}`) : `?anyType${index}`;
+		const instPostfix = index === maxIndex ? "" : index.toString();
+		const targetPropId = trustableTrgProp ? formatChainTerm(blankNode.blankTrgProp, `?blankAnyTrgProp${index}`) : `?anyType0${index}`;
+		return `
+            # ======================
+            ${sourceId} ${sourcePropId} ?blankSrc${index}.
+            ${index === 0 && blankNode.blankType.value === "listHead" ? `?blankSrc${index} rdf:rest*/rdf:first ?inst${instPostfix}.` : `?blankSrc${index} ${targetPropId} ?inst${instPostfix}.`}
+            BIND (${formatChainTerm(blankNode.blankTrgProp, `?blankAnyBind${index}`)} as ?blankSrcProp${index}).
+            FILTER (ISBLANK(?inst${instPostfix})).
+            {
+                ?inst${instPostfix} ?blankTrgProp${instPostfix} ?blankTrg${instPostfix}.
+                BIND("blankNode" as ?blankType${instPostfix}).
+                FILTER NOT EXISTS { ?inst${instPostfix} rdf:first _:smth1${index} }.
+            } UNION {
+                ?inst${instPostfix} rdf:rest*/rdf:first ?blankTrg${instPostfix}.
+                ?blankSrc${index} ?blankSrcProp${index} ?inst${instPostfix}.
+                _:smth2${index} rdf:first ?blankTrg${instPostfix}.
+                BIND(?blankSrcProp${index} as ?blankTrgProp${instPostfix})
+                BIND("listHead" as ?blankType${instPostfix})
+                FILTER NOT EXISTS { _:smth3${index} rdf:rest ?inst${instPostfix} }.
+            }
+            OPTIONAL {
+                ?inst${instPostfix} rdf:type ?class${instPostfix}.
+            }
+        `;
+	}
+	const body = blankNodes.map((bn, index) => getQueryBlock(bn, index, blankNodes.length - 1)).join("\n");
+	return `${settings.defaultPrefix}
+    SELECT ?inst ?class ?label ?blankTrgProp ?blankTrg ?blankType
+        WHERE {
+           ${body}
+        }
+    `;
+}
+/**
+* Formats a chain term as an IRI, falling back to a fresh variable when the term is
+* missing or is itself a blank node, neither of which can be referenced from a query.
+*/
+function formatChainTerm(term, fallbackVariable) {
+	return isRdfIri(term) ? `<${term.value}>` : fallbackVariable;
+}
+/**
+* Answers {@link DataProvider.elements} for encoded blank nodes without querying the endpoint.
+*
+* Literal targets of the blank node are surfaced as element properties; targets which are
+* entities of their own become links instead, see {@link links}.
+*/
+function elements(elementIds, factory) {
+	const bindings = [];
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) if (isRdfLiteral(binding.blankTrg)) bindings.push({
+			...binding,
+			propType: binding.blankTrgProp,
+			propValue: binding.blankTrg
+		});
+		else bindings.push(binding);
+	}
+	return bindings;
+}
+/**
+* Answers {@link DataProvider.links} for encoded blank nodes without querying the endpoint.
+*
+* Only links where both ends are among the requested elements are returned, matching
+* the behavior of the endpoint-backed query.
+*/
+function links(elementIds, factory) {
+	const requested = new Set(elementIds);
+	const bindings = [];
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) {
+			const { inst, blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+			if (blankSrc && blankSrcProp && requested.has(blankSrc.value)) bindings.push({
+				source: blankSrc,
+				type: blankSrcProp,
+				target: inst
+			});
+			if (!isRdfLiteral(blankTrg) && requested.has(blankTrg.value)) bindings.push({
+				source: inst,
+				type: blankTrgProp,
+				target: blankTrg
+			});
+		}
+	}
+	return bindings;
+}
+/**
+* Answers {@link DataProvider.connectedLinkStats} for an encoded blank node without
+* querying the endpoint.
+*/
+function connectedLinkStats(elementId, factory) {
+	const blankBindings = decodeId(elementId, factory);
+	if (!blankBindings) return [];
+	const stats = /* @__PURE__ */ new Map();
+	function getOrCreate(linkTypeId) {
+		let count = stats.get(linkTypeId);
+		if (!count) {
+			count = {
+				id: linkTypeId,
+				inCount: 0,
+				outCount: 0
+			};
+			stats.set(linkTypeId, count);
+		}
+		return count;
+	}
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (isRdfLiteral(blankTrg)) continue;
+		if (blankSrc && blankSrcProp) {
+			const incoming = getOrCreate(blankSrcProp.value);
+			incoming.inCount += 1;
+		}
+		const outgoing = getOrCreate(blankTrgProp.value);
+		outgoing.outCount += 1;
+	}
+	return Array.from(stats.values());
+}
+/**
+* Answers {@link DataProvider.lookup} for navigation from an encoded blank node without
+* querying the endpoint, or returns `undefined` when the lookup is not about one.
+*/
+function lookup(params, factory) {
+	let bindings;
+	if (params.elementTypeId) return;
+	else if (params.refElementId && params.refElementLinkId) bindings = getAllRelatedByLinkTypeElements(params.refElementId, params.refElementLinkId, params.linkDirection, factory);
+	else if (params.refElementId) bindings = getAllRelatedElements(params.refElementId, factory);
+	else return;
+	if (bindings.length === 0) return;
+	if (params.text) {
+		const text = params.text.toLowerCase();
+		bindings = bindings.filter((binding) => binding.inst.value.toLowerCase().includes(text));
+	}
+	return {
+		head: { vars: [] },
+		results: { bindings }
+	};
+}
+/**
+* Answers the element type query for encoded blank nodes without querying the endpoint.
+*/
+function collectElementTypes$1(elementIds, factory, result) {
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) if (binding.class) {
+			let types = result.get(id);
+			if (!types) {
+				types = /* @__PURE__ */ new Set();
+				result.set(id, types);
+			}
+			types.add(binding.class.value);
+		}
+	}
+}
+/**
+* Answers navigation from an encoded blank node over a single link type.
+*
+* The direction is relative to the blank node: `in` collects the entities which point at it,
+* `out` the entities it points at.
+*/
+function getAllRelatedByLinkTypeElements(refElementId, refElementLinkId, linkDirection, factory) {
+	const blankBindings = decodeId(refElementId, factory);
+	if (!blankBindings) return [];
+	const linkType = factory.namedNode(refElementLinkId);
+	const bindings = [];
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (linkDirection !== "out" && blankSrc && blankSrcProp && blankSrcProp.value === refElementLinkId) pushRelated(bindings, blankSrc, linkType, "in", factory);
+		if (linkDirection !== "in" && blankTrgProp.value === refElementLinkId && !isRdfLiteral(blankTrg)) pushRelated(bindings, blankTrg, linkType, "out", factory);
+	}
+	return bindings;
+}
+/**
+* Answers navigation from an encoded blank node over every link type at once.
+*
+* Literal targets are left out: they are the blank node's own properties, not connections.
+*/
+function getAllRelatedElements(refElementId, factory) {
+	const blankBindings = decodeId(refElementId, factory);
+	if (!blankBindings) return [];
+	const bindings = [];
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (blankSrc && blankSrcProp) pushRelated(bindings, blankSrc, blankSrcProp, "in", factory);
+		if (!isRdfLiteral(blankTrg)) pushRelated(bindings, blankTrg, blankTrgProp, "out", factory);
+	}
+	return bindings;
+}
+/**
+* Adds the element at the far end of a statement to the result: a named node as-is,
+* an encoded blank node expanded back into the statements which describe it.
+*
+* The link type and the direction are carried over so that the result describes the
+* connection the same way an endpoint-backed lookup does. A named node is returned bare,
+* without a label or a type: {@link SparqlDataProvider.lookup} fills those in, since only
+* the endpoint knows them.
+*/
+function pushRelated(bindings, term, linkType, direction, factory) {
+	const connection = {
+		link: linkType,
+		direction: factory.literal(direction)
+	};
+	const nested = isRdfIri(term) ? decodeId(term.value, factory) : void 0;
+	if (nested) for (const binding of nested) bindings.push({
+		...binding,
+		...connection
+	});
+	else bindings.push({
+		inst: term,
+		...connection
+	});
+}
+//#endregion
 //#region src/data/sparql/requestChunking.ts
 function* chunkArray(items, measure, maxChunkSize) {
 	if (!Number.isFinite(maxChunkSize)) {
@@ -6460,46 +7021,6 @@ function* chunkDirectedCrossProduct(from, to, measure, maxChunkSize, excludedTar
 	}
 }
 //#endregion
-//#region src/data/sparql/sparqlModels.ts
-function mapSparqlResponseIntoRdfJs(response, factory) {
-	function mapSparqlBinding(binding) {
-		const mapped = {};
-		for (const key in binding) if (Object.prototype.hasOwnProperty.call(binding, key)) {
-			const term = binding[key];
-			switch (term.type) {
-				case "uri":
-					mapped[key] = factory.namedNode(term.value);
-					break;
-				case "bnode":
-					mapped[key] = factory.blankNode(term.value);
-					break;
-				case "literal":
-				case "typed-literal":
-					mapped[key] = factory.literal(term.value, term["xml:lang"] ? term["xml:lang"] : term.datatype ? factory.namedNode(term.datatype) : void 0);
-					break;
-				default: throw new Error(`Unexpected SPARQL term type: "${term.type}"`);
-			}
-		}
-		return mapped;
-	}
-	return {
-		...response,
-		results: {
-			...response.results,
-			bindings: response.results.bindings.map(mapSparqlBinding)
-		}
-	};
-}
-function isRdfIri(term) {
-	return Boolean(term && term.termType === "NamedNode");
-}
-function isRdfBlank(term) {
-	return Boolean(term && term.termType === "BlankNode");
-}
-function isRdfLiteral(term) {
-	return Boolean(term && term.termType === "Literal");
-}
-//#endregion
 //#region src/data/sparql/responseHandler.ts
 var TYPE_PREDICATE = "urn:reactodia:sparql:type";
 var LABEL_PREDICATE = "urn:reactodia:sparql:label";
@@ -6778,7 +7299,7 @@ function typeMatchesDomain(config, types) {
 function enrichElement(element, binding, labelPredicate) {
 	if (!element) return;
 	if (binding.label) appendProperty(element.properties, labelPredicate, binding.label);
-	if (binding.class && element.types.indexOf(binding.class.value) < 0) element.types.push(binding.class.value);
+	if (isRdfIri(binding.class) && element.types.indexOf(binding.class.value) < 0) element.types.push(binding.class.value);
 	if (binding.propType && binding.propValue && binding.propType.value !== LABEL_PREDICATE) appendProperty(element.properties, binding.propType.value, binding.propValue);
 }
 function appendLabel(container, newLabel) {
@@ -7034,7 +7555,7 @@ var SparqlDataProvider = class {
 	options;
 	settings;
 	queryFunction;
-	acceptBlankNodes = false;
+	acceptBlankNodes;
 	chunkMeasure;
 	linkByPredicate = /* @__PURE__ */ new Map();
 	linkById = /* @__PURE__ */ new Map();
@@ -7049,6 +7570,7 @@ var SparqlDataProvider = class {
 		this.options = options;
 		this.settings = settings;
 		this.queryFunction = queryFunction;
+		this.acceptBlankNodes = Boolean(settings.acceptBlankNodes);
 		const { chunk, queryMethod = "GET", prepareLabelPredicate, prepareImagePredicate } = this.options;
 		if (chunk) {
 			if (!Number.isSafeInteger(chunk.maxSize)) throw new Error("SparqlDataProviderOptions.chunk.maxSize should be a non-negative number");
@@ -7172,8 +7694,9 @@ var SparqlDataProvider = class {
 	}
 	async elements(params) {
 		const { elementIds, signal } = params;
+		const queriedIds = this.acceptBlankNodes ? elementIds.filter((iri) => !isEncodedBlank$1(iri)) : elementIds;
 		const triples = [];
-		if (elementIds.length > 0) await this.queryChunked(elementIds, async (batch) => {
+		if (queriedIds.length > 0) await this.queryChunked(queriedIds, async (batch) => {
 			const ids = batch.map(escapeIri).map((id) => ` (${id})`).join(" ");
 			const { defaultPrefix, dataLabelProperty, filterOnlyLanguages, elementInfoQuery } = this.settings;
 			const query = defaultPrefix + resolveTemplate(elementInfoQuery, {
@@ -7187,15 +7710,18 @@ var SparqlDataProvider = class {
 			for (const triple of response) triples.push(triple);
 		});
 		const types = this.queryManyElementTypes(this.settings.propertyConfigurations.length > 0 ? elementIds : [], signal);
-		const elementModels = getElementsInfo(triplesToElementBinding(triples), await types, this.propertyByPredicate, this.labelPredicate, this.openWorldProperties);
-		if (this.options.prepareLabels) await attachProperties(Array.from(elementModels.values()), this.options.prepareLabels, this.labelPredicate, signal);
-		if (this.options.prepareImages) await prepareElementImages(elementModels, this.options.prepareImages, this.imagePredicate, this.factory, signal);
+		const bindings = triplesToElementBinding(triples);
+		if (this.acceptBlankNodes) bindings.results.bindings.push(...elements(elementIds, this.factory));
+		const elementModels = getElementsInfo(bindings, await types, this.propertyByPredicate, this.labelPredicate, this.openWorldProperties);
+		if (this.options.prepareLabels) await attachProperties(Array.from(elementModels.values()), this.options.prepareLabels, this.labelPredicate, this.acceptBlankNodes, signal);
+		if (this.options.prepareImages) await prepareElementImages(elementModels, this.options.prepareImages, this.imagePredicate, this.factory, this.acceptBlankNodes, signal);
 		else if (this.options.imagePropertyUris && this.options.imagePropertyUris.length) await this.attachImages(elementModels, this.options.imagePropertyUris, signal);
 		return elementModels;
 	}
 	async attachImages(elements, imagePropertyIris, signal) {
 		const imageProperties = imagePropertyIris.map(escapeIri).map((id) => ` ( ${id} )`).join(" ");
-		await this.queryChunked(Array.from(elements.keys()), async (batch) => {
+		const imageableIds = Array.from(elements.keys()).filter((iri) => !(this.acceptBlankNodes && isEncodedBlank$1(iri)));
+		await this.queryChunked(imageableIds, async (batch) => {
 			const ids = batch.map((id) => ` ( ${escapeIri(id)} )`).join(" ");
 			const query = this.settings.defaultPrefix + `
                 SELECT ?inst ?linkType ?image
@@ -7217,12 +7743,14 @@ var SparqlDataProvider = class {
 		const { filterOnlyLanguages, linksInfoQuery } = this.settings;
 		const propLanguageFilter = formatLanguageFilter("?propValue", filterOnlyLanguages);
 		const linkConfigurations = this.formatLinkLinks();
+		const queriedPrimary = this.acceptBlankNodes ? primary.filter((iri) => !isEncodedBlank$1(iri)) : primary;
+		const queriedSecondary = this.acceptBlankNodes ? secondary.filter((iri) => !isEncodedBlank$1(iri)) : secondary;
 		let bindings;
-		if (primary.length > 0 && secondary.length > 0) if (linksInfoQuery.includes("${ids}")) bindings = this.queryUndirectedLinks(primary, secondary, {
+		if (queriedPrimary.length > 0 && queriedSecondary.length > 0) if (linksInfoQuery.includes("${ids}")) bindings = this.queryUndirectedLinks(queriedPrimary, queriedSecondary, {
 			propLanguageFilter,
 			linkConfigurations
 		}, signal);
-		else bindings = this.queryDirectedLinks(primary, secondary, {
+		else bindings = this.queryDirectedLinks(queriedPrimary, queriedSecondary, {
 			propLanguageFilter,
 			linkConfigurations
 		}, signal);
@@ -7233,7 +7761,13 @@ var SparqlDataProvider = class {
 			for (const iri of secondary) elementsForTypes.add(iri);
 		}
 		const types = this.queryManyElementTypes(elementsForTypes ? Array.from(elementsForTypes) : [], signal);
-		let linksInfo = getLinksInfo(await bindings, await types, this.linkByPredicate, this.openWorldLinks);
+		let allBindings = await bindings;
+		if (this.acceptBlankNodes) {
+			const connected = new Set(primary);
+			for (const iri of secondary) connected.add(iri);
+			allBindings = [...allBindings, ...links(Array.from(connected), this.factory)];
+		}
+		let linksInfo = getLinksInfo(allBindings, await types, this.linkByPredicate, this.openWorldLinks);
 		if (linkTypeIds) {
 			const allowedLinkTypes = new Set(linkTypeIds);
 			linksInfo = linksInfo.filter((link) => allowedLinkTypes.has(link.linkTypeId));
@@ -7272,6 +7806,7 @@ var SparqlDataProvider = class {
 	}
 	async connectedLinkStats(params) {
 		const { elementId, inexactCount, signal } = params;
+		if (this.acceptBlankNodes && isEncodedBlank$1(elementId)) return connectedLinkStats(elementId, this.factory);
 		const { defaultPrefix, linkTypesOfQuery, linkTypesStatisticsQuery, filterTypePattern } = this.settings;
 		const bindDirection = /\?direction\b/.test(linkTypesOfQuery);
 		const elementIri = escapeIri(elementId);
@@ -7337,11 +7872,48 @@ var SparqlDataProvider = class {
 			limit: baseParams.limit === void 0 ? 100 : baseParams.limit
 		};
 		const types = this.querySingleElementTypes(params.refElementId && this.settings.linkConfigurations.length > 0 ? params.refElementId : void 0, signal);
-		const filterQuery = this.createFilterQuery(params);
-		const linkedElements = getFilteredData(await this.executeSparqlSelect(filterQuery, { signal }), await types, this.linkByPredicate, this.labelPredicate, this.openWorldLinks);
-		if (this.options.prepareLabels) await attachProperties(linkedElements.map((linked) => linked.element), this.options.prepareLabels, this.labelPredicate, signal);
+		let bindings;
+		let navigatedFromBlank = false;
+		if (this.acceptBlankNodes) {
+			const fromBlank = lookup(params, this.factory);
+			if (fromBlank) {
+				bindings = fromBlank;
+				navigatedFromBlank = true;
+			} else bindings = await updateLookupResults(await this.executeSparqlSelect(this.createFilterQuery(params), { signal }), (blankQuery) => this.executeSparqlSelect(blankQuery, { signal }), this.settings, this.factory);
+		} else {
+			const filterQuery = this.createFilterQuery(params);
+			bindings = await this.executeSparqlSelect(filterQuery, { signal });
+		}
+		const linkedElements = getFilteredData(bindings, await types, this.linkByPredicate, this.labelPredicate, this.openWorldLinks);
+		if (navigatedFromBlank) return this.attachNeighborInfo(linkedElements, signal);
+		if (this.options.prepareLabels) await attachProperties(linkedElements.map((linked) => linked.element), this.options.prepareLabels, this.labelPredicate, this.acceptBlankNodes, signal);
 		return linkedElements;
 	}
+	/**
+	* Fills in the data of the elements found by navigating from a blank node.
+	*
+	* The navigation is answered by decoding the blank node IRI, which knows only the term
+	* at the far end of each statement, so everything else about a named neighbor - its
+	* label, types and properties - still has to be read from the endpoint. Without this
+	* the neighbor would render as its bare IRI.
+	*
+	* {@link elements} applies the {@link SparqlDataProviderOptions.prepareLabels} hook
+	* itself, so the caller must not apply it again.
+	*/
+	async attachNeighborInfo(items, signal) {
+		if (items.length === 0) return [];
+		const elementModels = await this.elements({
+			elementIds: items.map((item) => item.element.id),
+			signal
+		});
+		return items.map((item) => {
+			const element = elementModels.get(item.element.id);
+			return element ? {
+				...item,
+				element
+			} : item;
+		});
+	}
 	createFilterQuery(params) {
 		if (!params.refElementId && params.refElementLinkId) throw new Error("Cannot execute refElementLink filter without refElement");
 		let outerProjection = "?inst ?class ?label";
@@ -7367,10 +7939,14 @@ var SparqlDataProvider = class {
 			filterByType = this.settings.filterTypePattern.replace(/[?$]class\b/g, elementTypeIri);
 		}
 		const { defaultPrefix, dataLabelProperty, lookupQuery, filterOnlyLanguages, filterElementInfoPattern, fullTextSearch } = this.settings;
-		const queryElementInfo = resolveTemplate(filterElementInfoPattern, {
+		let queryElementInfo = resolveTemplate(filterElementInfoPattern, {
 			dataLabelProperty,
 			labelLanguageFilter: formatLanguageFilter("?label", filterOnlyLanguages)
 		});
+		if (this.acceptBlankNodes) {
+			outerProjection += ` ${BLANK_NODE_QUERY_PARAMETERS}`;
+			queryElementInfo += BLANK_NODE_QUERY;
+		}
 		let filterByText = "";
 		let orderBy = "";
 		if (params.text) {
@@ -7498,7 +8074,12 @@ var SparqlDataProvider = class {
 		if (elements.length === 0) return /* @__PURE__ */ new Map();
 		const { filterTypePattern } = this.settings;
 		const elementTypes = /* @__PURE__ */ new Map();
-		await this.queryChunked(elements, async (batch) => {
+		let queriedElements = elements;
+		if (this.acceptBlankNodes) {
+			queriedElements = elements.filter((iri) => !isEncodedBlank$1(iri));
+			collectElementTypes$1(elements, this.factory, elementTypes);
+		}
+		await this.queryChunked(queriedElements, async (batch) => {
 			const query = resolveTemplate("SELECT ?inst ?class { VALUES(?inst) { ${ids} } ${filterTypePattern} }", {
 				ids: batch.map((iri) => `(${escapeIri(iri)})`).join(" "),
 				filterTypePattern
@@ -7521,15 +8102,16 @@ async function attachLabels(items, fetchLabels, signal) {
 		if (itemLabels) item.label = itemLabels;
 	}
 }
-async function attachProperties(items, fetchProperties, propertyIri, signal) {
-	const properties = await fetchProperties(new Set(items.map((item) => item.id)), signal);
-	for (const item of items) {
+async function attachProperties(items, fetchProperties, propertyIri, acceptBlankNodes, signal) {
+	const resolvable = acceptBlankNodes ? items.filter((item) => !isEncodedBlank(item.id)) : items;
+	const properties = await fetchProperties(new Set(resolvable.map((item) => item.id)), signal);
+	for (const item of resolvable) {
 		const itemValues = properties.get(item.id);
 		if (itemValues) item.properties[propertyIri] = itemValues;
 	}
 }
-function prepareElementImages(elements, fetchImages, imagePropertyIri, factory, signal) {
-	return fetchImages(elements.values(), signal).then((images) => {
+function prepareElementImages(elements, fetchImages, imagePropertyIri, factory, acceptBlankNodes, signal) {
+	return fetchImages(acceptBlankNodes ? Array.from(elements.values()).filter((element) => !isEncodedBlank(element.id)) : elements.values(), signal).then((images) => {
 		for (const [iri, image] of images) {
 			const entity = elements.get(iri);
 			if (entity) appendProperty(entity.properties, imagePropertyIri, factory.namedNode(image));