@larsgw/formica 0.7.3 → 0.8.0

package/lib/bin/generate-linked-data.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path = __importStar(require("path"));
+var util = __importStar(require("util"));
+var jsonld = __importStar(require("jsonld"));
+var N3 = __importStar(require("n3"));
+var index_1 = require("../index");
+var resource_1 = require("../resources/resource");
+var csv_1 = require("../csv");
+var SHEETS = ['catalog', 'authors', 'places', 'publishers', 'taxa'];
+var PREFIX = 'https://purl.org/identification-resources/';
+var HANDLE_PREFIX = 'https://hdl.handle.net/';
+var SCOPES = {
+    // animal life stage
+    'adults': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
+    'pupae': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/pupa'],
+    'juveniles': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/juvenile'],
+    'subimagos': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/juvenile'],
+    'larvae': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'larvae (instar V)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'larvae (instar IV)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'larvae (instar III)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'larvae (instar I)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'nymphs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'nypmhs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'nymphs (instar V)': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/larva'],
+    'eggs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/embryo'],
+    // plant life stage
+    'flowering plants': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
+    'fruiting plants': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
+    'without sporangia': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/juvenile'],
+    'with sporangia': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
+    'teleomorphs': ['dwciri:lifeStage', 'http://rs.gbif.org/vocabulary/gbif/life_stage/adult'],
+    // sex
+    'females': ['dwciri:sex', 'http://rs.gbif.org/vocabulary/gbif/sex/female'],
+    'males': ['dwciri:sex', 'http://rs.gbif.org/vocabulary/gbif/sex/male'],
+    // caste
+    'queens': ['dwc:caste', 'queen'],
+    'workers': ['dwc:caste', 'worker'],
+    'soldiers': ['dwc:caste', 'soldier'],
+    'alates': ['dwc:caste', 'alate'],
+    'alatae': ['dwc:caste', 'alate'],
+    'apterae': ['dwc:caste', 'aptera'],
+    'viviparae': ['dwc:caste', 'vivipara'],
+    // evidence
+    'nests': ['ac:subjectPartLiteral', 'nest'],
+    'galls': ['ac:subjectPartLiteral', 'gall'],
+    'puparia': ['ac:subjectPartLiteral', 'puparium'],
+    'eggcases': ['ac:subjectPart', 'http://rs.tdwg.org/acpart/values/p0031'],
+    'bones': ['ac:subjectPartLiteral', 'skeleton'],
+    'bones (skulls)': ['ac:subjectPart', 'http://rs.tdwg.org/acpart/values/p0027'],
+    'bones (upper jaws)': ['ac:subjectPart', 'http://rs.tdwg.org/acpart/values/p0028'],
+    'bones (lower jaws)': ['ac:subjectPart', 'http://rs.tdwg.org/acpart/values/p0029'],
+};
+var PREFIXES = {
+    'ac': 'http://rs.tdwg.org/ac/terms/',
+    'bibo': 'http://purl.org/ontology/bibo/',
+    'dcterms': 'http://purl.org/dc/terms/',
+    'dwc': 'http://rs.tdwg.org/dwc/terms/',
+    'dwciri': 'http://rs.tdwg.org/dwc/iri/',
+    'foaf': 'http://xmlns.com/foaf/0.1/',
+    'owl': 'http://www.w3.org/2002/07/owl#',
+    'schema': 'https://schema.org/',
+};
+var DWC_FIELDS = {
+    scientificName: 'dwc:scientificName',
+    scientificNameAuthorship: 'dwc:scientificNameAuthorship',
+    genericName: 'dwc:genericName',
+    infragenericEpithet: 'dwc:infragenericEpithet',
+    specificEpithet: 'dwc:specificEpithet',
+    infraspecificEpithet: 'dwc:infraspecificEpithet',
+    taxonRank: 'dwc:taxonRank',
+    taxonRemarks: 'dwc:taxonRemarks',
+    taxonomicStatus: 'dwc:taxonomicStatus',
+    verbatimIdentification: 'dwc:verbatimIdentification',
+};
+var GBIF_RANKS = ['kingdom', 'phylum', 'class', 'order', 'family', 'genus', 'species', 'subspecies'];
+function getCoveringTaxon(taxa) {
+    if (taxa.length === 1 && !taxa[0].has('gbif')) {
+        return "".concat(PREFIX, "taxon/").concat(taxa[0].get('id'));
+    }
+    function getAncestors(taxon) {
+        var _a;
+        var parents = ((_a = taxon.get('parent_taxa')) !== null && _a !== void 0 ? _a : []).slice(0);
+        if (taxon.has('gbif')) {
+            parents.push(taxon.get('gbif'));
+        }
+        return parents;
+    }
+    var ancestors = getAncestors(taxa[0]);
+    for (var _i = 0, _a = taxa.slice(1); _i < _a.length; _i++) {
+        var taxon = _a[_i];
+        var otherAncestors = getAncestors(taxon);
+        for (var i = 0; i < ancestors.length; i++) {
+            if (ancestors[i] !== otherAncestors[i]) {
+                ancestors.splice(i);
+            }
+        }
+    }
+    return ancestors.length ? makeGbifUri(ancestors[ancestors.length - 1])['@id'] : null;
+}
+function mapEntities(names, entities) {
+    var result = [];
+    var _loop_1 = function (name_1) {
+        var entity = entities.find(function (entity) {
+            var values = entity.get('name');
+            return Array.isArray(values) ? values.includes(name_1) : values === name_1;
+        });
+        if (!entity) {
+            console.error('Unmapped entity:', name_1);
+            return "continue";
+        }
+        result.push(entity);
+    };
+    for (var _i = 0, names_1 = names; _i < names_1.length; _i++) {
+        var name_1 = names_1[_i];
+        _loop_1(name_1);
+    }
+    return result;
+}
+function makeWikidataUri(qid) {
+    return { '@id': "http://www.wikidata.org/entity/".concat(qid) };
+}
+function makeGbifUri(id) {
+    return { '@id': "https://gbif.org/species/".concat(id) };
+}
+function makeWorkUri(id) {
+    return { '@id': "".concat(PREFIX, "catalog/").concat(id) };
+}
+function makeScientificNameUri(id) {
+    var resource = id.split(':').slice(0, -1).join(':');
+    return { '@id': "".concat(PREFIX, "resource/").concat(resource, "#").concat(id) };
+}
+function makeLinkedDataForAuthor(author) {
+    var node = {
+        '@id': "".concat(PREFIX, "author/").concat(author.get('id')),
+        '@type': 'foaf:Person',
+        'foaf:name': author.get('display_name')
+    };
+    if (author.has('qid')) {
+        node['owl:sameAs'] = makeWikidataUri(author.get('qid'));
+    }
+    return node;
+}
+function makeLinkedDataForPlace(place) {
+    var node = {
+        '@id': "".concat(PREFIX, "place/").concat(place.get('id')),
+        '@type': 'dcterms:Location',
+        'dcterms:title': place.get('display_name'),
+    };
+    if (place.has('qid')) {
+        node['owl:sameAs'] = makeWikidataUri(place.get('qid'));
+    }
+    return node;
+}
+function makeLinkedDataForPublisher(publisher) {
+    var node = {
+        '@id': "".concat(PREFIX, "author/").concat(publisher.get('id')),
+        '@type': 'foaf:Organization',
+        'foaf:name': publisher.get('display_name')
+    };
+    if (publisher.has('qid')) {
+        node['owl:sameAs'] = makeWikidataUri(publisher.get('qid'));
+    }
+    return node;
+}
+function makeLinkedDataForTaxon(taxon) {
+    var node = {
+        '@id': "".concat(PREFIX, "taxon/").concat(taxon.get('id')),
+        '@type': 'dwc:Taxon',
+        'dwc:scientificName': taxon.get('display_name'),
+    };
+    if (taxon.has('rank')) {
+        node['dwc:taxonRank'] = taxon.get('rank');
+    }
+    var ids = [];
+    if (taxon.has('qid')) {
+        ids.push(makeWikidataUri(taxon.get('qid')));
+    }
+    if (taxon.has('gbif')) {
+        ids.push(makeGbifUri(taxon.get('gbif')));
+    }
+    if (ids.length) {
+        node['owl:sameAs'] = ids;
+    }
+    return node;
+}
+function makeLinkedDataForTaxa(files) {
+    var _a;
+    var nodes = [];
+    var gbifTaxa = {};
+    for (var _i = 0, _b = files.taxa.entities; _i < _b.length; _i++) {
+        var taxon = _b[_i];
+        var node = makeLinkedDataForTaxon(taxon);
+        var ancestors = (_a = taxon.get('ancestors_gbif')) !== null && _a !== void 0 ? _a : [];
+        if (ancestors.length) {
+            node['dwc:parentNameUsageID'] = makeGbifUri(ancestors[ancestors.length - 1]);
+        }
+        else if (taxon.get('id') !== 'T141') {
+            node['dwc:parentNameUsageID'] = { '@id': "".concat(PREFIX, "taxon/T141") };
+        }
+        for (var i = 0; i < ancestors.length; i++) {
+            gbifTaxa[ancestors[i]] = __assign(__assign({}, makeGbifUri(ancestors[i])), { 'dwc:taxonRank': GBIF_RANKS[i], 'dwc:parentNameUsageID': i ? makeGbifUri(ancestors[i - 1]) : { '@id': "".concat(PREFIX, "taxon/T141") } });
+        }
+        if (taxon.has('children_gbif')) {
+            var children = taxon.get('children_gbif');
+            node['@reverse'] = { 'dwc:parentNameUsageID': children.map(makeGbifUri) };
+            var childRank = GBIF_RANKS[ancestors.length];
+            for (var _c = 0, children_1 = children; _c < children_1.length; _c++) {
+                var child = children_1[_c];
+                gbifTaxa[child] = __assign(__assign({}, makeGbifUri(child)), { 'dwc:taxonRank': childRank });
+            }
+        }
+        nodes.push(node);
+    }
+    nodes.push.apply(nodes, Object.values(gbifTaxa));
+    return nodes;
+}
+function makeLinkedDataForScientificName(name) {
+    var node = __assign(__assign({}, makeScientificNameUri(name.scientificNameID)), { '@type': 'dwc:Taxon' });
+    for (var field in DWC_FIELDS) {
+        var value = name[field];
+        if (value) {
+            node[DWC_FIELDS[field]] = value;
+        }
+    }
+    if (name.acceptedNameUsageID) {
+        node['dwc:acceptedNameUsageID'] = makeScientificNameUri(name.acceptedNameUsageID);
+    }
+    if (name.parentNameUsageID) {
+        node['dwc:parentNameUsageID'] = makeScientificNameUri(name.parentNameUsageID);
+    }
+    var identifiers = [];
+    if (name.gbifTaxonID) {
+        identifiers.push(makeGbifUri(name.gbifTaxonID));
+    }
+    if (name.colTaxonID) {
+        identifiers.push({ '@id': "https://www.checklistbank.org/dataset/309120/taxon/".concat(name.colTaxonID) });
+    }
+    if (identifiers.length) {
+        node['dwc:taxonID'] = identifiers;
+    }
+    return node;
+}
+function makeLinkedDataForResource(work, files, resourceId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var resource = new resource_1.WorkResource({});
+    if (!resourceId) {
+        resourceId = "".concat(work.get('id'), ":0");
+    }
+    if (files.resources[resourceId] && files.resources[resourceId].metadata.catalog) {
+        resource.fields = files.resources[resourceId].metadata.catalog;
+    }
+    if (!resource.has('language')) {
+        resource.fields.language = work.get('language');
+    }
+    var node = __assign(__assign({}, makeLinkedDataForWork(resource, files)), { '@id': "".concat(PREFIX, "resource/").concat(resourceId), '@type': 'bibo:DocumentPart' });
+    var types = (_b = (_a = resource.get('key_type')) !== null && _a !== void 0 ? _a : work.get('key_type')) !== null && _b !== void 0 ? _b : [];
+    if (types.includes('matrix')) {
+        node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Software' };
+    }
+    else if (types.includes('key') || types.includes('reference') || types.includes('supplement')) {
+        node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Text' };
+    }
+    else if (types.includes('gallery') || types.includes('collection')) {
+        node['dcterms:type'] = { '@id': 'http://purl.org/dc/dcmitype/Collection' };
+    }
+    if (types.includes('key') || types.includes('matrix')) {
+        node['ac:subtype'] = { '@id': 'http://rs.tdwg.org/acsubtype/values/IdentificationKey' };
+    }
+    var taxonNames = (_c = resource.get('taxon')) !== null && _c !== void 0 ? _c : work.get('taxon');
+    if (taxonNames) {
+        var taxa = mapEntities(taxonNames, files.taxa.entities);
+        var coveringTaxon = taxa.length ? getCoveringTaxon(taxa) : null;
+        if (coveringTaxon !== null) {
+            node['ac:taxonCoverage'] = { '@id': coveringTaxon };
+        }
+        node['dwc:taxonID'] = taxa.map(function (taxon) { return ({ '@id': "".concat(PREFIX, "taxon/").concat(taxon.get('id')) }); });
+    }
+    var scopes = (_d = resource.get('scope')) !== null && _d !== void 0 ? _d : work.get('scope');
+    if (scopes) {
+        for (var _i = 0, _j = scopes; _i < _j.length; _i++) {
+            var scope = _j[_i];
+            if (!SCOPES[scope]) {
+                console.error('Unmapped scope:', scope);
+                continue;
+            }
+            var _k = SCOPES[scope], property = _k[0], values = _k.slice(1);
+            if (!Array.isArray(node[property])) {
+                node[property] = [];
+            }
+            for (var _l = 0, values_1 = values; _l < values_1.length; _l++) {
+                var value = values_1[_l];
+                if (value.startsWith('http')) {
+                    node[property].push({ '@id': value });
+                }
+                else {
+                    node[property].push(value);
+                }
+            }
+        }
+    }
+    var region = (_e = resource.get('region')) !== null && _e !== void 0 ? _e : work.get('region');
+    if (region) {
+        var places = mapEntities(region, files.places.entities).map(function (place) { return ({ '@id': "".concat(PREFIX, "place/").concat(place.get('id')) }); });
+        node['dcterms:spatial'] = places;
+    }
+    var tags = [];
+    var taxonScopes = (_f = resource.get('taxon_scope')) !== null && _f !== void 0 ? _f : work.get('taxon_scope');
+    if (taxonScopes) {
+        tags.push.apply(tags, taxonScopes);
+    }
+    else if (((_g = resource.get('complete')) !== null && _g !== void 0 ? _g : work.get('complete')) === 'FALSE') {
+        tags.push('not intended to be complete');
+    }
+    var targetTaxa = (_h = resource.get('target_taxa')) !== null && _h !== void 0 ? _h : work.get('target_taxa');
+    if (targetTaxa) {
+        var first = targetTaxa.slice(0, -1).map(function (rank) { return rank + ','; });
+        var last = targetTaxa[targetTaxa.length - 1];
+        var list = first.length ? first.join('') + ' or ' + last : last;
+        tags.push("for identification to ".concat(list));
+    }
+    if (tags.length) {
+        node['ac:tag'] = tags;
+    }
+    if (files.resources[resourceId].taxa) {
+        var leafs = new Set(files.resources[resourceId].taxa.map(function (taxon) { return taxon.scientificNameID; }));
+        var taxa = [];
+        for (var _m = 0, _o = files.resources[resourceId].taxa; _m < _o.length; _m++) {
+            var taxon = _o[_m];
+            taxa.push(makeLinkedDataForScientificName(taxon));
+            if (taxon.parentNameUsageID) {
+                leafs.delete(taxon.parentNameUsageID);
+            }
+        }
+        node['dcterms:subject'] = taxa;
+        node['ac:taxonCount'] = leafs.size;
+    }
+    return node;
+}
+function makeLinkedDataForWork(work, files) {
+    var id = work.get('id');
+    var node = makeWorkUri(id);
+    var languages = work.get('language');
+    node['dcterms:language'] = languages.map(function (language) { return ({ '@id': "http://id.loc.gov/vocabulary/iso639-1/".concat(language) }); });
+    if (work.has('title')) {
+        var title = work.get('title');
+        node['dcterms:title'] = title.map(function (value, i) { return ({ '@value': value, '@lang': languages[i] }); });
+    }
+    if (work.has('pages') && work.get('pages').includes('-')) {
+        var containers = work.has('part_of') ? work.get('part_of').map(function (id) { return files.catalog.get(id); }) : [];
+        if (containers.find(function (container) { return container.get('entry_type') === 'online'; })) {
+            node['@type'] = 'bibo:BookSection';
+        }
+        else {
+            node['@type'] = 'bibo:AcademicArticle';
+        }
+    }
+    else if (work.get('entry_type') === 'online') {
+        node['@type'] = 'bibo:Website';
+    }
+    else {
+        node['@type'] = 'bibo:Book';
+    }
+    if (work.has('author')) {
+        var authors = mapEntities(work.get('author'), files.authors.entities).map(function (author) { return ({ '@id': "".concat(PREFIX, "author/").concat(author.get('id')) }); });
+        node['bibo:authorList'] = { '@list': authors };
+        node['dcterms:creator'] = authors;
+    }
+    if (work.has('url')) {
+        var urls = work.get('url');
+        var handle = urls.find(function (url) { return url.startsWith(HANDLE_PREFIX); });
+        if (handle) {
+            node['bibo:handle'] = handle.slice(HANDLE_PREFIX.length);
+        }
+        node['schema:url'] = urls.map(function (url) { return ({ '@id': url }); });
+    }
+    if (work.has('fulltext_url')) {
+        var urls = work.get('fulltext_url');
+        node['schema:encoding'] = urls.map(function (url) { return ({ '@type': 'schema:MediaObject', 'schema:contentUrl': { '@id': url } }); });
+    }
+    if (work.has('archive_url')) {
+        node['schema:archivedAt'] = work.get('archive_url').map(function (url) { return ({ '@id': url }); });
+    }
+    if (work.has('date')) {
+        node['dcterms:issued'] = work.get('date');
+    }
+    if (work.has('publisher')) {
+        var publishers = mapEntities(work.get('publisher'), files.publishers.entities).map(function (publisher) { return ({ '@id': "".concat(PREFIX, "publisher/").concat(publisher.get('id')) }); });
+        node['dcterms:publisher'] = publishers;
+    }
+    if (work.has('ISSN')) {
+        node['bibo:issn'] = work.get('ISSN');
+    }
+    if (work.has('ISBN')) {
+        var isbns = work.get('ISBN');
+        for (var _i = 0, isbns_1 = isbns; _i < isbns_1.length; _i++) {
+            var isbn = isbns_1[_i];
+            if (isbn.length === 13) {
+                node['bibo:isbn13'] = isbn;
+            }
+            else if (isbn.length === 10) {
+                node['bibo:isbn10'] = isbn;
+            }
+            else {
+                node['bibo:isbn'] = isbn;
+            }
+        }
+    }
+    if (work.has('QID')) {
+        node['bibo:uri'] = makeWikidataUri(work.get('QID'));
+    }
+    if (work.has('DOI')) {
+        node['bibo:doi'] = work.get('DOI');
+    }
+    if (work.has('volume')) {
+        node['bibo:volume'] = work.get('volume');
+    }
+    if (work.has('issue')) {
+        node['bibo:issue'] = work.get('issue');
+    }
+    if (work.has('pages')) {
+        var pages = work.get('pages');
+        var range = pages.split('-');
+        if (pages.match(/^\d+$/)) {
+            node['bibo:numPages'] = parseInt(pages);
+        }
+        else if (range.length === 2) {
+            node['bibo:pages'] = pages;
+            var _a = range.map(function (part) { return parseInt(part); }), start = _a[0], end = _a[1];
+            node['bibo:pageStart'] = start;
+            node['bibo:pageEnd'] = end;
+            node['bibo:numPages'] = end - start + 1;
+        }
+        else {
+            node['bibo:pages'] = pages;
+        }
+    }
+    if (work.has('edition')) {
+        node['bibo:edition'] = work.get('edition');
+    }
+    if (work.has('license')) {
+        var licenses = work.get('license');
+        node['dcterms:rights'] = licenses.map(function (license) {
+            if (license === '<public domain>' || license.match(/^<.+\?>$/)) {
+                return license.slice(1, -1);
+            }
+            else {
+                return { '@id': "https://spdx.org/licenses/".concat(license, ".html") };
+            }
+        });
+    }
+    return node;
+}
+function makeLinkedDataForWorks(files) {
+    var nodes = {};
+    var works = files.catalog;
+    for (var _i = 0, _a = works.entities; _i < _a.length; _i++) {
+        var work = _a[_i];
+        nodes[work.get('id')] = makeLinkedDataForWork(work, files);
+    }
+    var _loop_2 = function (work) {
+        var id = work.get('id');
+        var node = nodes[id];
+        var language = work.get('language');
+        if (work.has('part_of')) {
+            var containers = work.get('part_of');
+            if (work.get('key_type').includes('supplement')) {
+                node['bibo:annotates'] = containers.map(makeWorkUri);
+            }
+            else {
+                node['dcterms:isPartOf'] = containers.map(makeWorkUri);
+                for (var _d = 0, containers_1 = containers; _d < containers_1.length; _d++) {
+                    var container = containers_1[_d];
+                    if (!Array.isArray(nodes[container]['dcterms:hasPart'])) {
+                        nodes[container]['dcterms:hasPart'] = [];
+                    }
+                    nodes[container]['dcterms:hasPart'].push(makeWorkUri(id));
+                }
+            }
+        }
+        if (work.has('listed_in')) {
+            var referers = work.get('listed_in');
+            node['bibo:citedBy'] = node['dcterms:isReferencedBy'] = referers.map(makeWorkUri);
+            for (var _e = 0, referers_1 = referers; _e < referers_1.length; _e++) {
+                var referer = referers_1[_e];
+                nodes[referer]['bibo:cites'] = nodes[referer]['dcterms:references'] = makeWorkUri(id);
+            }
+        }
+        if (work.has('version_of')) {
+            var originals = work.get('version_of');
+            var originalLanguages_1 = originals.map(function (id) { return works.get(id).get('language').join(); });
+            node['bibo:translationOf'] = originals.filter(function (_, i) { return originalLanguages_1[i] !== language.join(); }).map(makeWorkUri);
+            node['dcterms:isVersionOf'] = originals.map(makeWorkUri);
+        }
+        var resourceIndex = 1;
+        var resourceId = void 0;
+        while ((resourceId = "".concat(id, ":").concat(resourceIndex++)) in files.resources) {
+            var resource = makeLinkedDataForResource(work, files, resourceId);
+            if (!Array.isArray(node['dcterms:hasPart'])) {
+                node['dcterms:hasPart'] = [];
+            }
+            node['dcterms:hasPart'].push(resource);
+            if (!Array.isArray(resource['dcterms:isPartof'])) {
+                resource['dcterms:isPartof'] = [];
+            }
+            resource['dcterms:isPartof'].push({ '@id': node['@id'] });
+        }
+    };
+    for (var _b = 0, _c = works.entities; _b < _c.length; _b++) {
+        var work = _c[_b];
+        _loop_2(work);
+    }
+    return Object.values(nodes);
+}
+function writeOutput(document_1) {
+    return __awaiter(this, arguments, void 0, function (document, format) {
+        var nquads, parser, writer;
+        if (format === void 0) { format = 'jsonld'; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (format === 'jsonld') {
+                        process.stdout.write(JSON.stringify(document, null, 2));
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, jsonld.toRDF(document, { format: 'application/n-quads' })];
+                case 1:
+                    nquads = _a.sent();
+                    if (format === 'nquads') {
+                        process.stdout.write(nquads);
+                        return [2 /*return*/];
+                    }
+                    parser = new N3.StreamParser();
+                    writer = new N3.StreamWriter({ prefixes: PREFIXES });
+                    parser.write(nquads);
+                    parser.pipe(writer);
+                    writer.pipe(process.stdout);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var args, directory, files, _i, SHEETS_1, sheet, filePath, file, resources, _a, _b, _loop_3, _c, _d, _e, _f, id, graph, _g, _h, entity, _j, _k, entity, _l, _m, entity, document;
+        return __generator(this, function (_o) {
+            switch (_o.label) {
+                case 0:
+                    args = util.parseArgs({
+                        allowPositionals: true,
+                        options: {
+                            format: {
+                                type: 'string',
+                                short: 'f',
+                                default: 'jsonld',
+                            }
+                        },
+                    });
+                    directory = path.resolve(args.positionals[0]);
+                    files = {};
+                    _i = 0, SHEETS_1 = SHEETS;
+                    _o.label = 1;
+                case 1:
+                    if (!(_i < SHEETS_1.length)) return [3 /*break*/, 4];
+                    sheet = SHEETS_1[_i];
+                    filePath = path.join(directory, "".concat(sheet, ".csv"));
+                    if (!(0, fs_1.existsSync)(filePath)) {
+                        throw new Error("File \"".concat(sheet, ".csv\" must be provided"));
+                    }
+                    return [4 /*yield*/, fs_1.promises.readFile(filePath, 'utf8')];
+                case 2:
+                    file = _o.sent();
+                    files[sheet] = index_1.catalog.loadData(file, sheet);
+                    _o.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    files.resources = {};
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, fs_1.promises.readFile(path.join(directory, 'resources', 'index.json'), 'utf8')];
+                case 5:
+                    resources = _b.apply(_a, [_o.sent()]);
+                    _loop_3 = function (id) {
+                        var filePath, file, _p, header, rows, taxa;
+                        return __generator(this, function (_q) {
+                            switch (_q.label) {
+                                case 0:
+                                    filePath = path.join(directory, 'resources', 'dwc', id.split(':').join('-') + '.csv');
+                                    return [4 /*yield*/, fs_1.promises.readFile(filePath, 'utf8')];
+                                case 1:
+                                    file = _q.sent();
+                                    _p = (0, csv_1.parseCsv)(file), header = _p[0], rows = _p.slice(1);
+                                    taxa = rows.map(function (row) { return row.reduce(function (object, value, index) {
+                                        object[header[index]] = value;
+                                        return object;
+                                    }, {}); });
+                                    files.resources[id] = { metadata: resources[id], taxa: taxa };
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _c = resources;
+                    _d = [];
+                    for (_e in _c)
+                        _d.push(_e);
+                    _f = 0;
+                    _o.label = 6;
+                case 6:
+                    if (!(_f < _d.length)) return [3 /*break*/, 9];
+                    _e = _d[_f];
+                    if (!(_e in _c)) return [3 /*break*/, 8];
+                    id = _e;
+                    return [5 /*yield**/, _loop_3(id)];
+                case 7:
+                    _o.sent();
+                    _o.label = 8;
+                case 8:
+                    _f++;
+                    return [3 /*break*/, 6];
+                case 9:
+                    graph = __spreadArray(__spreadArray([], makeLinkedDataForWorks(files), true), makeLinkedDataForTaxa(files), true);
+                    for (_g = 0, _h = files.authors.entities; _g < _h.length; _g++) {
+                        entity = _h[_g];
+                        graph.push(makeLinkedDataForAuthor(entity));
+                    }
+                    for (_j = 0, _k = files.places.entities; _j < _k.length; _j++) {
+                        entity = _k[_j];
+                        graph.push(makeLinkedDataForPlace(entity));
+                    }
+                    for (_l = 0, _m = files.publishers.entities; _l < _m.length; _l++) {
+                        entity = _m[_l];
+                        graph.push(makeLinkedDataForPublisher(entity));
+                    }
+                    document = {
+                        '@context': PREFIXES,
+                        '@graph': graph
+                    };
+                    writeOutput(document, args.values.format);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main().catch(function (error) {
+    console.error(error);
+    process.exit(1);
+});