ldkit 0.6.3 → 0.6.4

package/esm/library/decoder.js

@@ -1,5 +1,6 @@
 import { fromRdf } from "./rdf.js";
-import { ldkit, rdf } from "./namespaces/mod.js";
+import ldkit from "./namespaces/ldkit.js";
+import rdf from "./namespaces/rdf.js";
 class Decoder {
     constructor(graph, schema, context) {
         Object.defineProperty(this, "graph", {

package/esm/library/encoder.js

@@ -1,5 +1,6 @@
 import { DataFactory, toRdf } from "./rdf.js";
-import { rdf, xsd } from "./namespaces/mod.js";
+import xsd from "./namespaces/xsd.js";
+import rdf from "./namespaces/rdf.js";
 export const encode = (node, schema, context, variableInitCounter = 0) => {
     return Encoder.encode(node, schema, context, variableInitCounter);
 };

package/esm/library/rdf.js

@@ -1,7 +1,6 @@
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory } from "rdf-data-factory";
 export { DataFactory };
-import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 export const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {
@@ -39,10 +38,89 @@ export class TermFactory {
         return this.dataFactory.literal(jsonTerm.value);
     }
 }
-export class BindingsFactory extends ComunicaBindingsFactory {
-    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory()) {
-        super(dataFactory);
-        Object.defineProperty(this, "localDataFactory", {
+export class ReadOnlyBindings {
+    constructor(bindings, dataFactory = new DataFactory()) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "bindings"
+        });
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.entries = bindings;
+        this.dataFactory = dataFactory;
+        this.variables = new Map();
+        for (const variable of bindings.keys()) {
+            this.variables.set(variable.value, variable);
+        }
+    }
+    has(key) {
+        const stringKey = typeof key === "string" ? key : key.value;
+        const variableKey = this.variables.get(stringKey);
+        return this.entries.has(variableKey);
+    }
+    get(key) {
+        const stringKey = typeof key === "string" ? key : key.value;
+        const variableKey = this.variables.get(stringKey);
+        return this.entries.get(variableKey);
+    }
+    set(_key, _value) {
+        throw new Error("Method not implemented.");
+    }
+    delete(_key) {
+        throw new Error("Method not implemented.");
+    }
+    keys() {
+        return this.entries.keys();
+    }
+    values() {
+        return this.entries.values();
+    }
+    forEach(fn) {
+        return this.entries.forEach(fn);
+    }
+    get size() {
+        return this.entries.size;
+    }
+    [Symbol.iterator]() {
+        return this.entries.entries();
+    }
+    equals(_other) {
+        throw new Error("Method not implemented.");
+    }
+    filter(_fn) {
+        throw new Error("Method not implemented.");
+    }
+    map(_fn) {
+        throw new Error("Method not implemented.");
+    }
+    merge(_other) {
+        throw new Error("Method not implemented.");
+    }
+    mergeWith(_merger, _other) {
+        throw new Error("Method not implemented.");
+    }
+}
+export class BindingsFactory {
+    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory(dataFactory)) {
+        Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -54,21 +132,21 @@ export class BindingsFactory extends ComunicaBindingsFactory {
             writable: true,
             value: void 0
         });
-        this.localDataFactory = dataFactory;
+        this.dataFactory = dataFactory;
         this.termFactory = termFactory;
     }
     fromJson(jsonBindings) {
         const bindingsEntries = Object.entries(jsonBindings).map(([varName, jsonTerm]) => {
             return [
-                this.localDataFactory.variable(varName),
+                this.dataFactory.variable(varName),
                 this.termFactory.fromJson(jsonTerm),
             ];
         });
-        return this.bindings(bindingsEntries);
+        return new ReadOnlyBindings(new Map(bindingsEntries), this.dataFactory);
     }
 }
 export class QuadFactory {
-    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory()) {
+    constructor(dataFactory = new DataFactory(), termFactory = new TermFactory(dataFactory)) {
         Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,

package/esm/library/resource/query_builder.js

@@ -1,7 +1,8 @@
 import { getSchemaProperties } from "../schema/mod.js";
 import { $, CONSTRUCT, DELETE, INSERT, SELECT } from "../sparql.js";
 import { DataFactory } from "../rdf.js";
-import { ldkit, rdf } from "../namespaces/mod.js";
+import ldkit from "../namespaces/ldkit.js";
+import rdf from "../namespaces/rdf.js";
 import { encode } from "../encoder.js";
 import { QueryHelper } from "./query_helper.js";
 export class QueryBuilder {

package/esm/library/schema/data_types.js

@@ -1,4 +1,5 @@
-import { rdf, xsd } from "../namespaces/mod.js";
+import xsd from "../namespaces/xsd.js";
+import rdf from "../namespaces/rdf.js";
 const SupportedDataTypesPrototype = {
     [xsd.dateTime]: new Date(),
     [xsd.date]: new Date(),

package/esm/library/schema/utils.js

@@ -1,4 +1,4 @@
-import { xsd } from "../namespaces/mod.js";
+import xsd from "../namespaces/xsd.js";
 export const expandSchema = (schemaPrototype) => {
     const expandArray = (stringOrStrings) => {
         return Array.isArray(stringOrStrings) ? stringOrStrings : [stringOrStrings];

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -44,7 +44,6 @@
     }
   },
   "dependencies": {
-    "@comunica/bindings-factory": "2.2.0",
     "@comunica/types": "2.4.0",
     "@tpluscode/rdf-string": "0.2.26",
     "@tpluscode/sparql-builder": "0.3.23",

package/script/library/decoder.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode = void 0;
 const rdf_js_1 = require("./rdf.js");
-const mod_js_1 = require("./namespaces/mod.js");
+const ldkit_js_1 = __importDefault(require("./namespaces/ldkit.js"));
+const rdf_js_2 = __importDefault(require("./namespaces/rdf.js"));
 class Decoder {
     constructor(graph, schema, context) {
         Object.defineProperty(this, "graph", {
@@ -51,17 +55,17 @@ class Decoder {
     decode() {
         const output = [];
         for (const [iri, properties] of this.graph) {
-            if (properties.has(mod_js_1.rdf.type)) {
-                const types = properties.get(mod_js_1.rdf.type);
+            if (properties.has(rdf_js_2.default.type)) {
+                const types = properties.get(rdf_js_2.default.type);
                 for (const type of types) {
-                    if (type.termType === "NamedNode" && type.value === mod_js_1.ldkit.Resource) {
+                    if (type.termType === "NamedNode" && type.value === ldkit_js_1.default.Resource) {
                         output.push(this.decodeNode(iri, this.schema));
                     }
                 }
             }
         }
         if (this.graph.size > 0 && output.length < 1) {
-            throw new Error(`Unable to decode graph - no resources with type <${mod_js_1.ldkit.Resource}> found`);
+            throw new Error(`Unable to decode graph - no resources with type <${ldkit_js_1.default.Resource}> found`);
         }
         return output;
     }
@@ -91,12 +95,12 @@ class Decoder {
         return output;
     }
     decodeNodeType(node) {
-        const typeTerms = node.get(mod_js_1.rdf.type);
+        const typeTerms = node.get(rdf_js_2.default.type);
         if (!typeTerms) {
             return [];
         }
         return typeTerms.reduce((acc, term) => {
-            if (term.value !== mod_js_1.ldkit.Resource) {
+            if (term.value !== ldkit_js_1.default.Resource) {
                 acc.push(term.value);
             }
             return acc;

package/script/library/encoder.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encode = void 0;
 const rdf_js_1 = require("./rdf.js");
-const mod_js_1 = require("./namespaces/mod.js");
+const xsd_js_1 = __importDefault(require("./namespaces/xsd.js"));
+const rdf_js_2 = __importDefault(require("./namespaces/rdf.js"));
 const encode = (node, schema, context, variableInitCounter = 0) => {
     return Encoder.encode(node, schema, context, variableInitCounter);
 };
@@ -72,7 +76,7 @@ class Encoder {
     encodeNodeType(node, requiredTypes, nodeId) {
         const finalTypes = new Set([...this.getNodeTypes(node), ...requiredTypes]);
         finalTypes.forEach((type) => {
-            this.push(nodeId, this.df.namedNode(mod_js_1.rdf.type), this.df.namedNode(type));
+            this.push(nodeId, this.df.namedNode(rdf_js_2.default.type), this.df.namedNode(type));
         });
     }
     encodeNodeProperty(value, property, nodeId) {
@@ -104,9 +108,9 @@ class Encoder {
                 this.push(nodeId, propertyId, subNodeId);
                 return;
             }
-            const propertyType = property["@type"] ? property["@type"] : mod_js_1.xsd.string;
+            const propertyType = property["@type"] ? property["@type"] : xsd_js_1.default.string;
             if (typeof val === "string" && this.context.language) {
-                if (propertyType === mod_js_1.xsd.string || propertyType === mod_js_1.rdf.langString) {
+                if (propertyType === xsd_js_1.default.string || propertyType === rdf_js_2.default.langString) {
                     this.push(nodeId, propertyId, this.df.literal(val, this.context.language));
                     return;
                 }

package/script/library/rdf.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuadFactory = exports.BindingsFactory = exports.TermFactory = exports.quadsToGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
+exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
 var rdf_literal_1 = require("rdf-literal");
 Object.defineProperty(exports, "fromRdf", { enumerable: true, get: function () { return rdf_literal_1.fromRdf; } });
 Object.defineProperty(exports, "toRdf", { enumerable: true, get: function () { return rdf_literal_1.toRdf; } });
 const rdf_data_factory_1 = require("rdf-data-factory");
 Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_1.DataFactory; } });
-const bindings_factory_1 = require("@comunica/bindings-factory");
 const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {
@@ -46,10 +45,90 @@ class TermFactory {
     }
 }
 exports.TermFactory = TermFactory;
-class BindingsFactory extends bindings_factory_1.BindingsFactory {
-    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), termFactory = new TermFactory()) {
-        super(dataFactory);
-        Object.defineProperty(this, "localDataFactory", {
+class ReadOnlyBindings {
+    constructor(bindings, dataFactory = new rdf_data_factory_1.DataFactory()) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "bindings"
+        });
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.entries = bindings;
+        this.dataFactory = dataFactory;
+        this.variables = new Map();
+        for (const variable of bindings.keys()) {
+            this.variables.set(variable.value, variable);
+        }
+    }
+    has(key) {
+        const stringKey = typeof key === "string" ? key : key.value;
+        const variableKey = this.variables.get(stringKey);
+        return this.entries.has(variableKey);
+    }
+    get(key) {
+        const stringKey = typeof key === "string" ? key : key.value;
+        const variableKey = this.variables.get(stringKey);
+        return this.entries.get(variableKey);
+    }
+    set(_key, _value) {
+        throw new Error("Method not implemented.");
+    }
+    delete(_key) {
+        throw new Error("Method not implemented.");
+    }
+    keys() {
+        return this.entries.keys();
+    }
+    values() {
+        return this.entries.values();
+    }
+    forEach(fn) {
+        return this.entries.forEach(fn);
+    }
+    get size() {
+        return this.entries.size;
+    }
+    [Symbol.iterator]() {
+        return this.entries.entries();
+    }
+    equals(_other) {
+        throw new Error("Method not implemented.");
+    }
+    filter(_fn) {
+        throw new Error("Method not implemented.");
+    }
+    map(_fn) {
+        throw new Error("Method not implemented.");
+    }
+    merge(_other) {
+        throw new Error("Method not implemented.");
+    }
+    mergeWith(_merger, _other) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.ReadOnlyBindings = ReadOnlyBindings;
+class BindingsFactory {
+    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), termFactory = new TermFactory(dataFactory)) {
+        Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -61,22 +140,22 @@ class BindingsFactory extends bindings_factory_1.BindingsFactory {
             writable: true,
             value: void 0
         });
-        this.localDataFactory = dataFactory;
+        this.dataFactory = dataFactory;
         this.termFactory = termFactory;
     }
     fromJson(jsonBindings) {
         const bindingsEntries = Object.entries(jsonBindings).map(([varName, jsonTerm]) => {
             return [
-                this.localDataFactory.variable(varName),
+                this.dataFactory.variable(varName),
                 this.termFactory.fromJson(jsonTerm),
             ];
         });
-        return this.bindings(bindingsEntries);
+        return new ReadOnlyBindings(new Map(bindingsEntries), this.dataFactory);
     }
 }
 exports.BindingsFactory = BindingsFactory;
 class QuadFactory {
-    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), termFactory = new TermFactory()) {
+    constructor(dataFactory = new rdf_data_factory_1.DataFactory(), termFactory = new TermFactory(dataFactory)) {
         Object.defineProperty(this, "dataFactory", {
             enumerable: true,
             configurable: true,

package/script/library/resource/query_builder.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const mod_js_1 = require("../schema/mod.js");
 const sparql_js_1 = require("../sparql.js");
 const rdf_js_1 = require("../rdf.js");
-const mod_js_2 = require("../namespaces/mod.js");
+const ldkit_js_1 = __importDefault(require("../namespaces/ldkit.js"));
+const rdf_js_2 = __importDefault(require("../namespaces/rdf.js"));
 const encoder_js_1 = require("../encoder.js");
 const query_helper_js_1 = require("./query_helper.js");
 class QueryBuilder {
@@ -52,10 +56,10 @@ class QueryBuilder {
         this.df = new rdf_js_1.DataFactory();
     }
     getResourceSignature() {
-        return this.df.quad(this.df.variable("iri"), this.df.namedNode(mod_js_2.rdf.type), this.df.namedNode(mod_js_2.ldkit.Resource));
+        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf_js_2.default.type), this.df.namedNode(ldkit_js_1.default.Resource));
     }
     getTypesSignature() {
-        return this.df.quad(this.df.variable("iri"), this.df.namedNode(mod_js_2.rdf.type), this.df.variable("iri_type"));
+        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf_js_2.default.type), this.df.variable("iri_type"));
     }
     entitiesToQuads(entities) {
         const quadArrays = entities.map((entity) => (0, encoder_js_1.encode)(entity, this.schema, this.context));
@@ -69,7 +73,7 @@ class QueryBuilder {
             const properties = (0, mod_js_1.getSchemaProperties)(s);
             if (varPrefix !== "iri" || !omitRootTypes) {
                 rdfType.forEach((type) => {
-                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(mod_js_2.rdf.type), this.df.namedNode(type)));
+                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(rdf_js_2.default.type), this.df.namedNode(type)));
                 });
             }
             Object.keys(properties).forEach((prop, index) => {

package/script/library/schema/data_types.js

@@ -1,39 +1,43 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const mod_js_1 = require("../namespaces/mod.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
+const rdf_js_1 = __importDefault(require("../namespaces/rdf.js"));
 const SupportedDataTypesPrototype = {
-    [mod_js_1.xsd.dateTime]: new Date(),
-    [mod_js_1.xsd.date]: new Date(),
-    [mod_js_1.xsd.gDay]: new Date(),
-    [mod_js_1.xsd.gMonthDay]: new Date(),
-    [mod_js_1.xsd.gYear]: new Date(),
-    [mod_js_1.xsd.gYearMonth]: new Date(),
-    [mod_js_1.xsd.boolean]: true,
-    [mod_js_1.xsd.double]: 0.0,
-    [mod_js_1.xsd.decimal]: 0.0,
-    [mod_js_1.xsd.float]: 0.0,
-    [mod_js_1.xsd.integer]: 0,
-    [mod_js_1.xsd.long]: 0,
-    [mod_js_1.xsd.int]: 0,
-    [mod_js_1.xsd.byte]: 0,
-    [mod_js_1.xsd.short]: 0,
-    [mod_js_1.xsd.negativeInteger]: 0,
-    [mod_js_1.xsd.nonNegativeInteger]: 0,
-    [mod_js_1.xsd.nonPositiveInteger]: 0,
-    [mod_js_1.xsd.positiveInteger]: 0,
-    [mod_js_1.xsd.unsignedByte]: 0,
-    [mod_js_1.xsd.unsignedInt]: 0,
-    [mod_js_1.xsd.unsignedLong]: 0,
-    [mod_js_1.xsd.unsignedShort]: 0,
-    [mod_js_1.xsd.string]: "",
-    [mod_js_1.xsd.normalizedString]: "",
-    [mod_js_1.xsd.anyURI]: "",
-    [mod_js_1.xsd.base64Binary]: "",
-    [mod_js_1.xsd.language]: "",
-    [mod_js_1.xsd.Name]: "",
-    [mod_js_1.xsd.NCName]: "",
-    [mod_js_1.xsd.NMTOKEN]: "",
-    [mod_js_1.xsd.token]: "",
-    [mod_js_1.xsd.hexBinary]: "",
-    [mod_js_1.rdf.langString]: "",
+    [xsd_js_1.default.dateTime]: new Date(),
+    [xsd_js_1.default.date]: new Date(),
+    [xsd_js_1.default.gDay]: new Date(),
+    [xsd_js_1.default.gMonthDay]: new Date(),
+    [xsd_js_1.default.gYear]: new Date(),
+    [xsd_js_1.default.gYearMonth]: new Date(),
+    [xsd_js_1.default.boolean]: true,
+    [xsd_js_1.default.double]: 0.0,
+    [xsd_js_1.default.decimal]: 0.0,
+    [xsd_js_1.default.float]: 0.0,
+    [xsd_js_1.default.integer]: 0,
+    [xsd_js_1.default.long]: 0,
+    [xsd_js_1.default.int]: 0,
+    [xsd_js_1.default.byte]: 0,
+    [xsd_js_1.default.short]: 0,
+    [xsd_js_1.default.negativeInteger]: 0,
+    [xsd_js_1.default.nonNegativeInteger]: 0,
+    [xsd_js_1.default.nonPositiveInteger]: 0,
+    [xsd_js_1.default.positiveInteger]: 0,
+    [xsd_js_1.default.unsignedByte]: 0,
+    [xsd_js_1.default.unsignedInt]: 0,
+    [xsd_js_1.default.unsignedLong]: 0,
+    [xsd_js_1.default.unsignedShort]: 0,
+    [xsd_js_1.default.string]: "",
+    [xsd_js_1.default.normalizedString]: "",
+    [xsd_js_1.default.anyURI]: "",
+    [xsd_js_1.default.base64Binary]: "",
+    [xsd_js_1.default.language]: "",
+    [xsd_js_1.default.Name]: "",
+    [xsd_js_1.default.NCName]: "",
+    [xsd_js_1.default.NMTOKEN]: "",
+    [xsd_js_1.default.token]: "",
+    [xsd_js_1.default.hexBinary]: "",
+    [rdf_js_1.default.langString]: "",
 };

package/script/library/schema/utils.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSchemaProperties = exports.expandSchema = void 0;
-const mod_js_1 = require("../namespaces/mod.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
 const expandSchema = (schemaPrototype) => {
     const expandArray = (stringOrStrings) => {
         return Array.isArray(stringOrStrings) ? stringOrStrings : [stringOrStrings];
@@ -10,7 +13,7 @@ const expandSchema = (schemaPrototype) => {
         if (typeof stringOrProperty === "string") {
             return {
                 "@id": stringOrProperty,
-                "@type": mod_js_1.xsd.string,
+                "@type": xsd_js_1.default.string,
             };
         }
         const property = stringOrProperty;
@@ -38,7 +41,7 @@ const expandSchema = (schemaPrototype) => {
             return acc;
         }, baseProperty);
         if (!baseProperty["@type"] && !baseProperty["@context"]) {
-            baseProperty["@type"] = mod_js_1.xsd.string;
+            baseProperty["@type"] = xsd_js_1.default.string;
         }
         return expandedProperty;
     };

package/types/library/namespaces/dbo.d.ts

@@ -9,6 +9,13 @@ declare const _default: {
     range: "dbo:range";
     prefix: "dbo:prefix";
     length: "dbo:length";
+    Name: "dbo:Name";
+    date: "dbo:date";
+    duration: "dbo:duration";
+    language: "dbo:language";
+    time: "dbo:time";
+    List: "dbo:List";
+    description: "dbo:description";
     Academic: "dbo:Academic";
     AcademicConference: "dbo:AcademicConference";
     AcademicJournal: "dbo:AcademicJournal";
@@ -391,7 +398,6 @@ declare const _default: {
     LineOfFashion: "dbo:LineOfFashion";
     Linguist: "dbo:Linguist";
     Lipid: "dbo:Lipid";
-    List: "dbo:List";
     LiteraryGenre: "dbo:LiteraryGenre";
     Locality: "dbo:Locality";
     Lock: "dbo:Lock";
@@ -471,7 +477,6 @@ declare const _default: {
     MusicalWork: "dbo:MusicalWork";
     MythologicalFigure: "dbo:MythologicalFigure";
     NCAATeamSeason: "dbo:NCAATeamSeason";
-    Name: "dbo:Name";
     NarutoCharacter: "dbo:NarutoCharacter";
     NascarDriver: "dbo:NascarDriver";
     NationalAnthem: "dbo:NationalAnthem";
@@ -1391,7 +1396,6 @@ declare const _default: {
     damsire: "dbo:damsire";
     danseCompetition: "dbo:danseCompetition";
     danseScore: "dbo:danseScore";
-    date: "dbo:date";
     dateAct: "dbo:dateAct";
     dateAgreement: "dbo:dateAgreement";
     dateBudget: "dbo:dateBudget";
@@ -1455,7 +1459,6 @@ declare const _default: {
     deputy: "dbo:deputy";
     derivative: "dbo:derivative";
     derivedWord: "dbo:derivedWord";
-    description: "dbo:description";
     designCompany: "dbo:designCompany";
     designer: "dbo:designer";
     destination: "dbo:destination";
@@ -1534,7 +1537,6 @@ declare const _default: {
     drugbank: "dbo:drugbank";
     dryCargo: "dbo:dryCargo";
     dubber: "dbo:dubber";
-    duration: "dbo:duration";
     dutchArtworkCode: "dbo:dutchArtworkCode";
     dutchCOROPCode: "dbo:dutchCOROPCode";
     dutchMIPCode: "dbo:dutchMIPCode";
@@ -2069,7 +2071,6 @@ declare const _default: {
     landskap: "dbo:landskap";
     landtag: "dbo:landtag";
     landtagMandate: "dbo:landtagMandate";
-    language: "dbo:language";
     languageCode: "dbo:languageCode";
     languageFamily: "dbo:languageFamily";
     languageRegulator: "dbo:languageRegulator";
@@ -3406,7 +3407,6 @@ declare const _default: {
     thumbnail: "dbo:thumbnail";
     thumbnailCaption: "dbo:thumbnailCaption";
     tie: "dbo:tie";
-    time: "dbo:time";
     timeInSpace: "dbo:timeInSpace";
     timeZone: "dbo:timeZone";
     timeshiftChannel: "dbo:timeshiftChannel";

package/types/library/namespaces/dc.d.ts

@@ -1,11 +1,11 @@
 declare const _default: {
     subject: "dc:subject";
     type: "dc:type";
-    creator: "dc:creator";
     date: "dc:date";
+    language: "dc:language";
     description: "dc:description";
+    creator: "dc:creator";
     format: "dc:format";
-    language: "dc:language";
     publisher: "dc:publisher";
     relation: "dc:relation";
     source: "dc:source";

package/types/library/namespaces/dcterms.d.ts

@@ -1,16 +1,16 @@
 declare const _default: {
     subject: "dcterms:subject";
     type: "dcterms:type";
+    date: "dcterms:date";
+    language: "dcterms:language";
+    description: "dcterms:description";
     Agent: "dcterms:Agent";
     Standard: "dcterms:Standard";
     abstract: "dcterms:abstract";
     created: "dcterms:created";
     creator: "dcterms:creator";
-    date: "dcterms:date";
-    description: "dcterms:description";
     format: "dcterms:format";
     isPartOf: "dcterms:isPartOf";
-    language: "dcterms:language";
     license: "dcterms:license";
     publisher: "dcterms:publisher";
     relation: "dcterms:relation";

package/types/library/namespaces/gr.d.ts

@@ -1,8 +1,8 @@
 declare const _default: {
     includes: "gr:includes";
+    description: "gr:description";
     category: "gr:category";
     depth: "gr:depth";
-    description: "gr:description";
     height: "gr:height";
     name: "gr:name";
     owns: "gr:owns";

package/types/library/namespaces/rdf.d.ts

@@ -4,13 +4,13 @@ declare const _default: {
     predicate: "rdf:predicate";
     value: "rdf:value";
     type: "rdf:type";
-    List: "rdf:List";
     language: "rdf:language";
     Alt: "rdf:Alt";
     Bag: "rdf:Bag";
     CompoundLiteral: "rdf:CompoundLiteral";
     HTML: "rdf:HTML";
     JSON: "rdf:JSON";
+    List: "rdf:List";
     PlainLiteral: "rdf:PlainLiteral";
     Property: "rdf:Property";
     Seq: "rdf:Seq";

package/types/library/namespaces/rdfs.d.ts

@@ -1,10 +1,10 @@
 declare const _default: {
     Literal: "rdfs:Literal";
     range: "rdfs:range";
+    Resource: "rdfs:Resource";
     comment: "rdfs:comment";
     domain: "rdfs:domain";
     member: "rdfs:member";
-    Resource: "rdfs:Resource";
     Class: "rdfs:Class";
     Container: "rdfs:Container";
     ContainerMembershipProperty: "rdfs:ContainerMembershipProperty";

package/types/library/namespaces/schema.d.ts

@@ -3,6 +3,10 @@ declare const _default: {
     value: "schema:value";
     query: "schema:query";
     map: "schema:map";
+    duration: "schema:duration";
+    language: "schema:language";
+    Property: "schema:Property";
+    description: "schema:description";
     Airline: "schema:Airline";
     Airport: "schema:Airport";
     AnatomicalStructure: "schema:AnatomicalStructure";
@@ -94,14 +98,12 @@ declare const _default: {
     deathPlace: "schema:deathPlace";
     department: "schema:department";
     depth: "schema:depth";
-    description: "schema:description";
     differentialDiagnosis: "schema:differentialDiagnosis";
     director: "schema:director";
     dissolutionDate: "schema:dissolutionDate";
     distance: "schema:distance";
     drainsTo: "schema:drainsTo";
     drug: "schema:drug";
-    duration: "schema:duration";
     editor: "schema:editor";
     elevation: "schema:elevation";
     endDate: "schema:endDate";
@@ -131,7 +133,6 @@ declare const _default: {
     isbn: "schema:isbn";
     issn: "schema:issn";
     jurisdiction: "schema:jurisdiction";
-    language: "schema:language";
     license: "schema:license";
     location: "schema:location";
     logo: "schema:logo";
@@ -270,7 +271,6 @@ declare const _default: {
     valueAddedTaxIncluded: "schema:valueAddedTaxIncluded";
     valueReference: "schema:valueReference";
     vatID: "schema:vatID";
-    Property: "schema:Property";
     Class: "schema:Class";
     "3DModel": "schema:3DModel";
     AMRadioChannel: "schema:AMRadioChannel";

package/types/library/namespaces/sioc.d.ts

@@ -1,7 +1,8 @@
 declare const _default: {
     subject: "sioc:subject";
-    Community: "sioc:Community";
+    link: "sioc:link";
     description: "sioc:description";
+    Community: "sioc:Community";
     follows: "sioc:follows";
     id: "sioc:id";
     name: "sioc:name";
@@ -71,7 +72,6 @@ declare const _default: {
     later_version: "sioc:later_version";
     latest_version: "sioc:latest_version";
     likes: "sioc:likes";
-    link: "sioc:link";
     links_to: "sioc:links_to";
     member_of: "sioc:member_of";
     moderator_of: "sioc:moderator_of";

package/types/library/namespaces/xsd.d.ts

@@ -1,11 +1,6 @@
 declare const _default: {
     string: "xsd:string";
     boolean: "xsd:boolean";
-    Name: "xsd:Name";
-    date: "xsd:date";
-    duration: "xsd:duration";
-    language: "xsd:language";
-    time: "xsd:time";
     ENTITIES: "xsd:ENTITIES";
     ENTITY: "xsd:ENTITY";
     ID: "xsd:ID";
@@ -15,6 +10,7 @@ declare const _default: {
     NMTOKEN: "xsd:NMTOKEN";
     NMTOKENS: "xsd:NMTOKENS";
     NOTATION: "xsd:NOTATION";
+    Name: "xsd:Name";
     QName: "xsd:QName";
     anyAtomicType: "xsd:anyAtomicType";
     anySimpleType: "xsd:anySimpleType";
@@ -22,11 +18,13 @@ declare const _default: {
     anyURI: "xsd:anyURI";
     base64Binary: "xsd:base64Binary";
     byte: "xsd:byte";
+    date: "xsd:date";
     dateTime: "xsd:dateTime";
     dateTimeStamp: "xsd:dateTimeStamp";
     dayTimeDuration: "xsd:dayTimeDuration";
     decimal: "xsd:decimal";
     double: "xsd:double";
+    duration: "xsd:duration";
     float: "xsd:float";
     gDay: "xsd:gDay";
     gMonth: "xsd:gMonth";
@@ -36,6 +34,7 @@ declare const _default: {
     hexBinary: "xsd:hexBinary";
     int: "xsd:int";
     integer: "xsd:integer";
+    language: "xsd:language";
     long: "xsd:long";
     negativeInteger: "xsd:negativeInteger";
     nonNegativeInteger: "xsd:nonNegativeInteger";
@@ -43,6 +42,7 @@ declare const _default: {
     normalizedString: "xsd:normalizedString";
     positiveInteger: "xsd:positiveInteger";
     short: "xsd:short";
+    time: "xsd:time";
     token: "xsd:token";
     unsignedByte: "xsd:unsignedByte";
     unsignedInt: "xsd:unsignedInt";

package/types/library/rdf.d.ts

@@ -1,11 +1,8 @@
-import type { Bindings, BlankNode, Literal, NamedNode, Quad, Term, Variable } from "rdf-js";
-export type { Bindings, BlankNode, Literal, NamedNode, Quad, Term, Variable };
 import type * as RDF from "rdf-js";
 export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory } from "rdf-data-factory";
 export { DataFactory };
-import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export declare type LDkitContext = {
     graph?: string;
@@ -14,9 +11,9 @@ export declare type LDkitContext = {
 export declare type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
 export declare type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
 export declare type Iri = string;
-export declare type Node = Map<Iri, Term[]>;
+export declare type Node = Map<Iri, RDF.Term[]>;
 export declare type Graph = Map<Iri, Node>;
-export declare const quadsToGraph: (quads: Quad[]) => Graph;
+export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";
@@ -25,6 +22,7 @@ export declare namespace RDFJSON {
         datatype?: string;
     };
     type Bindings = Record<string, Term>;
+    type Triple = [Iri, Iri, Term];
     type SparqlResultsJsonFormat = {
         head: {
             vars?: string[];
@@ -42,23 +40,44 @@ export declare namespace RDFJSON {
         fromJson(jsonBindings: Bindings): RDF.Bindings;
     }
     interface QuadFactory {
-        fromJson(jsonRdf: [Iri, Iri, Term]): RDF.Quad;
+        fromJson(jsonRdf: Triple): RDF.Quad;
     }
 }
 export declare class TermFactory implements RDFJSON.TermFactory {
     protected readonly dataFactory: RDF.DataFactory;
     constructor(dataFactory?: RDF.DataFactory);
-    fromJson(jsonTerm: RDFJSON.Term): BlankNode | Literal | NamedNode<string>;
+    fromJson(jsonTerm: RDFJSON.Term): RDF.BlankNode | RDF.Literal | RDF.NamedNode<string>;
 }
-export declare class BindingsFactory extends ComunicaBindingsFactory implements RDFJSON.BindingsFactory {
-    protected readonly localDataFactory: RDF.DataFactory;
+export declare class ReadOnlyBindings implements RDF.Bindings {
+    readonly type = "bindings";
+    protected readonly dataFactory: RDF.DataFactory;
+    protected readonly entries: Map<RDF.Variable, RDF.Term>;
+    protected readonly variables: Map<string, RDF.Variable>;
+    constructor(bindings: Map<RDF.Variable, RDF.Term>, dataFactory?: RDF.DataFactory);
+    has(key: string | RDF.Variable): boolean;
+    get(key: string | RDF.Variable): RDF.Term | undefined;
+    set(_key: string | RDF.Variable, _value: RDF.Term): RDF.Bindings;
+    delete(_key: string | RDF.Variable): RDF.Bindings;
+    keys(): IterableIterator<RDF.Variable>;
+    values(): IterableIterator<RDF.Term>;
+    forEach(fn: (value: RDF.Term, key: RDF.Variable) => unknown): void;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<[RDF.Variable, RDF.Term]>;
+    equals(_other: RDF.Bindings | null | undefined): boolean;
+    filter(_fn: (value: RDF.Term, key: RDF.Variable) => boolean): RDF.Bindings;
+    map(_fn: (value: RDF.Term, key: RDF.Variable) => RDF.Term): RDF.Bindings;
+    merge(_other: RDF.Bindings): RDF.Bindings | undefined;
+    mergeWith(_merger: (self: RDF.Term, other: RDF.Term, key: RDF.Variable) => RDF.Term, _other: RDF.Bindings): RDF.Bindings;
+}
+export declare class BindingsFactory implements RDFJSON.BindingsFactory {
+    protected readonly dataFactory: RDF.DataFactory;
     protected readonly termFactory: RDFJSON.TermFactory;
     constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
-    fromJson(jsonBindings: RDFJSON.Bindings): Bindings;
+    fromJson(jsonBindings: RDFJSON.Bindings): ReadOnlyBindings;
 }
 export declare class QuadFactory implements RDFJSON.QuadFactory {
     protected readonly dataFactory: RDF.DataFactory;
     protected readonly termFactory: RDFJSON.TermFactory;
     constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
-    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): Quad;
+    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): RDF.Quad;
 }