@ng-org/shex-orm 0.1.2

package/dist/schema-converter/util/annotateReadablePredicates.js

@@ -0,0 +1,148 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+// Split IRI by colon, slash and hash; drop empties
+const splitIriTokens = (iri) => iri.split(/[:/#]+/).filter(Boolean);
+// Keep dots and dashes (so 0.1 stays as 0.1) but sanitize everything else
+const sanitize = (s) => s.replace(/[^\w.\-]/g, "_");
+/**
+ * Annotate EachOf-level TripleConstraints with a collision-free readablePredicate.
+ * Rule: for any group that shares the same local token, rename all members using
+ * prefix-first `${prefix}_${local}` from right to left; fallback to composite.
+ */
+export default function annotateReadablePredicates(schema) {
+    const shapes = schema.shapes ?? [];
+    const annotateEachOf = (eachOf) => {
+        if (!eachOf ||
+            eachOf.type !== "EachOf" ||
+            !Array.isArray(eachOf.expressions))
+            return;
+        const tcs = eachOf.expressions.filter((e) => typeof e === "object" &&
+            e !== null &&
+            e.type === "TripleConstraint");
+        if (tcs.length > 0) {
+            // Group by local token (last segment of IRI) and set a base readablePredicate for all
+            const readableNameToPredicatesMap = new Map();
+            for (const tripleConstraint of tcs) {
+                // Use the name based on the IRI ending.
+                let readableName;
+                // Special case rdfs:type => @type
+                if (tripleConstraint.predicate ===
+                    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") {
+                    readableName = "@type";
+                }
+                else {
+                    const tokens = splitIriTokens(tripleConstraint.predicate);
+                    readableName = tokens.length
+                        ? tokens[tokens.length - 1]
+                        : tripleConstraint.predicate;
+                }
+                // default base name for non-colliders
+                tripleConstraint.readablePredicate = readableName;
+                const groupMembers = readableNameToPredicatesMap.get(readableName) ?? [];
+                groupMembers.push(tripleConstraint);
+                readableNameToPredicatesMap.set(readableName, groupMembers);
+            }
+            // Resolve each group (rename all in collisions)
+            for (const [, groupMembers] of readableNameToPredicatesMap) {
+                if (groupMembers.length <= 1)
+                    continue;
+                const used = new Set();
+                const local = splitIriTokens(groupMembers[0].predicate).slice(-1)[0] ??
+                    "";
+                for (const tc of groupMembers) {
+                    const tokens = splitIriTokens(tc.predicate);
+                    let localIdx = tokens.lastIndexOf(local);
+                    if (localIdx === -1)
+                        localIdx = Math.max(tokens.length - 1, 0);
+                    let prefixIdx = localIdx - 1;
+                    let assigned = false;
+                    while (prefixIdx >= 0) {
+                        const cand = `${sanitize(tokens[prefixIdx])}_${sanitize(tokens[localIdx])}`;
+                        if (!used.has(cand)) {
+                            tc.readablePredicate = cand;
+                            used.add(cand);
+                            assigned = true;
+                            break;
+                        }
+                        prefixIdx -= 1;
+                    }
+                    if (!assigned) {
+                        const iriNoProto = tc.predicate.replace(/^[a-z]+:\/\//i, "");
+                        const composite = sanitize(iriNoProto
+                            .split(/[:/#]+/)
+                            .slice(0, -1)
+                            .join("_") || "iri");
+                        let cand = `${composite}_${sanitize(tokens[localIdx] || local)}`;
+                        let n = 1;
+                        while (used.has(cand))
+                            cand = `${cand}_${n++}`;
+                        tc.readablePredicate = cand;
+                        used.add(cand);
+                    }
+                }
+            }
+            // Recurse into nested valueExpr shapes of each TC
+            for (const tc of tcs) {
+                const ve = tc.valueExpr;
+                if (ve && typeof ve === "object") {
+                    const t = ve.type;
+                    if (t === "Shape" && ve.expression)
+                        annotateEachOf(ve.expression);
+                    else if (t === "EachOf")
+                        annotateEachOf(ve);
+                    else if (t === "ShapeOr" &&
+                        Array.isArray(ve.shapeExprs)) {
+                        for (const sub of ve.shapeExprs)
+                            annotateFromExpr(sub);
+                    }
+                    else if (t === "ShapeAnd" &&
+                        Array.isArray(ve.shapeExprs)) {
+                        for (const sub of ve.shapeExprs)
+                            annotateFromExpr(sub);
+                    }
+                }
+            }
+        }
+        // Also recurse into any inline sub-EachOf/Shape expressions found directly in expressions
+        for (const ex of eachOf.expressions) {
+            if (ex && typeof ex === "object")
+                annotateFromExpr(ex);
+        }
+    };
+    const annotateFromExpr = (expr) => {
+        if (!expr || typeof expr !== "object")
+            return;
+        const t = expr.type;
+        if (t === "Shape" && expr.expression)
+            annotateEachOf(expr.expression);
+        else if (t === "EachOf")
+            annotateEachOf(expr);
+        else if (t === "ShapeOr" && Array.isArray(expr.shapeExprs)) {
+            for (const sub of expr.shapeExprs)
+                annotateFromExpr(sub);
+        }
+        else if (t === "ShapeAnd" &&
+            Array.isArray(expr.shapeExprs)) {
+            for (const sub of expr.shapeExprs)
+                annotateFromExpr(sub);
+        }
+        else if (t === "TripleConstraint") {
+            const ve = expr.valueExpr;
+            if (ve && typeof ve === "object")
+                annotateFromExpr(ve);
+        }
+    };
+    for (const s of shapes) {
+        const sd = s;
+        const shape = (sd.shapeExpr || sd);
+        if (shape?.expression)
+            annotateFromExpr(shape);
+    }
+}

package/dist/schema-converter/util/dedupeObjectTypeMembers.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectTypeMember } from "dts-dom";
+export declare function dedupeObjectTypeMembers(memberList: ObjectTypeMember[]): ObjectTypeMember[];
+//# sourceMappingURL=dedupeObjectTypeMembers.d.ts.map

package/dist/schema-converter/util/dedupeObjectTypeMembers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupeObjectTypeMembers.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/util/dedupeObjectTypeMembers.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,gBAAgB,EAAE,GAC7B,gBAAgB,EAAE,CAoCpB"}

package/dist/schema-converter/util/dedupeObjectTypeMembers.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+import * as dom from "dts-dom";
+export function dedupeObjectTypeMembers(memberList) {
+    const properties = {};
+    memberList.forEach((expression) => {
+        const propertyDeclaration = expression;
+        // Combine properties if they're duplicates
+        if (properties[propertyDeclaration.name]) {
+            const oldPropertyDeclaration = properties[propertyDeclaration.name];
+            const oldPropertyType = isLdSetType(oldPropertyDeclaration.type)
+                ? oldPropertyDeclaration.type.typeArguments[0]
+                : oldPropertyDeclaration.type;
+            const propertyType = isLdSetType(propertyDeclaration.type)
+                ? propertyDeclaration.type.typeArguments[0]
+                : propertyDeclaration.type;
+            const isOptional = propertyDeclaration.flags === dom.DeclarationFlags.Optional ||
+                oldPropertyDeclaration.flags === dom.DeclarationFlags.Optional;
+            properties[propertyDeclaration.name] = dom.create.property(propertyDeclaration.name, {
+                kind: "name",
+                name: "LdSet",
+                typeArguments: [dom.create.union([oldPropertyType, propertyType])],
+            }, isOptional ? dom.DeclarationFlags.Optional : dom.DeclarationFlags.None);
+            // Set JS Comment
+            properties[propertyDeclaration.name].jsDocComment =
+                oldPropertyDeclaration.jsDocComment && propertyDeclaration.jsDocComment
+                    ? `${oldPropertyDeclaration.jsDocComment} | ${propertyDeclaration.jsDocComment}`
+                    : oldPropertyDeclaration.jsDocComment ||
+                        propertyDeclaration.jsDocComment;
+        }
+        else {
+            properties[propertyDeclaration.name] = propertyDeclaration;
+        }
+    });
+    return Object.values(properties);
+}
+function isLdSetType(potentialLdSet) {
+    return (potentialLdSet.kind === "name" &&
+        potentialLdSet.name === "LdSet");
+}

package/dist/schema-converter/util/getRdfTypesForTripleConstraint.d.ts

@@ -0,0 +1,4 @@
+import type { ShexJTraverserTypes } from "@ldo/traverser-shexj";
+import type { InterfaceInstanceNode } from "@ldo/type-traverser";
+export declare function getRdfTypesForTripleConstraint(tripleConstraintNode: InterfaceInstanceNode<ShexJTraverserTypes, "TripleConstraint", ShexJTraverserTypes["TripleConstraint"]>): string[] | undefined[];
+//# sourceMappingURL=getRdfTypesForTripleConstraint.d.ts.map

package/dist/schema-converter/util/getRdfTypesForTripleConstraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRdfTypesForTripleConstraint.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/util/getRdfTypesForTripleConstraint.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACR,mBAAmB,EAEtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAwGjE,wBAAgB,8BAA8B,CAC1C,oBAAoB,EAAE,qBAAqB,CACvC,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,CAAC,kBAAkB,CAAC,CAC1C,GACF,MAAM,EAAE,GAAG,SAAS,EAAE,CA4BxB"}

package/dist/schema-converter/util/getRdfTypesForTripleConstraint.js

@@ -0,0 +1,98 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+function addRdfTypeFromTripleExpr(tripleExpr, rdfTypeSet) {
+    if (typeof tripleExpr === "object" &&
+        tripleExpr.type === "TripleConstraint" &&
+        tripleExpr.predicate ===
+            "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" &&
+        typeof tripleExpr.valueExpr === "object" &&
+        tripleExpr.valueExpr.type === "NodeConstraint" &&
+        tripleExpr.valueExpr.values) {
+        tripleExpr.valueExpr.values.forEach((val) => {
+            if (typeof val === "string")
+                rdfTypeSet.add(val);
+            // TODO handle other edge cases like IRIStem
+        });
+    }
+}
+function recursivelyGatherTypesFromShapeNodes(shapeNode, rdfTypeSet) {
+    const tripleExpr = shapeNode.instance.expression;
+    if (tripleExpr)
+        addRdfTypeFromTripleExpr(tripleExpr, rdfTypeSet);
+    shapeNode.parent("shapeExpr").forEach((parentShapeExpr) => {
+        parentShapeExpr
+            .parent("ShapeDecl", "shapeExpr")
+            .forEach((parentShapeDecl) => {
+            parentShapeDecl
+                .parent("shapeDeclRef")
+                .forEach((parentShapeDeclOrRef) => {
+                parentShapeDeclOrRef
+                    .parent("shapeExprOrRef")
+                    .forEach((parentShapeExprOrRef) => {
+                    parentShapeExprOrRef
+                        .parent("Shape", "extends")
+                        .forEach((parentShape) => {
+                        recursivelyGatherTypesFromShapeNodes(parentShape, rdfTypeSet);
+                        const childExpressionNode = parentShape.child("expression");
+                        if (!childExpressionNode)
+                            return;
+                        const childEachOf = childExpressionNode
+                            .child()
+                            .child();
+                        if (childEachOf.typeName === "EachOf") {
+                            recursivelyGatherTypesFromEachOfNodes(childEachOf, rdfTypeSet);
+                        }
+                    });
+                });
+            });
+        });
+    });
+}
+function recursivelyGatherTypesFromEachOfNodes(eachOfNode, rdfTypeSet) {
+    const tripleExprs = eachOfNode.instance.expressions;
+    tripleExprs.forEach((tripleExpr) => {
+        addRdfTypeFromTripleExpr(tripleExpr, rdfTypeSet);
+    });
+    eachOfNode.parent("tripleExpr").forEach((tripleExprNode) => {
+        const tripleExprOrRefNodes = tripleExprNode.parent("tripleExprOrRef");
+        tripleExprOrRefNodes.forEach((tripleExprOrRdfNode) => {
+            const parentEachOfs = tripleExprOrRdfNode.parent("EachOf", "expressions");
+            parentEachOfs.forEach((parentEachOf) => {
+                recursivelyGatherTypesFromEachOfNodes(parentEachOf, rdfTypeSet);
+            });
+            // Deal with shape extends
+            const parentShapes = tripleExprOrRdfNode.parent("Shape", "expression");
+            parentShapes.forEach((parentShape) => recursivelyGatherTypesFromShapeNodes(parentShape, rdfTypeSet));
+        });
+    });
+}
+export function getRdfTypesForTripleConstraint(tripleConstraintNode) {
+    // Check that there's a triple constraint that is a type at the
+    // same level if there is, use that as an rdfType
+    const rdfTypeSet = new Set();
+    tripleConstraintNode.parent("tripleExpr").forEach((tripleExprParents) => {
+        tripleExprParents
+            .parent("tripleExprOrRef")
+            .forEach((tripleExprOrRefParent) => {
+            tripleExprOrRefParent
+                .parent("EachOf", "expressions")
+                .forEach((eachOfParent) => {
+                recursivelyGatherTypesFromEachOfNodes(eachOfParent, rdfTypeSet);
+            });
+            tripleExprOrRefParent
+                .parent("Shape", "expression")
+                .forEach((shapeParent) => {
+                recursivelyGatherTypesFromShapeNodes(shapeParent, rdfTypeSet);
+            });
+        });
+    });
+    const rdfTypes = rdfTypeSet.size > 0 ? Array.from(rdfTypeSet) : [undefined];
+    return rdfTypes;
+}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+export interface ShapeType<T extends BaseType> {
+    schema: Schema;
+    shape: string;
+}
+export interface BaseType extends Record<string, any> {
+    "@id": string;
+}
+export type Schema = {
+    [id: string]: Shape;
+};
+export interface Shape {
+    iri: string;
+    predicates: Predicate[];
+}
+export type DataType = {
+    /** The required literal value(s), if type is `literal`. Others are allowed, if `extra` is true. */
+    literals?: number[] | string[] | boolean;
+    /** If `valType` is `"shape"`, the nested shape or its reference. Use reference for serialization. */
+    shape?: string | Shape;
+    /** The type of object value for a triple constraint. */
+    valType: "number" | "string" | "boolean" | "iri" | "literal" | "shape";
+};
+export interface Predicate {
+    /** Allowed type of object. If more than one is present, either of them is allowed. */
+    dataTypes: DataType[];
+    /** The RDF predicate URI. */
+    iri: string;
+    /** The alias of the `predicateUri` when serialized to a JSON object. */
+    readablePredicate: string;
+    /** Maximum allowed number of values. `-1` means infinite. */
+    maxCardinality: number;
+    /** Minimum required number of values */
+    minCardinality: number;
+    /** If other (additional) values are permitted. Useful for literals. */
+    extra?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,KAAK;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,QAAQ,GAAG;IACnB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IACzC,qGAAqG;IACrG,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC;CAC1E,CAAC;AAEF,MAAM,WAAW,SAAS;IACtB,sFAAsF;IACtF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/dist/types.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+export {};

package/dist/util/forAllShapes.d.ts

@@ -0,0 +1,2 @@
+export declare function forAllShapes(shapePath: string, callback: (filename: string, shape: string) => Promise<void>): Promise<void>;
+//# sourceMappingURL=forAllShapes.d.ts.map

package/dist/util/forAllShapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forAllShapes.d.ts","sourceRoot":"","sources":["../../src/util/forAllShapes.ts"],"names":[],"mappings":"AAYA,wBAAsB,YAAY,CAC9B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAC7D,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/dist/util/forAllShapes.js

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Jackson Morgan
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+import fs from "fs";
+import path from "node:path";
+export async function forAllShapes(shapePath, callback) {
+    const shapeDir = await fs.promises.readdir(shapePath, {
+        withFileTypes: true,
+    });
+    // Filter out non-shex documents
+    const shexFiles = shapeDir.filter((file) => file.isFile() && file.name.endsWith(".shex"));
+    const shexPromise = Promise.all(shexFiles.map(async (file) => {
+        const fileName = path.parse(file.name).name;
+        // Get the content of each document
+        const shexC = await fs.promises.readFile(path.join(shapePath, file.name), "utf8");
+        await callback(fileName, shexC);
+    }));
+    // Note: SHACL conversion omitted here.
+    await Promise.all([shexPromise]);
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@ng-org/shex-orm",
+  "version": "0.1.2",
+  "description": "",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "rdf-orm": "./src/cli.ts"
+  },
+  "scripts": {
+    "build": "pnpm run build:ts",
+    "build:ts": "rm -rf dist && tsc && pnpm run update-permission && pnpm copy-templates",
+    "copy-templates": "mkdir -p dist && rsync -qav --include=\"*/\" --include=\"*.ejs\" --exclude=\"*\" src/ dist/",
+    "update-permission": "chmod +x ./dist/cli.js",
+    "test": "vitest run",
+    "prepublishOnly": " npm run build",
+    "lint": "eslint src/** --fix --no-error-on-unmatched-pattern",
+    "test:init": "rm -rf ./example-init && cp -R ./example-init-placeholder ./example-init && cd ./example-init && ../dist/index.js init",
+    "test:create": "rm -rf ./example-create && ./dist/index.js create ./example-create"
+  },
+  "authors": [
+    "Laurin Weger",
+    "Jackson Morgan"
+  ],
+  "license": "MIT/Apache-2.0",
+  "devDependencies": {
+    "@types/child-process-promise": "^2.2.2",
+    "@types/ejs": "^3.1.1",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jsonld": "^1.5.15",
+    "@types/prompts": "^2.4.9",
+    "@types/shexj": "^2.1.4",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "@jeswr/shacl2shex": "^1.1.0",
+    "@ldo/traverser-shexj": "1.0.0-alpha.28",
+    "@ldo/type-traverser": "1.0.0-alpha.28",
+    "@shexjs/parser": "^1.0.0-alpha.24",
+    "child-process-promise": "^2.2.1",
+    "commander": "^14.0.1",
+    "dts-dom": "~3.6.0",
+    "ejs": "^3.1.8",
+    "fs-extra": "^10.1.0",
+    "jsonld2graphobject": "^0.0.5",
+    "loading-cli": "^1.1.0",
+    "prettier": "^3.0.3",
+    "prompts": "^2.4.2",
+    "rdf-dereference-store": "^1.4.0",
+    "rdf-namespaces": "^1.13.1",
+    "ts-morph": "^24.0.0",
+    "type-fest": "^2.19.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "bin": {
+      "rdf-orm": "./dist/cli.js"
+    },
+    "access": "public",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  }
+}