ldkit 1.1.0 → 2.0.0

package/esm/library/schema/utils.js

@@ -1,12 +1,22 @@
-import xsd from "../namespaces/xsd.js";
+import { rdf } from "../../namespaces/rdf.js";
+import { xsd } from "../../namespaces/xsd.js";
 export const expandSchema = (schemaPrototype) => {
+    if (typeof schemaPrototype !== "object") {
+        throw new Error(`Invalid schema, expected object`);
+    }
+    if (Object.keys(schemaPrototype).length === 0) {
+        throw new Error(`Invalid schema, empty object, expected "@type" key or property definition`);
+    }
+    const expandShortcut = (value) => {
+        return value === "@type" ? rdf.type : value;
+    };
     const expandArray = (stringOrStrings) => {
         return Array.isArray(stringOrStrings) ? stringOrStrings : [stringOrStrings];
     };
     const expandSchemaProperty = (stringOrProperty) => {
         if (typeof stringOrProperty === "string") {
             return {
-                "@id": stringOrProperty,
+                "@id": expandShortcut(stringOrProperty),
                 "@type": xsd.string,
             };
         }
@@ -14,27 +24,34 @@ export const expandSchema = (schemaPrototype) => {
         if (!property["@id"]) {
             throw new Error(`Invalid schema, "@id" key for property missing`);
         }
+        if (property["@inverse"] && property["@multilang"]) {
+            throw new Error(`Invalid schema, "@inverse" property cannot be used with "@multilang"`);
+        }
         const validKeys = [
-            "@context",
+            "@schema",
             "@id",
             "@type",
             "@array",
             "@optional",
             "@multilang",
+            "@inverse",
         ];
         const baseProperty = {
             "@id": "",
         };
         const expandedProperty = Object.keys(property).reduce((acc, key) => {
-            if (key === "@context") {
+            if (key === "@schema") {
                 acc[key] = expandSchema(property[key]);
             }
+            else if (key === "@id") {
+                acc[key] = expandShortcut(property[key]);
+            }
             else if (validKeys.includes(key)) {
                 acc[key] = property[key];
             }
             return acc;
         }, baseProperty);
-        if (!baseProperty["@type"] && !baseProperty["@context"]) {
+        if (!baseProperty["@type"] && !baseProperty["@schema"]) {
             baseProperty["@type"] = xsd.string;
         }
         return expandedProperty;
@@ -42,12 +59,20 @@ export const expandSchema = (schemaPrototype) => {
     const baseSchema = {
         "@type": [],
     };
+    const existingPropertyMap = {};
     return Object.keys(schemaPrototype).reduce((acc, key) => {
         if (key === "@type") {
             acc[key] = expandArray(schemaPrototype[key]);
         }
         else {
-            acc[key] = expandSchemaProperty(schemaPrototype[key]);
+            const expandedProperty = expandSchemaProperty(schemaPrototype[key]);
+            if (existingPropertyMap[expandedProperty["@id"]]) {
+                throw new Error(`Invalid schema, duplicate property "${expandedProperty["@id"]}"`);
+            }
+            else {
+                existingPropertyMap[expandedProperty["@id"]] = true;
+            }
+            acc[key] = expandedProperty;
         }
         return acc;
     }, baseSchema);

package/esm/library/sparql/mod.js

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

package/esm/library/sparql/sparql_expression_builders.js

@@ -0,0 +1,18 @@
+import { bracesInline, SparqlBuilder } from "./sparql_shared_builders.js";
+class SparqlExpressionBuilder extends SparqlBuilder {
+    OPTIONAL(strings, ...values) {
+        return this.template(strings, values, "OPTIONAL", bracesInline);
+    }
+}
+/**
+ * SPARQL OPTIONAL expression fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { OPTIONAL } from "ldkit/sparql";
+ *
+ * const query = OPTIONAL`?s ?p ?o`.build();
+ * console.log(query); // OPTIONAL { ?s ?p ?o }
+ * ```
+ */
+export const OPTIONAL = (strings, ...values) => new SparqlExpressionBuilder().OPTIONAL(strings, ...values);

package/esm/library/sparql/sparql_query_builders.js

@@ -55,6 +55,27 @@ class SparqlQueryBuilder extends SparqlBuilder {
         return this.template(strings, values, "DESCRIBE");
     }
 }
+/**
+ * SPARQL SELECT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { SELECT } from "ldkit/sparql";
+ *
+ * const query = SELECT`?s`.WHERE`?s ?p ?o`.ORDER_BY`?s`.LIMIT(100).build();
+ * console.log(query);
+ * // SELECT ?s WHERE { ?s ?p ?o } ORDER BY ?s LIMIT 100
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { SELECT } from "ldkit/sparql";
+ *
+ * const query = SELECT.DISTINCT`?s`.WHERE`?s ?p ?o`.build();
+ * console.log(query);
+ * // SELECT DISTINCT ?s WHERE { ?s ?p ?o }
+ * ```
+ */
 export const SELECT = Object.assign((strings, ...values) => new SparqlQueryBuilder().SELECT(strings, ...values), {
     DISTINCT: (strings, ...values) => new SparqlQueryBuilder().SELECT_DISTINCT(strings, ...values),
     REDUCED: (strings, ...values) => new SparqlQueryBuilder().SELECT_REDUCED(strings, ...values),
@@ -62,12 +83,56 @@ export const SELECT = Object.assign((strings, ...values) => new SparqlQueryBuild
         return new SparqlQueryBuilder().SELECT `*`;
     },
 });
+/**
+ * SPARQL CONSTRUCT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { CONSTRUCT } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const sNode = df.namedNode("http://example.org/datasource");
+ * const pNode = df.namedNode("http://example.org/hasSubject");
+ *
+ * const query = CONSTRUCT`${sNode} ${pNode} ?s`.WHERE`?s ?p ?o`.build();
+ * console.log(query);
+ * // CONSTRUCT { <http://example.org/datasource> <http://example.org/hasSubject> ?s }
+ * // WHERE { ?s ?p ?o }
+ * ```
+ */
 export const CONSTRUCT = Object.assign((strings, ...values) => new SparqlQueryBuilder().CONSTRUCT(strings, ...values), {
     WHERE: (strings, ...values) => new SparqlQueryBuilder().CONSTRUCT_WHERE(strings, ...values),
 });
+/**
+ * SPARQL ASK query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { ASK } from "ldkit/sparql";
+ *
+ * const query = ASK`?s ?p ?o`.build();
+ * console.log(query); // ASK { ?s ?p ?o }
+ * ```
+ */
 export const ASK = Object.assign((strings, ...values) => new SparqlQueryBuilder().ASK(strings, ...values), {
     FROM: (stringOrNamedNode) => new SparqlQueryBuilder().ASK_FROM(stringOrNamedNode),
     FROM_NAMED: (stringOrNamedNode) => new SparqlQueryBuilder().ASK_FROM_NAMED(stringOrNamedNode),
     WHERE: (strings, ...values) => new SparqlQueryBuilder().ASK_WHERE(strings, ...values),
 });
+/**
+ * SPARQL DESCRIBE query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DESCRIBE } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const node = df.namedNode("http://example.org/resource");
+ *
+ * const query = DESCRIBE`${node}`.build();
+ * console.log(query); // DESCRIBE <http://example.org/resource>
+ * ```
+ */
 export const DESCRIBE = (strings, ...values) => new SparqlQueryBuilder().DESCRIBE(strings, ...values);

package/esm/library/sparql/sparql_shared_builders.js

@@ -1,6 +1,7 @@
 import { DataFactory } from "../rdf.js";
 import { sparql } from "./sparql_tag.js";
 export const braces = (keyword, value) => `${keyword} {\n${value}\n}\n`;
+export const bracesInline = (keyword, value) => `${keyword} { ${value} }`;
 export const parentheses = (keyword, value) => `${keyword} (${value})\n`;
 const none = (keyword, value) => `${keyword} ${value}\n`;
 export class SparqlBuilder {

package/esm/library/sparql/sparql_tag.js

@@ -1,6 +1,29 @@
 import { DataFactory } from "../rdf.js";
-import xsd from "../namespaces/xsd.js";
+import { xsd } from "../../namespaces/xsd.js";
 import { stringify } from "./stringify.js";
+/**
+ * A template tag for SPARQL queries or its parts. Automatically converts
+ * values to SPARQL literals and escapes strings as needed.
+ *
+ * @example
+ * ```typescript
+ * import { sparql } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const quad = df.quad(
+ *   df.namedNode("http://example.org/s"),
+ *   df.namedNode("http://example.org/p"),
+ *   df.literal("o"),
+ * );
+ * const query = sparql`SELECT * WHERE { ${quad} }`;
+ * console.log(query); // SELECT * WHERE { <http://example.org/s> <http://example.org/p> "o" . }
+ * ```
+ *
+ * @param strings {TemplateStringsArray} template strings
+ * @param values {SparqlValue[]}
+ * @returns {string} SPARQL query or its part
+ */
 export const sparql = (strings, ...values) => {
     let counter = 0;
     let result = "";
@@ -40,6 +63,9 @@ const valueToString = (value) => {
         }
         return result;
     }
+    if ("build" in value) {
+        return value.build();
+    }
     if (value.termType) {
         return stringify(value);
     }

package/esm/library/sparql/sparql_update_builders.js

@@ -21,14 +21,84 @@ class SparqlUpdateBuilder extends SparqlBuilder {
     DELETE_DATA(strings, ...values) {
         return this.template(strings, values, "DELETE DATA", braces);
     }
+    DELETE_WHERE(strings, ...values) {
+        return this.template(strings, values, "DELETE WHERE", braces);
+    }
     WITH(stringOrNamedNode) {
         return this.namedNode(stringOrNamedNode, "WITH");
     }
 }
+/**
+ * SPARQL INSERT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { INSERT } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ *
+ * const query = INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export const INSERT = Object.assign((strings, ...values) => new SparqlUpdateBuilder().INSERT(strings, ...values), {
     DATA: (strings, ...values) => new SparqlUpdateBuilder().INSERT_DATA(strings, ...values),
 });
+/**
+ * SPARQL DELETE query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DELETE } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ *
+ * const query = DELETE`?person ${firstName} "Jean"`
+ *   .INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // DELETE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export const DELETE = Object.assign((strings, ...values) => new SparqlUpdateBuilder().DELETE(strings, ...values), {
     DATA: (strings, ...values) => new SparqlUpdateBuilder().DELETE_DATA(strings, ...values),
+    WHERE: (strings, ...values) => new SparqlUpdateBuilder().DELETE_WHERE(strings, ...values),
 });
+/**
+ * SPARQL WITH query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DELETE } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ * const graph = df.namedNode("http://example.org/graph");
+ *
+ * const query = WITH(graph).DELETE`?person ${firstName} "Jean"`
+ *   .INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // WITH <http://example.org/graph>
+ * // DELETE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export const WITH = (stringOrNamedNode) => new SparqlUpdateBuilder().WITH(stringOrNamedNode);

package/esm/library/sparql/stringify.js

@@ -1,5 +1,5 @@
 import { DefaultGraph } from "../rdf.js";
-import xsd from "../namespaces/xsd.js";
+import { xsd } from "../../namespaces/xsd.js";
 import { escape } from "./escape.js";
 export const blankNode = (term) => {
     return `_:${term.value}`;
@@ -12,9 +12,8 @@ export const variable = (term) => {
 };
 export const literal = (term) => {
     const datatype = term.datatype.value;
-    if (datatype === xsd.integer || datatype === xsd.boolean ||
-        datatype === xsd.decimal) {
-        return term.value;
+    if (datatype === xsd.boolean) {
+        return term.value == "true" || term.value == "1" ? "true" : "false";
     }
     const value = `"${escape(term.value)}"`;
     if (term.language) {

package/esm/mod.js

@@ -1,4 +1,4 @@
-export { setDefaultContext, setDefaultEngine } from "./library/global.js";
-export { createLens, createResource } from "./library/lens/mod.js";
-export { createNamespace } from "./library/namespaces/namespace.js";
-export { QueryEngine } from "./library/engine/mod.js";
+export { setGlobalOptions } from "./library/options.js";
+export * from "./library/lens/mod.js";
+export * from "./library/namespace.js";
+export * from "./library/engine/mod.js";

package/esm/{library/namespaces → namespaces}/dbo.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * DBpedia Ontology
+ *
+ * `@dbo: <http://dbpedia.org/ontology/>`
+ */
+export const dbo = createNamespace({
     iri: "http://dbpedia.org/ontology/",
     prefix: "dbo:",
     terms: [

package/esm/{library/namespaces → namespaces}/dc.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * Dublin Core Metadata Element Set, Version 1.1
+ *
+ * `@dc: <http://purl.org/dc/elements/1.1/>`,
+ */
+export const dc = createNamespace({
     iri: "http://purl.org/dc/elements/1.1/",
     prefix: "dc:",
     terms: [

package/esm/{library/namespaces → namespaces}/dcterms.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * DCMI Metadata Terms
+ *
+ * `@dcterms: <http://purl.org/dc/terms/>`,
+ */
+export const dcterms = createNamespace({
     iri: "http://purl.org/dc/terms/",
     prefix: "dcterms:",
     terms: [

package/esm/{library/namespaces → namespaces}/foaf.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * The Friend of a Friend (FOAF) vocabulary, described using W3C RDF Schema and the Web Ontology Language.
+ *
+ * `@foaf: <http://xmlns.com/foaf/0.1/>`,
+ */
+export const foaf = createNamespace({
     iri: "http://xmlns.com/foaf/0.1/",
     prefix: "foaf:",
     terms: [

package/esm/{library/namespaces → namespaces}/gr.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * GoodRelations Ontology
+ *
+ * `@gr: <http://purl.org/goodrelations/v1#>`,
+ */
+export const gr = createNamespace({
     iri: "http://purl.org/goodrelations/v1#",
     prefix: "gr:",
     terms: [

package/esm/namespaces/ldkit.js

@@ -0,0 +1,11 @@
+import { createNamespace } from "../library/namespace.js";
+/**
+ * LDkit Ontology
+ *
+ * `@ldkit: <http://ldkit.io/ontology/>`,
+ */
+export const ldkit = createNamespace({
+    iri: "https://ldkit.io/ontology/",
+    prefix: "ldkit:",
+    terms: ["Resource", "IRI"],
+});

package/esm/namespaces/owl.js

@@ -0,0 +1,91 @@
+import { createNamespace } from "../library/namespace.js";
+/**
+ * OWL Web Ontology Language
+ *
+ * `@owl: <http://www.w3.org/2002/07/owl#>`,
+ */
+export const owl = createNamespace({
+    iri: "http://www.w3.org/2002/07/owl#",
+    prefix: "owl:",
+    terms: [
+        "owl:AllDifferent",
+        "owl:AllDisjointClasses",
+        "owl:AllDisjointProperties",
+        "owl:allValuesFrom",
+        "owl:annotatedProperty",
+        "owl:annotatedSource",
+        "owl:annotatedTarget",
+        "owl:Annotation",
+        "owl:AnnotationProperty",
+        "owl:assertionProperty",
+        "owl:AsymmetricProperty",
+        "owl:Axiom",
+        "owl:backwardCompatibleWith",
+        "owl:bottomDataProperty",
+        "owl:bottomObjectProperty",
+        "owl:cardinality",
+        "owl:Class",
+        "owl:complementOf",
+        "owl:DataRange",
+        "owl:datatypeComplementOf",
+        "owl:DatatypeProperty",
+        "owl:deprecated",
+        "owl:DeprecatedClass",
+        "owl:DeprecatedProperty",
+        "owl:differentFrom",
+        "owl:disjointUnionOf",
+        "owl:disjointWith",
+        "owl:distinctMembers",
+        "owl:equivalentClass",
+        "owl:equivalentProperty",
+        "owl:FunctionalProperty",
+        "owl:hasKey",
+        "owl:hasSelf",
+        "owl:hasValue",
+        "owl:imports",
+        "owl:incompatibleWith",
+        "owl:intersectionOf",
+        "owl:InverseFunctionalProperty",
+        "owl:inverseOf",
+        "owl:IrreflexiveProperty",
+        "owl:maxCardinality",
+        "owl:maxQualifiedCardinality",
+        "owl:members",
+        "owl:minCardinality",
+        "owl:minQualifiedCardinality",
+        "owl:NamedIndividual",
+        "owl:NegativePropertyAssertion",
+        "owl:Nothing",
+        "owl:ObjectProperty",
+        "owl:onClass",
+        "owl:onDataRange",
+        "owl:onDatatype",
+        "owl:oneOf",
+        "owl:onProperty",
+        "owl:onProperties",
+        "owl:Ontology",
+        "owl:OntologyProperty",
+        "owl:priorVersion",
+        "owl:propertyChainAxiom",
+        "owl:propertyDisjointWith",
+        "owl:qualifiedCardinality",
+        "owl:rational",
+        "owl:real",
+        "owl:ReflexiveProperty",
+        "owl:Restriction",
+        "owl:sameAs",
+        "owl:someValuesFrom",
+        "owl:sourceIndividual",
+        "owl:SymmetricProperty",
+        "owl:targetIndividual",
+        "owl:targetValue",
+        "owl:Thing",
+        "owl:topDataProperty",
+        "owl:topObjectProperty",
+        "owl:TransitiveProperty",
+        "owl:unionOf",
+        "owl:versionInfo",
+        "owl:versionIRI",
+        "owl:withRestrictions",
+    ],
+});

package/{script/library → esm}/namespaces/rdf.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * The RDF Concepts Vocabulary (RDF)
+ *
+ * `@rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>`,
+ */
+export const rdf = createNamespace({
     iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     prefix: "rdf:",
     terms: [

package/{script/library → esm}/namespaces/rdfs.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * The RDF Schema vocabulary (RDFS)
+ *
+ * `@rdfs: <http://www.w3.org/2000/01/rdf-schema#>`,
+ */
+export const rdfs = createNamespace({
     iri: "http://www.w3.org/2000/01/rdf-schema#",
     prefix: "rdfs:",
     terms: [

package/esm/{library/namespaces → namespaces}/schema.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * Schema.org vocabulary
+ *
+ * `@schema: <http://schema.org/>`,
+ */
+export const schema = createNamespace({
     iri: "http://schema.org/",
     prefix: "schema:",
     terms: [

package/esm/{library/namespaces → namespaces}/sioc.js

@@ -1,5 +1,10 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * SIOC Core Ontology Namespace
+ *
+ * `@sioc: <http://rdfs.org/sioc/ns#>`,
+ */
+export const sioc = createNamespace({
     iri: "http://rdfs.org/sioc/ns#",
     prefix: "sioc:",
     terms: [

package/{script/library → esm}/namespaces/skos.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * SKOS - Simple Knowledge Organization System
+ *
+ * `@skos: <http://www.w3.org/2004/02/skos/core#>`,
+ */
+export const skos = createNamespace({
     iri: "http://www.w3.org/2004/02/skos/core#",
     prefix: "skos:",
     terms: [

package/{script/library → esm}/namespaces/xsd.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+import { createNamespace } from "../library/namespace.js";
+/**
+ * XML Schema Definition Language (XSD)
+ *
+ * `@xsd: <http://www.w3.org/2001/XMLSchema#>`,
+ */
+export const xsd = createNamespace({
     iri: "http://www.w3.org/2001/XMLSchema#",
     prefix: "xsd:",
     terms: [

package/esm/namespaces.js

@@ -1 +1,30 @@
-export * from "./library/namespaces/mod.js";
+/**
+ * Popular namespaces used in Linked Data, fully compatible with LDkit,
+ * offering autocompletion and type checking in IDE.
+ *
+ * Create your own namespaces using {@link createNamespace} helper.
+ *
+ * @example
+ * ```typescript
+ * import { rdf, schema } from "ldkit/namespaces";
+ *
+ * console.log(rdf.type); // "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+ * console.log(schema.Person); // "http://schema.org/Person"
+ * ```
+ *
+ * @module
+ */
+export { dbo } from "./namespaces/dbo.js";
+export { dc } from "./namespaces/dc.js";
+export { dcterms } from "./namespaces/dcterms.js";
+export { foaf } from "./namespaces/foaf.js";
+export { gr } from "./namespaces/gr.js";
+export { ldkit } from "./namespaces/ldkit.js";
+export { owl } from "./namespaces/owl.js";
+export { rdf } from "./namespaces/rdf.js";
+export { rdfs } from "./namespaces/rdfs.js";
+export { schema } from "./namespaces/schema.js";
+export { sioc } from "./namespaces/sioc.js";
+export { skos } from "./namespaces/skos.js";
+export { xsd } from "./namespaces/xsd.js";
+export * from "./library/namespace.js";