componentsjs 5.0.0-beta.3 → 5.0.0-beta.7

package/CHANGELOG.md

@@ -1,6 +1,46 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.0.0-beta.7"></a>
+## [v5.0.0-beta.7](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.6...v5.0.0-beta.7) - 2022-02-21
+
+### Changed
+* [Lower log level of empty modules to debug](https://github.com/LinkedSoftwareDependencies/Components.js/commit/df119861bc12992e05af05b42f0a734069de6915)
+* [Bump to rdf-object 1.13.1](https://github.com/LinkedSoftwareDependencies/Components.js/commit/264be522079f86bd47bea9fe5730eaed29bbe450)
+
+### Fixed
+* [Fix incorrect error logging when generics error occurs in extends clause](https://github.com/LinkedSoftwareDependencies/Components.js/commit/1ce62d39896ca498ecba7443c9c7c298c9db0301)
+* [Fix minor context issues](https://github.com/LinkedSoftwareDependencies/Components.js/commit/7adcd5fe0de73a42c8225069752be40214f843f3)
+
+<a name="v5.0.0-beta.6"></a>
+## [v5.0.0-beta.6](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.5...v5.0.0-beta.6) - 2022-02-09
+
+### Fixed
+* [Fix generic errors still throwing during ignored type checking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c14adcf4757e5194db22c0f0285407bd03bf5635)
+
+<a name="v5.0.0-beta.5"></a>
+## [v5.0.0-beta.5](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.4...v5.0.0-beta.5) - 2022-02-08
+
+### Added
+* [Allow type-checking to be disabled via typeChecking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a55331085e4c5621832e6b23bc52b00068e8256a)
+
+### Changed
+* [Throw error on circular dependencies, Closes #53](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e7a28d1cf87d96d5b58bb6d1f19ce41d6e55aab6)
+
+### Fixed
+* [Fix seeAlso links not handling encoded URI components, Closes #43](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2b72914d2720b2982d4570af55f9b5d7dc196c27)
+
+<a name="v5.0.0-beta.4"></a>
+## [v5.0.0-beta.4](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.3...v5.0.0-beta.4) - 2022-01-29
+
+### Added
+* [Support ParameterRangeIndexed for fixed literals](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0d97782a4a8dcca9fc5bbb3389a4213eca5a5205)
+
+### Changed
+* [Propagate original error messages to require calls, Closes #65](https://github.com/LinkedSoftwareDependencies/Components.js/commit/8934ec9b784def601730b3d3f2e60c4ff0b8776e)
+* [Include config id in invalid param error message](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e724f44e2222eb9917da3b227e2ce0dc9cde15f9)
+* [Update memberKeys to memberFields](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2c7437e1519c1813fb1a29f50d7c20bdbdf7f06e)
+
 <a name="v5.0.0-beta.3"></a>
 ## [v5.0.0-beta.3](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.2...v5.0.0-beta.3) - 2022-01-17
 

package/README.md

@@ -202,6 +202,41 @@ const myInstance = await manager.instantiate('http://example.org/myInstance');
 [RDF]: https://www.w3.org/RDF/
 [JSON-LD]: https://json-ld.org/
 
+## Advanced usage
+
+The `ComponentsManager` can be customized with the following options:
+
+```javascript
+const manager = await ComponentsManager.build({
+    // Absolute path to the package root from which module resolution should start.
+    mainModulePath: __dirname,
+    // Callback for registering components and modules
+    // Defaults to an invocation of {@link ComponentRegistry.registerAvailableModules}.
+    moduleLoader: (registry) => {},
+    // Callback for registering configurations.
+    // Defaults to no config registrations.
+    configLoader: (registry) => {},
+    // A strategy for constructing instances.
+    // Defaults to {@link ConstructionStrategyCommonJs}.
+    constructionStrategy: new ConstructionStrategyCommonJs(),
+    // If the error state should be dumped into `componentsjs-error-state.json` after failed instantiations.
+    // Defaults to `true`.
+    dumpErrorState: true,
+    // The logging level.
+    // Defaults to `'warn'`.
+    logLevel: 'warn',
+    // The module state.
+    // Defaults to a newly created instance on the {@link mainModulePath}.
+    moduleState: {},
+    // If JSON-LD context validation should be skipped.
+    // Defaults to `true`.
+    skipContextValidation: true,
+    // If values for parameters should be type-checked.
+    // Defaults to `true`.
+    typeChecking: true,
+});
+```
+
 ## Cite
 
 If you are using or extending Components.js as part of a scientific publication,

package/components/context.jsonld

@@ -32,8 +32,11 @@
     "parameters": {
       "@id": "oo:parameter"
     },
-    "memberKeys": {
-      "@id": "oo:memberKey"
+    "memberFields": {
+      "@id": "oo:memberField"
+    },
+    "memberFieldName": {
+      "@id": "oo:memberFieldName"
     },
     "genericTypeParameters": {
       "@id": "oo:genericTypeParameter"
@@ -108,8 +111,11 @@
     "ParameterRangeIntersection": {
       "@id": "oo:ParameterRangeIntersection"
     },
+    "ParameterRangeTuple": {
+      "@id": "oo:ParameterRangeTuple"
+    },
     "parameterRangeElements": {
-      "@id": "oo:parameterRangeElements",
+      "@id": "oo:parameterRangeElement",
       "@type": "@id"
     },
     "ParameterRangeCollectEntries": {
@@ -138,7 +144,18 @@
       "@type": "@id"
     },
     "parameterRangeGenericBindings": {
-      "@id": "oo:parameterRangeGenericBindings",
+      "@id": "oo:parameterRangeGenericBinding",
+      "@type": "@id"
+    },
+    "ParameterRangeIndexed": {
+      "@id": "oo:ParameterRangeIndexed"
+    },
+    "parameterRangeIndexedObject": {
+      "@id": "oo:parameterRangeIndexedObject",
+      "@type": "@id"
+    },
+    "parameterRangeIndexedIndex": {
+      "@id": "oo:parameterRangeIndexedIndex",
       "@type": "@id"
     },
     "GenericComponentExtension": {

package/lib/construction/ConfigConstructorPool.js

@@ -28,7 +28,7 @@ class ConfigConstructorPool {
         // if so, return a dummy value, to avoid infinite recursion.
         const resourceBlacklist = settings.resourceBlacklist || {};
         if (resourceBlacklist[configResource.value]) {
-            return Promise.resolve(this.constructionStrategy.createUndefined());
+            return Promise.reject(new ErrorResourcesContext_1.ErrorResourcesContext(`Circular dependency was detected on ${configResource.value}`, { config: configResource }));
         }
         // Before instantiating, first check if the resource is a variable
         if (configResource.isA('Variable')) {

package/lib/construction/strategy/ConstructionStrategyCommonJs.d.ts

@@ -16,7 +16,9 @@ export declare class ConstructionStrategyCommonJs implements IConstructionStrate
      * @param requireName The module name that should be required.
      * @returns {any} The require() result
      */
-    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): void;
+    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): {
+        value: any;
+    } | false;
     createHash(options: ICreationStrategyHashOptions<any>): any;
     createArray(options: ICreationStrategyArrayOptions<any>): any;
     createLazySupplier(options: ICreationStrategySupplierOptions<any>): Promise<any>;

package/lib/construction/strategy/ConstructionStrategyCommonJs.js

@@ -14,16 +14,14 @@ class ConstructionStrategyCommonJs {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
+        // First try requiring current module, and fallback to a plain require
         let object;
-        try {
-            object = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-        }
-        catch (_a) {
-            // Always require relative from main module, because Components.js will in most cases just be dependency.
-            object = this.req(options.requireName.startsWith('.') ?
+        const currentResult = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        object = currentResult !== false ?
+            currentResult.value :
+            this.req(options.requireName.startsWith('.') ?
                 Path.join(process.cwd(), options.requireName) :
                 this.req.resolve(options.requireName, { paths: [options.moduleState.mainModulePath] }));
-        }
         // Determine the child of the require'd element
         let subObject;
         if (options.requireElement) {
@@ -31,7 +29,7 @@ class ConstructionStrategyCommonJs {
             try {
                 subObject = requireElementPath.reduce((acc, subRequireElement) => acc[subRequireElement], object);
             }
-            catch (_b) {
+            catch (_a) {
                 throw new Error(`Failed to get module element ${options.requireElement} from module ${options.requireName}`);
             }
         }
@@ -65,11 +63,11 @@ class ConstructionStrategyCommonJs {
                 const mainPath = Path.posix.join(moduleState.mainModulePath, pckg.main);
                 const required = this.req(mainPath);
                 if (required) {
-                    return required;
+                    return { value: required };
                 }
             }
         }
-        throw new Error('Component is not the main module');
+        return false;
     }
     createHash(options) {
         return options.entries.reduce((data, entry) => {

package/lib/construction/strategy/ConstructionStrategyCommonJsString.js

@@ -30,14 +30,12 @@ class ConstructionStrategyCommonJsString {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
-        let resultingRequirePath;
-        try {
-            this.strategyCommonJs.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-            resultingRequirePath = `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}`;
-        }
-        catch (_a) {
-            resultingRequirePath = options.requireName;
-        }
+        // First try requiring current module, and fallback to a plain require
+        const currentResult = this.strategyCommonJs
+            .requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        const resultingRequirePath = currentResult !== false ?
+            `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}` :
+            options.requireName;
         let serialization = `require('${resultingRequirePath.replace(/\\/gu, '/')}')`;
         // Determine the child of the require'd element
         if (options.requireElement) {

package/lib/loading/ComponentRegistry.js

@@ -60,7 +60,7 @@ class ComponentRegistry {
             }
         }
         else {
-            this.logger.warn(`Registered a module ${moduleResource.value} without components.`);
+            this.logger.debug(`Registered a module ${moduleResource.value} without components.`);
         }
     }
     /**

package/lib/loading/ComponentsManagerBuilder.d.ts

@@ -18,6 +18,7 @@ export declare class ComponentsManagerBuilder<Instance = any> {
     private readonly logger;
     private readonly moduleState?;
     private readonly skipContextValidation;
+    private readonly typeChecking;
     constructor(options: IComponentsManagerBuilderOptions<Instance>);
     static createLogger(logLevel?: LogLevel): Logger;
     static createObjectLoader(): RdfObjectLoader;
@@ -69,4 +70,9 @@ export interface IComponentsManagerBuilderOptions<Instance> {
      * Defaults to `true`.
      */
     skipContextValidation?: boolean;
+    /**
+     * If values for parameters should be type-checked.
+     * Defaults to `true`.
+     */
+    typeChecking?: boolean;
 }

package/lib/loading/ComponentsManagerBuilder.js

@@ -31,6 +31,9 @@ class ComponentsManagerBuilder {
         this.skipContextValidation = options.skipContextValidation === undefined ?
             true :
             Boolean(options.skipContextValidation);
+        this.typeChecking = options.typeChecking === undefined ?
+            true :
+            Boolean(options.typeChecking);
     }
     static createLogger(logLevel = 'warn') {
         return (0, winston_1.createLogger)({
@@ -92,7 +95,7 @@ class ComponentsManagerBuilder {
         this.logger.info(`Loaded configs`);
         // Build constructor pool
         const runTypeConfigs = {};
-        const parameterHandler = new ParameterHandler_1.ParameterHandler({ objectLoader });
+        const parameterHandler = new ParameterHandler_1.ParameterHandler({ objectLoader, typeChecking: this.typeChecking });
         const configConstructorPool = new ConfigConstructorPool_1.ConfigConstructorPool({
             objectLoader,
             configPreprocessors: [

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -97,8 +97,11 @@ class ConfigPreprocessorComponent {
         // ParameterPropertyHandlerRange#hasParamValueValidType)
         if (config.property.genericTypeInstancesComponentScope &&
             handleResponse.component.value === config.property.genericTypeInstancesComponentScope.value) {
-            genericsContext.bindComponentGenericTypes(handleResponse.component, config.properties.genericTypeInstances, { config }, (subType, superType) => this.parameterHandler.parameterPropertyHandlerRange
+            const conflict = genericsContext.bindComponentGenericTypes(handleResponse.component, config.properties.genericTypeInstances, { config }, (subType, superType) => this.parameterHandler.parameterPropertyHandlerRange
                 .hasType(subType, superType, genericsContext, config.property.genericTypeInstancesComponentScope, config.properties.genericTypeInstances, { config }));
+            if (conflict) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(conflict.description, { cause: conflict });
+            }
         }
         return genericsContext;
     }

package/lib/preprocess/GenericsContext.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericsContext = void 0;
-const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
 const ParameterPropertyHandlerRange_1 = require("./parameterproperty/ParameterPropertyHandlerRange");
 /**
  * Context for binding generic types to a concrete range value.
@@ -270,7 +269,10 @@ class GenericsContext {
         }
         // Throw if an unexpected number of generic type instances are passed.
         if (genericTypeParameters.length !== genericTypeInstances.length) {
-            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid generic type instantiation: a different amount of generic types are passed (${genericTypeInstances.length}) than are defined on the component (${genericTypeParameters.length}).`, Object.assign({ passedGenerics: genericTypeInstances, definedGenerics: genericTypeParameters, component }, errorContext));
+            return {
+                description: `Invalid generic type instantiation: a different amount of generic types are passed (${genericTypeInstances.length}) than are defined on the component (${genericTypeParameters.length}).`,
+                context: Object.assign({ passedGenerics: genericTypeInstances, definedGenerics: genericTypeParameters, component }, errorContext),
+            };
         }
         // Populate with manually defined generic type bindings
         for (const [i, genericTypeInstance] of genericTypeInstances.entries()) {

package/lib/preprocess/ParameterHandler.d.ts

@@ -21,4 +21,5 @@ export declare class ParameterHandler {
 }
 export interface IParameterHandlerOptions {
     objectLoader: RdfObjectLoader;
+    typeChecking: boolean;
 }

package/lib/preprocess/ParameterHandler.js

@@ -17,7 +17,7 @@ class ParameterHandler {
             new ParameterPropertyHandlerDefaultScoped_1.ParameterPropertyHandlerDefaultScoped(this.objectLoader),
             new ParameterPropertyHandlerDefault_1.ParameterPropertyHandlerDefault(this.objectLoader),
             new ParameterPropertyHandlerFixed_1.ParameterPropertyHandlerFixed(this.objectLoader),
-            this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
+            this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader, options.typeChecking),
             new ParameterPropertyHandlerLazy_1.ParameterPropertyHandlerLazy(),
         ];
     }
@@ -38,7 +38,7 @@ class ParameterHandler {
         }
         else if (values.length > 0) {
             if (values.some(subValue => !subValue.list)) {
-                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for parameter ${parameter.value}. RDF lists should be used for defining multiple values.`, {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for parameter ${parameter.value} in ${configElement.value}. RDF lists should be used for defining multiple values.`, {
                     arguments: values,
                 });
             }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.d.ts

@@ -7,7 +7,8 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
  */
 export declare class ParameterPropertyHandlerRange implements IParameterPropertyHandler {
     private readonly objectLoader;
-    constructor(objectLoader: RdfObjectLoader);
+    private readonly typeChecking;
+    constructor(objectLoader: RdfObjectLoader, typeChecking: boolean);
     canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
     handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext): Resource | undefined;
     /**

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.js

@@ -8,8 +8,9 @@ const GenericsContext_1 = require("../GenericsContext");
  * If a param range is defined, apply the type and validate the range.
  */
 class ParameterPropertyHandlerRange {
-    constructor(objectLoader) {
+    constructor(objectLoader, typeChecking) {
         this.objectLoader = objectLoader;
+        this.typeChecking = typeChecking;
     }
     canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.range);
@@ -30,7 +31,7 @@ class ParameterPropertyHandlerRange {
     captureType(value, param, genericsContext) {
         const errorContext = { param };
         const conflict = this.hasValueType(value, param.property.range, errorContext, genericsContext);
-        if (!conflict) {
+        if (!conflict || !this.typeChecking) {
             return value;
         }
         ParameterPropertyHandlerRange.throwIncorrectTypeError(value, param, genericsContext, conflict);
@@ -259,9 +260,9 @@ class ParameterPropertyHandlerRange {
             // Simulate a union of the member keys as literal parameter ranges
             const simulatedUnionRange = this.objectLoader.createCompactedResource({
                 '@type': 'ParameterRangeUnion',
-                parameterRangeElements: component.properties.memberKeys.map(memberKey => ({
+                parameterRangeElements: component.properties.memberFields.map(memberField => ({
                     '@type': 'ParameterRangeLiteral',
-                    parameterRangeValue: memberKey,
+                    parameterRangeValue: memberField.property.memberFieldName,
                 })),
             });
             const subConflict = this.hasValueType(value, simulatedUnionRange, errorContext, genericsContext);
@@ -274,6 +275,39 @@ class ParameterPropertyHandlerRange {
                 causes: [subConflict],
             };
         }
+        // Check if the range refers to an indexed type such as `MyClass[myField]`
+        if (type.isA('ParameterRangeIndexed')) {
+            const object = type.property.parameterRangeIndexedObject;
+            const index = type.property.parameterRangeIndexedIndex;
+            // Collect field ranges
+            const fieldRanges = Object.fromEntries(object.properties.memberFields
+                .map(memberField => [memberField.property.memberFieldName.value, memberField.property.range ||
+                    this.objectLoader.createCompactedResource({ '@type': 'ParameterRangeWildcard' })]));
+            // Handle literal indexes
+            if (index.isA('ParameterRangeLiteral')) {
+                const field = index.property.parameterRangeValue.value;
+                const range = fieldRanges[field];
+                if (!range) {
+                    return {
+                        description: `indexed index does not refer to a known field`,
+                        context: errorContext,
+                    };
+                }
+                const subConflict = this.hasValueType(value, range, errorContext, genericsContext);
+                if (!subConflict) {
+                    return;
+                }
+                return {
+                    description: `indexed value is invalid`,
+                    context: errorContext,
+                    causes: [subConflict],
+                };
+            }
+            return {
+                description: `indexed index type can not be understood`,
+                context: errorContext,
+            };
+        }
         // Check if the range refers to a generic type
         if (type.isA('ParameterRangeGenericTypeReference')) {
             return genericsContext.bindGenericTypeToValue(type.property.parameterRangeGenericType.value, value, (subValue, subType) => this.hasValueType(subValue, subType, errorContext, genericsContext), (subType, superType) => this.hasType(subType, superType, genericsContext, undefined, [], errorContext));
@@ -467,6 +501,13 @@ class ParameterPropertyHandlerRange {
             return `(${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.component, genericsContext)})<${paramRange.properties.genericTypeInstances
                 .map(genericTypeInstance => ParameterPropertyHandlerRange.rangeToDisplayString(genericTypeInstance, genericsContext)).join(', ')}>`;
         }
+        if (paramRange.isA('ParameterRangeIndexed')) {
+            const object = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedObject, genericsContext);
+            const index = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedIndex, genericsContext);
+            return `${object}[${index}]`;
+        }
         return paramRange.value;
     }
 }

package/lib/rdf/Iris.d.ts

@@ -18,7 +18,7 @@ export declare const IRIS_RDF: {
 };
 export declare const PREFIX_RDFS: (suffix: string) => string;
 export declare const IRIS_RDFS: {
-    imports: string;
+    seeAlso: string;
 };
 export declare const PREFIX_XSD: (suffix: string) => string;
 export declare const IRIS_XSD: {

package/lib/rdf/Iris.js

@@ -22,7 +22,7 @@ exports.IRIS_RDF = {
 };
 exports.PREFIX_RDFS = definePrefix('http://www.w3.org/2000/01/rdf-schema#');
 exports.IRIS_RDFS = {
-    imports: (0, exports.PREFIX_RDFS)('seeAlso'),
+    seeAlso: (0, exports.PREFIX_RDFS)('seeAlso'),
 };
 exports.PREFIX_XSD = definePrefix('http://www.w3.org/2001/XMLSchema#');
 exports.IRIS_XSD = {

package/lib/rdf/RdfStreamIncluder.js

@@ -36,9 +36,9 @@ class RdfStreamIncluder extends stream_1.Transform {
      * @param quad A quad.
      */
     handleImports(quad) {
-        if (!this.parserOptions.ignoreImports && quad.predicate.value === Iris_1.IRIS_RDFS.imports) {
+        if (!this.parserOptions.ignoreImports && quad.predicate.value === Iris_1.IRIS_RDFS.seeAlso) {
             this.runningImporters++;
-            let relativeFilePath = quad.object.value;
+            let relativeFilePath = decodeURI(quad.object.value);
             // Try overriding path using defined import paths
             if (this.parserOptions.importPaths) {
                 for (const prefix of Object.keys(this.parserOptions.importPaths)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.7",
   "description": "A semantic dependency injection framework",
   "lsd:contexts": {
     "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^3.0.0/components/context.jsonld": "components/context.jsonld"
@@ -40,7 +40,7 @@
     "jsonld-context-parser": "^2.1.1",
     "minimist": "^1.2.0",
     "rdf-data-factory": "^1.1.0",
-    "rdf-object": "^1.13.0",
+    "rdf-object": "^1.13.1",
     "rdf-parse": "^1.9.1",
     "rdf-quad": "^1.5.0",
     "rdf-terms": "^1.7.0",