ldkit 0.6.4 → 0.7.0

package/README.md

@@ -37,18 +37,12 @@ For Deno environment, you can import LDkit like this:
 import * as ldkit from "https://deno.land/x/ldkit/mod.ts";
 ```
 
-### Set up RDF source and create data schema
+### Create data schema and set up RDF source
 
 ```ts
-import { type Context, createResource } from "ldkit";
+import { type Context, createLens } from "ldkit";
 import { dbo, rdfs, xsd } from "ldkit/namespaces";
 
-// Create a context for query engine
-const context: Context = {
-  sources: ["https://dbpedia.org/sparql"], // SPARQL endpoint
-  language: "en", // Preferred language
-};
-
 // Create a schema
 const PersonSchema = {
   "@type": dbo.Person,
@@ -60,22 +54,28 @@ const PersonSchema = {
   },
 } as const;
 
+// Create a context for query engine
+const context: Context = {
+  sources: ["https://dbpedia.org/sparql"], // SPARQL endpoint
+  language: "en", // Preferred language
+};
+
 // Create a resource using the data schema and context above
-const Person = createResource(PersonSchema, context);
+const Persons = createLens(PersonSchema, context);
 ```
 
 ### List all available data
 
 ```ts
 // List all persons
-const persons = await Person.find();
+const persons = await Persons.find();
 for (const person of persons) {
   console.log(person.name); // string
   console.log(person.birthDate); // Date
 }
 
 // Get total count of all persons
-const count = await Person.count();
+const count = await Persons.count();
 console.log(count); // number
 ```
 
@@ -83,7 +83,7 @@ console.log(count); // number
 
 ```ts
 // Get a particular person identified by IRI
-const ada = await Person.findByIri("http://dbpedia.org/resource/Ada_Lovelace");
+const ada = await Persons.findByIri("http://dbpedia.org/resource/Ada_Lovelace");
 console.log(ada?.name); // string "Ada Lovelace"
 console.log(ada?.birthDate); // Date object of 1815-12-10
 ```
@@ -92,20 +92,20 @@ console.log(ada?.birthDate); // Date object of 1815-12-10
 
 ```ts
 // Insert a new person
-Person.insert({
+Persons.insert({
   $id: "http://dbpedia.org/resource/Alan_Turing",
   name: "Alan Turing",
   birthDate: new Date("1912-06-23"),
 });
 
 // Modify a person's name
-Person.update({
+Persons.update({
   $id: "http://dbpedia.org/resource/Alan_Turing",
   name: "Not Alan Turing",
 });
 
 // Delete a person
-Person.delete("http://dbpedia.org/resource/Alan_Turing");
+Persons.delete("http://dbpedia.org/resource/Alan_Turing");
 ```
 
 More complex examples can be found in [documentation](https://ldkit.io/docs).

package/esm/library/encoder.js

@@ -83,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/global.js

@@ -6,7 +6,7 @@ export const setDefaultContext = (context) => {
 };
 export const resolveContext = (context) => {
     if (!context && !defaultContext) {
-        throw new Error("No context found. Please create a default context or pass one to createResource function");
+        throw new Error("No context found. Please create a default context or pass one to createLens function");
     }
     return context || defaultContext;
 };
@@ -18,7 +18,7 @@ export const resolveEngine = (engine) => {
         setDefaultEngine(new QueryEngine());
         // TODO: consider the consequences here, maybe log a warning?
         /*throw new Error(
-          "No engine found. Please create a default engine or pass one to createResource function",
+          "No engine found. Please create a default engine or pass one to createLens function",
         );*/
     }
     return engine || defaultEngine;

package/esm/library/{resource/resource.js → lens/lens.js}

@@ -3,8 +3,23 @@ import { expandSchema, } from "../schema/mod.js";
 import { decode } from "../decoder.js";
 import { QueryBuilder } from "./query_builder.js";
 import { QueryEngineProxy } from "../engine/query_engine_proxy.js";
-export const createResource = (spec, context, engine) => new Resource(spec, context, engine);
-export class Resource {
+/**
+ * Lens lets you query and update RDF data via data schema using TypeScript native data types.
+ *
+ * https://ldkit.io/docs/components/lens
+ *
+ * @param schema data schema which extends `SchemaPrototype`
+ * @param context optional `Context` - contains LDkit and query engine configuration
+ * @param engine optional Query Engine
+ * @returns Lens instance
+ */
+export const createLens = (schema, context, engine) => new Lens(schema, context, engine);
+/**
+ * @deprecated
+ * Use `createLens` instead
+ */
+export const createResource = (schema, context, engine) => new Lens(schema, context, engine);
+export class Lens {
     constructor(schema, context, engine) {
         Object.defineProperty(this, "schema", {
             enumerable: true,

package/esm/library/lens/mod.js

@@ -0,0 +1 @@
+export { createLens, createResource } from "./lens.js";

package/esm/library/{resource → lens}/query_builder.js

@@ -1,5 +1,5 @@
 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 from "../namespaces/ldkit.js";
 import rdf from "../namespaces/rdf.js";
@@ -36,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();
             }
         });
@@ -96,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;
     }
@@ -137,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/rdf.js

@@ -1,6 +1,6 @@
 export { fromRdf, toRdf } from "rdf-literal";
-import { DataFactory } from "rdf-data-factory";
-export { DataFactory };
+import { DataFactory, DefaultGraph, } from "rdf-data-factory";
+export { DataFactory, DefaultGraph };
 export const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {

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,73 @@
+import { braces, parentheses, SparqlBuilder, } from "./sparql_shared_builders.js";
+class SparqlQueryBuilder extends SparqlBuilder {
+    OFFSET(number) {
+        return this.number(number, "OFFSET");
+    }
+    LIMIT(number) {
+        return this.number(number, "LIMIT");
+    }
+    ORDER_BY(strings, ...values) {
+        return this.template(strings, values, "ORDER BY");
+    }
+    HAVING(strings, ...values) {
+        return this.template(strings, values, "HAVING", parentheses);
+    }
+    GROUP_BY(strings, ...values) {
+        return this.template(strings, values, "GROUP BY");
+    }
+    WHERE(strings, ...values) {
+        return this.template(strings, values, "WHERE", braces);
+    }
+    FROM_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "FROM NAMED");
+    }
+    FROM(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "FROM");
+    }
+    SELECT(strings, ...values) {
+        return this.template(strings, values, "SELECT");
+    }
+    SELECT_DISTINCT(strings, ...values) {
+        return this.template(strings, values, "SELECT DISTINCT");
+    }
+    SELECT_REDUCED(strings, ...values) {
+        return this.template(strings, values, "SELECT REDUCED");
+    }
+    CONSTRUCT(strings, ...values) {
+        return this.template(strings, values, "CONSTRUCT", braces);
+    }
+    CONSTRUCT_WHERE(strings, ...values) {
+        return this.template(strings, values, "CONSTRUCT WHERE", braces);
+    }
+    ASK(strings, ...values) {
+        return this.template(strings, values, "ASK", braces);
+    }
+    ASK_FROM(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "ASK\nFROM");
+    }
+    ASK_FROM_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "ASK\nFROM NAMED");
+    }
+    ASK_WHERE(strings, ...values) {
+        return this.template(strings, values, "ASK\nWHERE", braces);
+    }
+    DESCRIBE(strings, ...values) {
+        return this.template(strings, values, "DESCRIBE");
+    }
+}
+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),
+    get ALL() {
+        return new SparqlQueryBuilder().SELECT `*`;
+    },
+});
+export const CONSTRUCT = Object.assign((strings, ...values) => new SparqlQueryBuilder().CONSTRUCT(strings, ...values), {
+    WHERE: (strings, ...values) => new SparqlQueryBuilder().CONSTRUCT_WHERE(strings, ...values),
+});
+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),
+});
+export const DESCRIBE = (strings, ...values) => new SparqlQueryBuilder().DESCRIBE(strings, ...values);

package/esm/library/sparql/sparql_shared_builders.js

@@ -0,0 +1,46 @@
+import { DataFactory } from "../rdf.js";
+import { sparql } from "./sparql_tag.js";
+export const braces = (keyword, value) => `${keyword} {\n${value}\n}\n`;
+export const parentheses = (keyword, value) => `${keyword} (${value})\n`;
+const none = (keyword, value) => `${keyword} ${value}\n`;
+export class SparqlBuilder {
+    constructor() {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new DataFactory()
+        });
+    }
+    build() {
+        return this.value;
+    }
+    sparql(strings, ...values) {
+        return !values || values.length < 1
+            ? sparql(strings)
+            : sparql(strings, ...values);
+    }
+    template(strings, values, keyword, wrap = none) {
+        const inputSparql = this.sparql(strings, ...values);
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    namedNode(stringOrNamedNode, keyword, wrap = none) {
+        const namedNode = typeof stringOrNamedNode === "string"
+            ? this.dataFactory.namedNode(stringOrNamedNode)
+            : stringOrNamedNode;
+        const inputSparql = this.sparql `${namedNode}`;
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    number(number, keyword, wrap = none) {
+        this.value += wrap(keyword, number.toString());
+        return this;
+    }
+}

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,34 @@
+import { braces, SparqlBuilder } from "./sparql_shared_builders.js";
+class SparqlUpdateBuilder extends SparqlBuilder {
+    WHERE(strings, ...values) {
+        return this.template(strings, values, "WHERE", braces);
+    }
+    USING_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING NAMED");
+    }
+    USING(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING");
+    }
+    INSERT(strings, ...values) {
+        return this.template(strings, values, "INSERT", braces);
+    }
+    INSERT_DATA(strings, ...values) {
+        return this.template(strings, values, "INSERT DATA", braces);
+    }
+    DELETE(strings, ...values) {
+        return this.template(strings, values, "DELETE", braces);
+    }
+    DELETE_DATA(strings, ...values) {
+        return this.template(strings, values, "DELETE DATA", braces);
+    }
+    WITH(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "WITH");
+    }
+}
+export const INSERT = Object.assign((strings, ...values) => new SparqlUpdateBuilder().INSERT(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().INSERT_DATA(strings, ...values),
+});
+export const DELETE = Object.assign((strings, ...values) => new SparqlUpdateBuilder().DELETE(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().DELETE_DATA(strings, ...values),
+});
+export const WITH = (stringOrNamedNode) => new SparqlUpdateBuilder().WITH(stringOrNamedNode);

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/mod.js

@@ -1,3 +1,3 @@
 export { setDefaultContext, setDefaultEngine } from "./library/global.js";
-export { createResource } from "./library/resource/mod.js";
+export { createLens, createResource } from "./library/lens/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";

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.4",
+  "version": "0.7.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -45,8 +45,6 @@
   },
   "dependencies": {
     "@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/encoder.js

@@ -90,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));
                 });

package/script/library/global.js

@@ -10,7 +10,7 @@ const setDefaultContext = (context) => {
 exports.setDefaultContext = setDefaultContext;
 const resolveContext = (context) => {
     if (!context && !defaultContext) {
-        throw new Error("No context found. Please create a default context or pass one to createResource function");
+        throw new Error("No context found. Please create a default context or pass one to createLens function");
     }
     return context || defaultContext;
 };
@@ -24,7 +24,7 @@ const resolveEngine = (engine) => {
         (0, exports.setDefaultEngine)(new mod_js_1.QueryEngine());
         // TODO: consider the consequences here, maybe log a warning?
         /*throw new Error(
-          "No engine found. Please create a default engine or pass one to createResource function",
+          "No engine found. Please create a default engine or pass one to createLens function",
         );*/
     }
     return engine || defaultEngine;

package/script/library/{resource/resource.js → lens/lens.js}

@@ -1,14 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Resource = exports.createResource = void 0;
+exports.Lens = exports.createResource = exports.createLens = void 0;
 const global_js_1 = require("../global.js");
 const mod_js_1 = require("../schema/mod.js");
 const decoder_js_1 = require("../decoder.js");
 const query_builder_js_1 = require("./query_builder.js");
 const query_engine_proxy_js_1 = require("../engine/query_engine_proxy.js");
-const createResource = (spec, context, engine) => new Resource(spec, context, engine);
+/**
+ * Lens lets you query and update RDF data via data schema using TypeScript native data types.
+ *
+ * https://ldkit.io/docs/components/lens
+ *
+ * @param schema data schema which extends `SchemaPrototype`
+ * @param context optional `Context` - contains LDkit and query engine configuration
+ * @param engine optional Query Engine
+ * @returns Lens instance
+ */
+const createLens = (schema, context, engine) => new Lens(schema, context, engine);
+exports.createLens = createLens;
+/**
+ * @deprecated
+ * Use `createLens` instead
+ */
+const createResource = (schema, context, engine) => new Lens(schema, context, engine);
 exports.createResource = createResource;
-class Resource {
+class Lens {
     constructor(schema, context, engine) {
         Object.defineProperty(this, "schema", {
             enumerable: true,
@@ -97,4 +113,4 @@ class Resource {
         return this.updateQuery(q);
     }
 }
-exports.Resource = Resource;
+exports.Lens = Lens;

package/script/library/lens/mod.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResource = exports.createLens = void 0;
+var lens_js_1 = require("./lens.js");
+Object.defineProperty(exports, "createLens", { enumerable: true, get: function () { return lens_js_1.createLens; } });
+Object.defineProperty(exports, "createResource", { enumerable: true, get: function () { return lens_js_1.createResource; } });