ldkit 0.6.3 → 0.6.5

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);
 };
@@ -82,10 +83,11 @@ class Encoder {
             return;
         }
         if (property["@multilang"]) {
-            Object.keys(value).forEach((language) => {
-                const languageValue = Array.isArray(value[language])
-                    ? value[language]
-                    : [value[language]];
+            const multiValue = value;
+            Object.keys(multiValue).forEach((language) => {
+                const languageValue = Array.isArray(multiValue[language])
+                    ? multiValue[language]
+                    : [multiValue[language]];
                 languageValue.forEach((singleValue) => {
                     this.push(nodeId, propertyId, this.df.literal(singleValue, language.length > 0 ? language : undefined));
                 });

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";
+import { DataFactory, DefaultGraph, } from "rdf-data-factory";
+export { DataFactory, DefaultGraph };
 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 { CONSTRUCT, DELETE, INSERT, SELECT, sparql as $, } from "../sparql/mod.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 {
@@ -35,11 +36,11 @@ export class QueryBuilder {
             configurable: true,
             writable: true,
             value: (iris) => {
-                return DELETE `
-      ?s ?p ?o
-    `.WHERE `
-      ?s ?p ?o .
-      VALUES ?s { ${iris.map(this.df.namedNode)} }
+                return DELETE `
+      ?s ?p ?o
+    `.WHERE `
+      ?s ?p ?o .
+      VALUES ?s { ${iris.map(this.df.namedNode)} }
     `.build();
             }
         });
@@ -95,36 +96,36 @@ export class QueryBuilder {
         return SELECT `(count(?iri) as ?count)`.WHERE `${quads}`.build();
     }
     getQuery(where, limit = 1000) {
-        const selectSubQuery = SELECT `
-      ${this.df.variable("iri")}
-    `.WHERE `
-      ${this.getShape(false, true)}
-      ${where}
-    `.LIMIT(limit);
-        const query = CONSTRUCT `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      {
-        ${selectSubQuery}
-      }
+        const selectSubQuery = SELECT `
+      ${this.df.variable("iri")}
+    `.WHERE `
+      ${this.getShape(false, true)}
+      ${where}
+    `.LIMIT(limit).build();
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      {
+        ${selectSubQuery}
+      }
     `.build();
         return query;
     }
     getByIrisQuery(iris) {
-        const query = CONSTRUCT `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      VALUES ?iri {
-        ${iris.map(this.df.namedNode)}
-      }
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      VALUES ?iri {
+        ${iris.map(this.df.namedNode)}
+      }
     `.build();
         return query;
     }
@@ -136,7 +137,7 @@ export class QueryBuilder {
         return INSERT.DATA `${quads}`.build();
     }
     deleteDataQuery(quads) {
-        return $ `DELETE DATA { ${quads} }`.toString();
+        return DELETE.DATA `${quads}`.build();
     }
     updateQuery(entities) {
         const deleteQuads = [];

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/esm/library/sparql/escape.js

@@ -0,0 +1,22 @@
+const escapeCharRegEx = /["\\\n\r]/;
+const escapeCharRegExAll = /["\\\n\r]/g;
+const replacer = (char) => {
+    switch (char) {
+        case `"`:
+            return `\\"`;
+        case `\\`:
+            return `\\\\`;
+        case `\n`:
+            return `\\n`;
+        case `\r`:
+            return `\\r`;
+        default:
+            return char; // this should never happen
+    }
+};
+export const escape = (value) => {
+    if (escapeCharRegEx.test(value)) {
+        return value.replace(escapeCharRegExAll, replacer);
+    }
+    return value;
+};

package/esm/library/sparql/mod.js

@@ -0,0 +1,3 @@
+export { sparql } from "./sparql_tag.js";
+export { ASK, CONSTRUCT, DESCRIBE, SELECT } from "./sparql_query_builders.js";
+export { DELETE, INSERT, WITH } from "./sparql_update_builders.js";

package/esm/library/sparql/sparql_query_builders.js

@@ -0,0 +1,35 @@
+import { build, createNumericBuilder, createTemplateBuilder, } from "./sparql_shared_builders.js";
+const OFFSET = createNumericBuilder((value) => `OFFSET ${value}\n`, { build });
+const LIMIT = createNumericBuilder((value) => `LIMIT ${value}\n`, { build, OFFSET });
+const ORDER_BY = createTemplateBuilder((value) => `ORDER BY ${value}\n`, { build, LIMIT });
+const HAVING = createTemplateBuilder((value) => `HAVING(${value})\n`, { build, LIMIT });
+const GROUP_BY = createTemplateBuilder((value) => `GROUP BY ${value}\n`, { build, HAVING, ORDER_BY, LIMIT });
+const WHERE = createTemplateBuilder((value) => `WHERE {\n${value}\n}\n`, { build, GROUP_BY, ORDER_BY, LIMIT });
+const FROM_NAMED = createTemplateBuilder((value) => `FROM NAMED ${value}\n`, { WHERE });
+const FROM = createTemplateBuilder((value) => `FROM ${value}\n`, { FROM_NAMED, WHERE });
+const _SELECT = createTemplateBuilder((value) => `SELECT ${value}\n`, { FROM, FROM_NAMED, WHERE });
+const DISTINCT = createTemplateBuilder((value) => `SELECT DISTINCT ${value}\n`, { FROM, WHERE });
+const REDUCED = createTemplateBuilder((value) => `SELECT REDUCED ${value}\n`, {
+    FROM,
+    WHERE,
+});
+export const SELECT = Object.assign(_SELECT, {
+    DISTINCT,
+    REDUCED,
+    ALL: _SELECT `*`,
+});
+const _CONSTRUCT = createTemplateBuilder((value) => `CONSTRUCT {\n${value}\n}\n`, { WHERE });
+const _CONSTRUCT_WHERE = createTemplateBuilder((value) => `CONSTRUCT WHERE {\n${value}\n}\n`, { build, GROUP_BY, ORDER_BY, LIMIT });
+export const CONSTRUCT = Object.assign(_CONSTRUCT, {
+    WHERE: _CONSTRUCT_WHERE,
+});
+const _ASK = createTemplateBuilder((value) => `ASK {\n${value}\n}\n`, { build });
+const _ASK_FROM = createTemplateBuilder((value) => `ASK\nFROM ${value}\n`, { FROM_NAMED, WHERE });
+const _ASK_FROM_NAMED = createTemplateBuilder((value) => `ASK\nFROM NAMED ${value}\n`, { FROM_NAMED, WHERE });
+const _ASK_WHERE = createTemplateBuilder((value) => `ASK\nWHERE {\n${value}\n}\n`, { build, GROUP_BY, ORDER_BY, LIMIT });
+export const ASK = Object.assign(_ASK, {
+    FROM: _ASK_FROM,
+    FROM_NAMED: _ASK_FROM_NAMED,
+    WHERE: _ASK_WHERE,
+});
+export const DESCRIBE = createTemplateBuilder((value) => `DESCRIBE ${value}\n`, { build, FROM, FROM_NAMED, WHERE });

package/esm/library/sparql/sparql_shared_builders.js

@@ -0,0 +1,40 @@
+import { DataFactory } from "../rdf.js";
+import { sparql } from "./sparql_tag.js";
+const createContext = (self, current, builders) => {
+    const previousQuery = self?.$partialQuery || "";
+    const context = { $partialQuery: previousQuery + current };
+    return Object.keys(builders).reduce((acc, key) => {
+        acc[key] = builders[key].bind(context);
+        return acc;
+    }, {});
+};
+export const createTemplateBuilder = (wrap, builders) => {
+    return function (strings, ...values) {
+        const self = this;
+        const inner = sparql(strings, ...values);
+        const current = wrap(inner);
+        return createContext(self, current, builders);
+    };
+};
+export const createNumericBuilder = (wrap, builders) => {
+    return function (number) {
+        const self = this;
+        const current = wrap(number);
+        return createContext(self, current, builders);
+    };
+};
+const df = new DataFactory();
+export const createNamedNodeBuilder = (wrap, builders) => {
+    return function (stringOrNamedNode) {
+        const self = this;
+        const namedNode = typeof stringOrNamedNode === "string"
+            ? df.namedNode(stringOrNamedNode)
+            : stringOrNamedNode;
+        const inner = sparql `${namedNode}`;
+        const current = wrap(inner);
+        return createContext(self, current, builders);
+    };
+};
+export const build = function () {
+    return this?.$partialQuery || "";
+};

package/esm/library/sparql/sparql_tag.js

@@ -0,0 +1,47 @@
+import { DataFactory } from "../rdf.js";
+import xsd from "../namespaces/xsd.js";
+import { stringify } from "./stringify.js";
+export const sparql = (strings, ...values) => {
+    let counter = 0;
+    let result = "";
+    for (const value of values) {
+        result += strings[counter++];
+        result += valueToString(value);
+    }
+    result += strings[counter];
+    return result;
+};
+const isIterable = (obj) => {
+    return Symbol.iterator in Object(obj);
+};
+const df = new DataFactory();
+const valueToString = (value) => {
+    if (typeof value === "undefined" || value === null) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        const numberDataType = Number.isInteger(value) ? xsd.integer : xsd.decimal;
+        return stringify(df.literal(value.toString(), df.namedNode(numberDataType)));
+    }
+    if (typeof value === "boolean") {
+        return stringify(df.literal(value.toString(), df.namedNode(xsd.boolean)));
+    }
+    if (value instanceof Date) {
+        return stringify(df.literal(value.toISOString(), df.namedNode(xsd.dateTime)));
+    }
+    if (isIterable(value)) {
+        const [first, ...rest] = value;
+        let result = valueToString(first);
+        for (const part of rest) {
+            result += `\n${valueToString(part)}`;
+        }
+        return result;
+    }
+    if (value.termType) {
+        return stringify(value);
+    }
+    throw new Error("Not supported input type detected.");
+};

package/esm/library/sparql/sparql_update_builders.js

@@ -0,0 +1,15 @@
+import { build, createNamedNodeBuilder, createTemplateBuilder, } from "./sparql_shared_builders.js";
+const WHERE = createTemplateBuilder((value) => `WHERE {\n${value}\n}\n`, { build });
+const USING_NAMED = createNamedNodeBuilder((value) => `USING NAMED ${value}\n`, { WHERE });
+const USING = createNamedNodeBuilder((value) => `USING ${value}\n`, { USING_NAMED, WHERE });
+const _INSERT = createTemplateBuilder((value) => `INSERT {\n${value}\n}\n`, { USING, USING_NAMED, WHERE });
+const _INSERT_DATA = createTemplateBuilder((value) => `INSERT DATA {\n${value}\n}\n`, { build });
+export const INSERT = Object.assign(_INSERT, {
+    DATA: _INSERT_DATA,
+});
+const _DELETE = createTemplateBuilder((value) => `DELETE {\n${value}\n}\n`, { INSERT: _INSERT, USING, USING_NAMED, WHERE });
+const _DELETE_DATA = createTemplateBuilder((value) => `DELETE DATA {\n${value}\n}\n`, { build });
+export const DELETE = Object.assign(_DELETE, {
+    DATA: _DELETE_DATA,
+});
+export const WITH = createNamedNodeBuilder((value) => `WITH ${value}\n`, { build, INSERT: _INSERT, DELETE: _DELETE });

package/esm/library/sparql/stringify.js

@@ -0,0 +1,50 @@
+import { DefaultGraph } from "../rdf.js";
+import xsd from "../namespaces/xsd.js";
+import { escape } from "./escape.js";
+export const blankNode = (term) => {
+    return `_:${term.value}`;
+};
+export const namedNode = (term) => {
+    return `<${term.value}>`;
+};
+export const variable = (term) => {
+    return `?${term.value}`;
+};
+export const literal = (term) => {
+    const datatype = term.datatype.value;
+    if (datatype === xsd.integer || datatype === xsd.boolean ||
+        datatype === xsd.decimal) {
+        return term.value;
+    }
+    const value = `"${escape(term.value)}"`;
+    if (term.language) {
+        return `${value}@${term.language}`;
+    }
+    if (datatype !== xsd.string) {
+        return `${value}^^${namedNode(term.datatype)}`;
+    }
+    return value;
+};
+const quad = (term) => {
+    const triple = `${stringify(term.subject)} ${stringify(term.predicate)} ${stringify(term.object)} .`;
+    if (term.graph.equals(DefaultGraph.INSTANCE)) {
+        return triple;
+    }
+    return `GRAPH ${stringify(term.graph)} { ${triple} }`;
+};
+export const stringify = (term) => {
+    switch (term.termType) {
+        case "BlankNode":
+            return blankNode(term);
+        case "NamedNode":
+            return namedNode(term);
+        case "Variable":
+            return variable(term);
+        case "Literal":
+            return literal(term);
+        case "Quad":
+            return quad(term);
+        default:
+            throw new Error("Unknown RDF type found.");
+    }
+};

package/esm/sparql.js

@@ -1 +1 @@
-export * from "./library/sparql.js";
+export * from "./library/sparql/mod.js";

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.5",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -44,10 +44,7 @@
     }
   },
   "dependencies": {
-    "@comunica/bindings-factory": "2.2.0",
     "@comunica/types": "2.4.0",
-    "@tpluscode/rdf-string": "0.2.26",
-    "@tpluscode/sparql-builder": "0.3.23",
     "asynciterator": "3.7.0",
     "rdf-data-factory": "1.1.1",
     "rdf-js": "4.0.2",

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) {
@@ -86,10 +90,11 @@ class Encoder {
             return;
         }
         if (property["@multilang"]) {
-            Object.keys(value).forEach((language) => {
-                const languageValue = Array.isArray(value[language])
-                    ? value[language]
-                    : [value[language]];
+            const multiValue = value;
+            Object.keys(multiValue).forEach((language) => {
+                const languageValue = Array.isArray(multiValue[language])
+                    ? multiValue[language]
+                    : [multiValue[language]];
                 languageValue.forEach((singleValue) => {
                     this.push(nodeId, propertyId, this.df.literal(singleValue, language.length > 0 ? language : undefined));
                 });
@@ -104,9 +109,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;
                 }