@rdfx/fs 0.0.26 → 0.0.28
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/RdfDirectoryGraphStore.d.ts +27 -0
- package/dist/RdfDirectoryGraphStore.js +180 -0
- package/dist/RdfFile.d.ts +1 -1
- package/dist/RdfFile.js +1 -2
- package/dist/RdfFileGraphStore.d.ts +32 -0
- package/dist/RdfFileGraphStore.js +107 -0
- package/dist/index.d.ts +2 -0
- package/dist/index.js +2 -0
- package/package.json +12 -8
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import type { DatasetCore, Stream } from "@rdfjs/types";
|
|
2
|
+
import { GraphIdentifier, type GraphStore } from "@rdfx/graph-store";
|
|
3
|
+
import { Either, Maybe } from "purify-ts";
|
|
4
|
+
import { type Logger } from "ts-log";
|
|
5
|
+
/**
|
|
6
|
+
* A GraphStore implementation backed by files in a directory.
|
|
7
|
+
*/
|
|
8
|
+
export declare class RdfDirectoryGraphStore implements GraphStore {
|
|
9
|
+
readonly directoryPath: string;
|
|
10
|
+
private readonly logger;
|
|
11
|
+
constructor(directoryPath: string, options?: {
|
|
12
|
+
logger?: Logger;
|
|
13
|
+
});
|
|
14
|
+
clear(): Promise<Either<Error, object>>;
|
|
15
|
+
delete(identifier: GraphIdentifier): Promise<Either<Error, object>>;
|
|
16
|
+
get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
|
|
17
|
+
head(identifier: GraphIdentifier): Promise<Either<Error, boolean>>;
|
|
18
|
+
identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
|
|
19
|
+
isEmpty(): Promise<Either<Error, boolean>>;
|
|
20
|
+
post(quads: Stream): Promise<Either<Error, object>>;
|
|
21
|
+
put(quads: Stream): Promise<Either<Error, object>>;
|
|
22
|
+
unionDataset(): Promise<Either<Error, DatasetCore>>;
|
|
23
|
+
private files;
|
|
24
|
+
private graphFilePath;
|
|
25
|
+
private postOrPut;
|
|
26
|
+
}
|
|
27
|
+
//# sourceMappingURL=RdfDirectoryGraphStore.d.ts.map
|
|
@@ -0,0 +1,180 @@
|
|
|
1
|
+
import { Buffer } from "node:buffer";
|
|
2
|
+
import fs from "node:fs";
|
|
3
|
+
import path from "node:path";
|
|
4
|
+
import datasetFactory from "@rdfjs/dataset";
|
|
5
|
+
import dataFactory from "@rdfx/data-factory";
|
|
6
|
+
import { GraphIdentifier } from "@rdfx/graph-store";
|
|
7
|
+
import parsers from "@rdfx/parsers";
|
|
8
|
+
import { NTriplesTerm } from "@rdfx/string";
|
|
9
|
+
import { Either, EitherAsync, Left, Maybe } from "purify-ts";
|
|
10
|
+
import { dummyLogger } from "ts-log";
|
|
11
|
+
import { RdfDirectory } from "./RdfDirectory.js";
|
|
12
|
+
import { stat } from "./stat.js";
|
|
13
|
+
/**
|
|
14
|
+
* A GraphStore implementation backed by files in a directory.
|
|
15
|
+
*/
|
|
16
|
+
export class RdfDirectoryGraphStore {
|
|
17
|
+
directoryPath;
|
|
18
|
+
logger;
|
|
19
|
+
constructor(directoryPath, options) {
|
|
20
|
+
this.directoryPath = directoryPath;
|
|
21
|
+
this.logger = options?.logger ?? dummyLogger;
|
|
22
|
+
}
|
|
23
|
+
async clear() {
|
|
24
|
+
return EitherAsync(async () => {
|
|
25
|
+
await fs.promises.rm(this.directoryPath, {
|
|
26
|
+
force: true,
|
|
27
|
+
recursive: true,
|
|
28
|
+
});
|
|
29
|
+
return {};
|
|
30
|
+
});
|
|
31
|
+
}
|
|
32
|
+
async delete(identifier) {
|
|
33
|
+
return EitherAsync(async () => {
|
|
34
|
+
try {
|
|
35
|
+
await fs.promises.rm(this.graphFilePath(identifier));
|
|
36
|
+
}
|
|
37
|
+
catch (error) {
|
|
38
|
+
if (errorCode(error) !== "ENOENT") {
|
|
39
|
+
throw error;
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
return {};
|
|
43
|
+
});
|
|
44
|
+
}
|
|
45
|
+
async get(identifier) {
|
|
46
|
+
return EitherAsync(async ({ liftEither }) => {
|
|
47
|
+
if (!(await liftEither(await this.head(identifier)))) {
|
|
48
|
+
return Maybe.empty();
|
|
49
|
+
}
|
|
50
|
+
let stream = parser.import(fs.createReadStream(this.graphFilePath(identifier)));
|
|
51
|
+
if (identifier.termType !== "DefaultGraph") {
|
|
52
|
+
stream = stream.map((quad) => dataFactory.quad(quad.subject, quad.predicate, quad.object, identifier));
|
|
53
|
+
}
|
|
54
|
+
return Maybe.of(stream);
|
|
55
|
+
});
|
|
56
|
+
}
|
|
57
|
+
async head(identifier) {
|
|
58
|
+
return (await EitherAsync(async ({ liftEither }) => (await liftEither(await stat(this.graphFilePath(identifier)))).isFile())).chainLeft((error) => errorCode(error) === "ENOENT"
|
|
59
|
+
? Either.of(false)
|
|
60
|
+
: Left(error));
|
|
61
|
+
}
|
|
62
|
+
async identifiers() {
|
|
63
|
+
return EitherAsync(async () => {
|
|
64
|
+
const identifiers = [];
|
|
65
|
+
for await (const [_, identifier] of this.files()) {
|
|
66
|
+
identifiers.push(identifier);
|
|
67
|
+
}
|
|
68
|
+
return identifiers;
|
|
69
|
+
});
|
|
70
|
+
}
|
|
71
|
+
async isEmpty() {
|
|
72
|
+
return EitherAsync(async () => {
|
|
73
|
+
try {
|
|
74
|
+
return (await fs.promises.readdir(this.directoryPath)).length === 0;
|
|
75
|
+
}
|
|
76
|
+
catch (error) {
|
|
77
|
+
if (errorCode(error) === "ENOENT") {
|
|
78
|
+
return true;
|
|
79
|
+
}
|
|
80
|
+
throw error;
|
|
81
|
+
}
|
|
82
|
+
});
|
|
83
|
+
}
|
|
84
|
+
async post(quads) {
|
|
85
|
+
return this.postOrPut("post", quads);
|
|
86
|
+
}
|
|
87
|
+
async put(quads) {
|
|
88
|
+
return this.postOrPut("put", quads);
|
|
89
|
+
}
|
|
90
|
+
async unionDataset() {
|
|
91
|
+
return EitherAsync(async ({ liftEither }) => {
|
|
92
|
+
this.logger.debug("parsing dataset from %s", this.directoryPath);
|
|
93
|
+
const unionDataset = datasetFactory.dataset();
|
|
94
|
+
for await (const [file, graphIdentifier] of this.files()) {
|
|
95
|
+
const fileDataset = datasetFactory.dataset();
|
|
96
|
+
await liftEither(await file.parseInto(fileDataset));
|
|
97
|
+
this.logger.debug("parsed %d quads from %s", fileDataset.size, file.path);
|
|
98
|
+
for (const quad of fileDataset) {
|
|
99
|
+
if (quad.graph.termType !== "DefaultGraph") {
|
|
100
|
+
throw new Error(`${file.path} quad is not in default graph`);
|
|
101
|
+
}
|
|
102
|
+
unionDataset.add(dataFactory.quad(quad.subject, quad.predicate, quad.object, graphIdentifier));
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
this.logger.debug("parsed %d quads from %s", unionDataset.size, this.directoryPath);
|
|
106
|
+
return unionDataset;
|
|
107
|
+
});
|
|
108
|
+
}
|
|
109
|
+
async *files() {
|
|
110
|
+
for await (const file of new RdfDirectory(this.directoryPath, {
|
|
111
|
+
logger: this.logger,
|
|
112
|
+
}).files()) {
|
|
113
|
+
const fileStem = path.basename(file.path, path.extname(file.path));
|
|
114
|
+
if (!/^[-A-Za-z0-9\-_]+$/.test(fileStem)) {
|
|
115
|
+
this.logger.debug("ignoring RDF file %s with non-Base64url-encoded file name", file.path);
|
|
116
|
+
continue;
|
|
117
|
+
}
|
|
118
|
+
const graphIdentifier = fileStem === "default"
|
|
119
|
+
? dataFactory.defaultGraph()
|
|
120
|
+
: dataFactory.namedNode(Buffer.from(fileStem, "base64url").toString());
|
|
121
|
+
this.logger.debug("RDF file %s graph identifier: %s", file.path, graphIdentifier);
|
|
122
|
+
yield [file, graphIdentifier];
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
graphFilePath(identifier) {
|
|
126
|
+
const identifierString = typeof identifier === "object"
|
|
127
|
+
? GraphIdentifier.stringify(identifier)
|
|
128
|
+
: identifier;
|
|
129
|
+
return path.join(this.directoryPath, identifierString.length === 0
|
|
130
|
+
? "default.nq"
|
|
131
|
+
: `${Buffer.from(identifierString).toString("base64url")}.nq`);
|
|
132
|
+
}
|
|
133
|
+
async postOrPut(method, quads) {
|
|
134
|
+
return EitherAsync(async ({ liftEither }) => {
|
|
135
|
+
const ntriplesByGraphIdentifier = new Map();
|
|
136
|
+
await liftEither(await new Promise((resolve) => {
|
|
137
|
+
quads.on("data", (quad) => {
|
|
138
|
+
const graphIdentifierString = GraphIdentifier.stringify(GraphIdentifier.fromQuadGraph(quad.graph).unsafeCoerce());
|
|
139
|
+
let ntriples = ntriplesByGraphIdentifier.get(graphIdentifierString);
|
|
140
|
+
if (!ntriples) {
|
|
141
|
+
ntriples = [];
|
|
142
|
+
ntriplesByGraphIdentifier.set(graphIdentifierString, ntriples);
|
|
143
|
+
}
|
|
144
|
+
ntriples.push(`${NTriplesTerm.stringify(quad.subject)} ${NTriplesTerm.stringify(quad.predicate)} ${NTriplesTerm.stringify(quad.object)} .`);
|
|
145
|
+
});
|
|
146
|
+
quads.on("end", () => resolve(Either.of(undefined)));
|
|
147
|
+
quads.on("error", (error) => resolve(Left(error)));
|
|
148
|
+
}));
|
|
149
|
+
for (let [graphIdentifierString, ntriples,] of ntriplesByGraphIdentifier.entries()) {
|
|
150
|
+
await fs.promises.mkdir(this.directoryPath, {
|
|
151
|
+
recursive: true,
|
|
152
|
+
});
|
|
153
|
+
const graphFilePath = this.graphFilePath(graphIdentifierString);
|
|
154
|
+
if (method === "post") {
|
|
155
|
+
try {
|
|
156
|
+
ntriples = (await fs.promises.readFile(graphFilePath))
|
|
157
|
+
.toString("utf-8")
|
|
158
|
+
.split("\n")
|
|
159
|
+
.concat(ntriples);
|
|
160
|
+
}
|
|
161
|
+
catch (error) {
|
|
162
|
+
if (errorCode(error) !== "ENOENT") {
|
|
163
|
+
throw error;
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
}
|
|
167
|
+
ntriples.sort();
|
|
168
|
+
await fs.promises.writeFile(graphFilePath, ntriples.join("\n"), "utf-8");
|
|
169
|
+
}
|
|
170
|
+
return {};
|
|
171
|
+
});
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
function errorCode(error) {
|
|
175
|
+
return error instanceof Error && "code" in error
|
|
176
|
+
? error.code
|
|
177
|
+
: undefined;
|
|
178
|
+
}
|
|
179
|
+
const parser = parsers({ dataFactory }).get("application/n-quads");
|
|
180
|
+
//# sourceMappingURL=RdfDirectoryGraphStore.js.map
|
package/dist/RdfFile.d.ts
CHANGED
|
@@ -17,7 +17,7 @@ export declare class RdfFile extends AbstractRdfFileSystemEntry {
|
|
|
17
17
|
parseInto(dataset: DatasetCore, options?: {
|
|
18
18
|
prefixMap?: PrefixMap;
|
|
19
19
|
}): Promise<Either<Error, DatasetCore>>;
|
|
20
|
-
serialize(quads:
|
|
20
|
+
serialize(quads: Stream, options?: Parameters<typeof serializers>[0]): Promise<Either<Error, void>>;
|
|
21
21
|
}
|
|
22
22
|
export declare namespace RdfFile {
|
|
23
23
|
const COMPRESSION_METHODS: readonly ["application/gzip", "application/x-brotli", "application/x-bzip2"];
|
package/dist/RdfFile.js
CHANGED
|
@@ -1,6 +1,5 @@
|
|
|
1
1
|
import fs from "node:fs";
|
|
2
2
|
import * as path from "node:path";
|
|
3
|
-
import { Readable } from "node:stream";
|
|
4
3
|
import { pipeline } from "node:stream/promises";
|
|
5
4
|
import zlib from "node:zlib";
|
|
6
5
|
import dataFactory from "@rdfx/data-factory";
|
|
@@ -106,7 +105,7 @@ export class RdfFile extends AbstractRdfFileSystemEntry {
|
|
|
106
105
|
}
|
|
107
106
|
async serialize(quads, options) {
|
|
108
107
|
return EitherAsync(async () => {
|
|
109
|
-
const rdfStream = serializers(options).import(this.format.rdfFormat,
|
|
108
|
+
const rdfStream = serializers(options).import(this.format.rdfFormat, quads);
|
|
110
109
|
if (rdfStream === null) {
|
|
111
110
|
throw new RangeError(`unsupported RDF serialization format: ${this.format.rdfFormat}`);
|
|
112
111
|
}
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
|
|
2
|
+
import type { DatasetCore, Stream } from "@rdfjs/types";
|
|
3
|
+
import { type GraphIdentifier, type GraphStore } from "@rdfx/graph-store";
|
|
4
|
+
import { Either, type Maybe } from "purify-ts";
|
|
5
|
+
import { type Logger } from "ts-log";
|
|
6
|
+
import { RdfFile } from "./RdfFile.js";
|
|
7
|
+
/**
|
|
8
|
+
* A GraphStore implementation backed by a single RdfFile.
|
|
9
|
+
*/
|
|
10
|
+
export declare class RdfFileGraphStore implements GraphStore {
|
|
11
|
+
readonly filePath: string;
|
|
12
|
+
private readonly file;
|
|
13
|
+
private readonly logger;
|
|
14
|
+
private readonly prefixMap?;
|
|
15
|
+
constructor(filePath: string, options?: {
|
|
16
|
+
format?: RdfFile.Format;
|
|
17
|
+
logger?: Logger;
|
|
18
|
+
prefixMap?: PrefixMap;
|
|
19
|
+
});
|
|
20
|
+
clear(): Promise<Either<Error, object>>;
|
|
21
|
+
delete(identifier: GraphIdentifier): Promise<Either<Error, object>>;
|
|
22
|
+
get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
|
|
23
|
+
head(identifier: GraphIdentifier): Promise<Either<Error, boolean>>;
|
|
24
|
+
identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
|
|
25
|
+
isEmpty(): Promise<Either<Error, boolean>>;
|
|
26
|
+
post(quads: Stream): Promise<Either<Error, object>>;
|
|
27
|
+
put(quads: Stream): Promise<Either<Error, object>>;
|
|
28
|
+
unionDataset(): Promise<Either<Error, DatasetCore>>;
|
|
29
|
+
private mutate;
|
|
30
|
+
private unionDatasetGraphStore;
|
|
31
|
+
}
|
|
32
|
+
//# sourceMappingURL=RdfFileGraphStore.d.ts.map
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
import fs from "node:fs/promises";
|
|
2
|
+
import path from "node:path";
|
|
3
|
+
import datasetFactory from "@rdfjs/dataset";
|
|
4
|
+
import { RdfjsDatasetGraphStore, } from "@rdfx/graph-store";
|
|
5
|
+
import intoStream from "into-stream";
|
|
6
|
+
import { Either, EitherAsync, Left } from "purify-ts";
|
|
7
|
+
import { dummyLogger } from "ts-log";
|
|
8
|
+
import { RdfFile } from "./RdfFile.js";
|
|
9
|
+
/**
|
|
10
|
+
* A GraphStore implementation backed by a single RdfFile.
|
|
11
|
+
*/
|
|
12
|
+
export class RdfFileGraphStore {
|
|
13
|
+
filePath;
|
|
14
|
+
file;
|
|
15
|
+
logger;
|
|
16
|
+
prefixMap;
|
|
17
|
+
constructor(filePath, options) {
|
|
18
|
+
this.filePath = filePath;
|
|
19
|
+
this.logger = options?.logger ?? dummyLogger;
|
|
20
|
+
this.file = options?.format
|
|
21
|
+
? new RdfFile(this.filePath, { format: options.format })
|
|
22
|
+
: RdfFile.fromPath(this.filePath, {
|
|
23
|
+
logger: this.logger,
|
|
24
|
+
}).unsafeCoerce();
|
|
25
|
+
this.prefixMap = options?.prefixMap;
|
|
26
|
+
}
|
|
27
|
+
async clear() {
|
|
28
|
+
return EitherAsync(async () => {
|
|
29
|
+
try {
|
|
30
|
+
await fs.unlink(this.filePath);
|
|
31
|
+
}
|
|
32
|
+
catch (error) {
|
|
33
|
+
if (errorCode(error) !== "ENOENT") {
|
|
34
|
+
throw error;
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
return {};
|
|
38
|
+
});
|
|
39
|
+
}
|
|
40
|
+
async delete(identifier) {
|
|
41
|
+
return this.mutate((unionDatasetGraphStore) => unionDatasetGraphStore.delete(identifier));
|
|
42
|
+
}
|
|
43
|
+
async get(identifier) {
|
|
44
|
+
return EitherAsync(async ({ liftEither }) => await liftEither(await (await liftEither(await this.unionDatasetGraphStore())).get(identifier)));
|
|
45
|
+
}
|
|
46
|
+
async head(identifier) {
|
|
47
|
+
return EitherAsync(async ({ liftEither }) => await liftEither(await (await liftEither(await this.unionDatasetGraphStore())).head(identifier)));
|
|
48
|
+
}
|
|
49
|
+
async identifiers() {
|
|
50
|
+
return EitherAsync(async ({ liftEither }) => await liftEither(await (await liftEither(await this.unionDatasetGraphStore())).identifiers()));
|
|
51
|
+
}
|
|
52
|
+
async isEmpty() {
|
|
53
|
+
return EitherAsync(async ({ liftEither }) => await liftEither(await (await liftEither(await this.unionDatasetGraphStore())).isEmpty()));
|
|
54
|
+
}
|
|
55
|
+
async post(quads) {
|
|
56
|
+
return this.mutate((unionDatasetGraphStore) => unionDatasetGraphStore.post(quads));
|
|
57
|
+
}
|
|
58
|
+
async put(quads) {
|
|
59
|
+
return this.mutate((unionDatasetGraphStore) => unionDatasetGraphStore.put(quads));
|
|
60
|
+
}
|
|
61
|
+
async unionDataset() {
|
|
62
|
+
return (await EitherAsync(async ({ liftEither }) => {
|
|
63
|
+
this.logger.debug("parsing dataset from %s", this.filePath);
|
|
64
|
+
const dataset = await liftEither(await this.file.parseInto(datasetFactory.dataset()));
|
|
65
|
+
this.logger.debug("parsed %d quads from %d", dataset.size, this.filePath);
|
|
66
|
+
return dataset;
|
|
67
|
+
})).chainLeft((error) => {
|
|
68
|
+
if (errorCode(error) === "ENOENT") {
|
|
69
|
+
return Either.of(datasetFactory.dataset());
|
|
70
|
+
}
|
|
71
|
+
else {
|
|
72
|
+
return Left(error);
|
|
73
|
+
}
|
|
74
|
+
});
|
|
75
|
+
}
|
|
76
|
+
async mutate(mutator) {
|
|
77
|
+
return EitherAsync(async ({ liftEither }) => {
|
|
78
|
+
const unionDataset = await liftEither(await this.unionDataset());
|
|
79
|
+
const return_ = await liftEither(await mutator(new RdfjsDatasetGraphStore(unionDataset)));
|
|
80
|
+
if (unionDataset.size === 0) {
|
|
81
|
+
try {
|
|
82
|
+
await fs.unlink(this.filePath);
|
|
83
|
+
}
|
|
84
|
+
catch (error) {
|
|
85
|
+
if (errorCode(error) !== "ENOENT") {
|
|
86
|
+
throw error;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
return return_;
|
|
90
|
+
}
|
|
91
|
+
await fs.mkdir(path.dirname(this.filePath), { recursive: true });
|
|
92
|
+
await liftEither(await this.file.serialize(intoStream.object(unionDataset), {
|
|
93
|
+
prefixes: this.prefixMap,
|
|
94
|
+
}));
|
|
95
|
+
return return_;
|
|
96
|
+
});
|
|
97
|
+
}
|
|
98
|
+
async unionDatasetGraphStore() {
|
|
99
|
+
return (await this.unionDataset()).map((dataset) => new RdfjsDatasetGraphStore(dataset));
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
function errorCode(error) {
|
|
103
|
+
return error instanceof Error && "code" in error
|
|
104
|
+
? error.code
|
|
105
|
+
: undefined;
|
|
106
|
+
}
|
|
107
|
+
//# sourceMappingURL=RdfFileGraphStore.js.map
|
package/dist/index.d.ts
CHANGED
package/dist/index.js
CHANGED
package/package.json
CHANGED
|
@@ -1,19 +1,23 @@
|
|
|
1
1
|
{
|
|
2
2
|
"dependencies": {
|
|
3
|
-
"@rdfx/data-factory": "0.0.
|
|
4
|
-
"@rdfx/
|
|
5
|
-
"@rdfx/
|
|
3
|
+
"@rdfx/data-factory": "0.0.28",
|
|
4
|
+
"@rdfx/graph-store": "0.0.28",
|
|
5
|
+
"@rdfx/parsers": "0.0.28",
|
|
6
|
+
"@rdfx/serializers": "0.0.28",
|
|
7
|
+
"@rdfx/string": "0.0.28",
|
|
8
|
+
"@rdfjs/dataset": "~2.0.2",
|
|
9
|
+
"@rdfjs/prefix-map": "~0.1.2",
|
|
6
10
|
"@rdfjs/types": "~2.0.1",
|
|
11
|
+
"@types/rdfjs__dataset": "~2.0.7",
|
|
12
|
+
"@types/rdfjs__prefix-map": "~0.1.5",
|
|
7
13
|
"@types/unbzip2-stream": "~1.4.3",
|
|
14
|
+
"into-stream": "~9.1.0",
|
|
8
15
|
"mime": "~4.1.0",
|
|
9
16
|
"purify-ts": "~2.1.4",
|
|
10
17
|
"ts-log": "~3.0.2",
|
|
11
18
|
"unbzip2-stream": "~1.4.3"
|
|
12
19
|
},
|
|
13
|
-
"devDependencies": {
|
|
14
|
-
"@rdfjs/dataset": "~2.0.2",
|
|
15
|
-
"@types/rdfjs__dataset": "~2.0.7"
|
|
16
|
-
},
|
|
20
|
+
"devDependencies": {},
|
|
17
21
|
"files": [
|
|
18
22
|
"LICENSE",
|
|
19
23
|
"dist/*.d.ts",
|
|
@@ -37,5 +41,5 @@
|
|
|
37
41
|
},
|
|
38
42
|
"type": "module",
|
|
39
43
|
"types": "./dist/index.d.ts",
|
|
40
|
-
"version": "0.0.
|
|
44
|
+
"version": "0.0.28"
|
|
41
45
|
}
|