@shaclmate/compiler 2.0.23 → 2.0.24

package/dist/input/generated.js

@@ -1,4 +1,5 @@
-import { DataFactory as dataFactory } from "n3";
+import { StoreFactory as _DatasetFactory, DataFactory as dataFactory, } from "n3";
+const datasetFactory = new _DatasetFactory();
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
 import { PropertyPath } from "./PropertyPath.js";
@@ -37,95 +38,150 @@ export var BaseShaclCoreShapeStatic;
         $Identifier.fromString = fromString;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = BaseShaclCoreShapeStatic.$Identifier || (BaseShaclCoreShapeStatic.$Identifier = {}));
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclCoreNodeShapeStatic.$fromRdf(resource, {
+            ...context,
+            ignoreRdfType: false,
+            objectSet,
+        }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf(resource, {
+            ...context,
+            ignoreRdfType: false,
+            objectSet,
+        }));
+    }
+    BaseShaclCoreShapeStatic.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $identifier = $resource.identifier;
-        const _andEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.and["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier()))))));
+        const _andEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.and["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: BaseShaclCoreShapeStatic.$properties.and["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.and["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_andEither.isLeft()) {
             return _andEither;
         }
         const and = _andEither.unsafeCoerce();
-        const _classesEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.classes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri())));
+        const _classesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.classes["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.classes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_classesEither.isLeft()) {
             return _classesEither;
         }
         const classes = _classesEither.unsafeCoerce();
-        const _commentsEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.comments["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _commentsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.comments["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.comments["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_commentsEither.isLeft()) {
             return _commentsEither;
         }
         const comments = _commentsEither.unsafeCoerce();
-        const _datatypeEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIri())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _datatypeEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.datatype["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_datatypeEither.isLeft()) {
             return _datatypeEither;
         }
         const datatype = _datatypeEither.unsafeCoerce();
-        const _deactivatedEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _deactivatedEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.deactivated["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_deactivatedEither.isLeft()) {
             return _deactivatedEither;
         }
         const deactivated = _deactivatedEither.unsafeCoerce();
-        const _flagsEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.flags["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toString())));
+        const _flagsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.flags["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.flags["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_flagsEither.isLeft()) {
             return _flagsEither;
         }
         const flags = _flagsEither.unsafeCoerce();
-        const _hasValuesEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+        const _hasValuesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => purify.Either.of(value.toTerm()).chain((term) => {
             switch (term.termType) {
                 case "Literal":
                 case "NamedNode":
@@ -138,19 +194,25 @@ export var BaseShaclCoreShapeStatic;
                         predicate: BaseShaclCoreShapeStatic.$properties.hasValues["identifier"],
                     }));
             }
-        }))));
+        })))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.hasValues["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_hasValuesEither.isLeft()) {
             return _hasValuesEither;
         }
         const hasValues = _hasValuesEither.unsafeCoerce();
-        const _in_Either = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.in_["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+        const _in_Either = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.in_["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: BaseShaclCoreShapeStatic.$properties.in_["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => purify.Either.of(value.toTerm()).chain((term) => {
             switch (term.termType) {
                 case "Literal":
                 case "NamedNode":
@@ -164,207 +226,368 @@ export var BaseShaclCoreShapeStatic;
                     }));
             }
         })))))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.in_["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_in_Either.isLeft()) {
             return _in_Either;
         }
         const in_ = _in_Either.unsafeCoerce();
-        const _isDefinedByEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIdentifier())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _isDefinedByEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_isDefinedByEither.isLeft()) {
             return _isDefinedByEither;
         }
         const isDefinedBy = _isDefinedByEither.unsafeCoerce();
-        const _labelsEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.labels["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _labelsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.labels["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.labels["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        const _languageInEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => value.toString()))))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _languageInEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => value.toString()))))
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.languageIn["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_languageInEither.isLeft()) {
             return _languageInEither;
         }
         const languageIn = _languageInEither.unsafeCoerce();
-        const _maxCountEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toNumber())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _maxCountEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toNumber()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.maxCount["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_maxCountEither.isLeft()) {
             return _maxCountEither;
         }
         const maxCount = _maxCountEither.unsafeCoerce();
-        const _maxExclusiveEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], { unique: true })
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _maxExclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_maxExclusiveEither.isLeft()) {
             return _maxExclusiveEither;
         }
         const maxExclusive = _maxExclusiveEither.unsafeCoerce();
-        const _maxInclusiveEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], { unique: true })
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _maxInclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_maxInclusiveEither.isLeft()) {
             return _maxInclusiveEither;
         }
         const maxInclusive = _maxInclusiveEither.unsafeCoerce();
-        const _maxLengthEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toNumber())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _maxLengthEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toNumber()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.maxLength["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_maxLengthEither.isLeft()) {
             return _maxLengthEither;
         }
         const maxLength = _maxLengthEither.unsafeCoerce();
-        const _minCountEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toNumber())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _minCountEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toNumber()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.minCount["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_minCountEither.isLeft()) {
             return _minCountEither;
         }
         const minCount = _minCountEither.unsafeCoerce();
-        const _minExclusiveEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], { unique: true })
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _minExclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_minExclusiveEither.isLeft()) {
             return _minExclusiveEither;
         }
         const minExclusive = _minExclusiveEither.unsafeCoerce();
-        const _minInclusiveEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], { unique: true })
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _minInclusiveEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_minInclusiveEither.isLeft()) {
             return _minInclusiveEither;
         }
         const minInclusive = _minInclusiveEither.unsafeCoerce();
-        const _minLengthEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toNumber())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _minLengthEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toNumber()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.minLength["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_minLengthEither.isLeft()) {
             return _minLengthEither;
         }
         const minLength = _minLengthEither.unsafeCoerce();
-        const _nodeKindEither = $resource
-            .values(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _nodeKindEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://www.w3.org/ns/shacl#BlankNode":
                     return purify.Either.of(iri);
@@ -386,69 +609,92 @@ export var BaseShaclCoreShapeStatic;
                         predicate: BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_nodeKindEither.isLeft()) {
             return _nodeKindEither;
         }
         const nodeKind = _nodeKindEither.unsafeCoerce();
-        const _nodesEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier())));
+        const _nodesEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.nodes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_nodesEither.isLeft()) {
             return _nodesEither;
         }
         const nodes = _nodesEither.unsafeCoerce();
-        const _notEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.not["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier())));
+        const _notEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.not["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.not["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_notEither.isLeft()) {
             return _notEither;
         }
         const not = _notEither.unsafeCoerce();
-        const _orEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.or["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier()))))));
+        const _orEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.or["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: BaseShaclCoreShapeStatic.$properties.or["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.or["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_orEither.isLeft()) {
             return _orEither;
         }
         const or = _orEither.unsafeCoerce();
-        const _patternsEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toString())));
+        const _patternsEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.patterns["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_patternsEither.isLeft()) {
             return _patternsEither;
         }
         const patterns = _patternsEither.unsafeCoerce();
-        const _xoneEither = purify.Either.sequence($resource
-            .values(BaseShaclCoreShapeStatic.$properties.xone["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier()))))));
+        const _xoneEither = purify.Either.of($resource.values(BaseShaclCoreShapeStatic.$properties.xone["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: BaseShaclCoreShapeStatic.$properties.xone["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: BaseShaclCoreShapeStatic.$properties.xone["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_xoneEither.isLeft()) {
             return _xoneEither;
         }
@@ -483,14 +729,15 @@ export var BaseShaclCoreShapeStatic;
         });
     }
     BaseShaclCoreShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        const { ignoreRdfType: _, ...otherParameters } = parameters;
-        return ShaclCoreNodeShapeStatic.$fromRdf(otherParameters).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf(otherParameters));
-    }
-    BaseShaclCoreShapeStatic.$fromRdf = $fromRdf;
-    function $toRdf(_baseShaclCoreShape, { mutateGraph, resourceSet, }) {
-        const _resource = resourceSet.mutableResource(_baseShaclCoreShape.$identifier, { mutateGraph });
-        _resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], _baseShaclCoreShape.and.map((item) => item.length > 0
+    function $toRdf(_baseShaclCoreShape, options) {
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = resourceSet.mutableResource(_baseShaclCoreShape.$identifier, { mutateGraph });
+        resource.add(BaseShaclCoreShapeStatic.$properties.and["identifier"], _baseShaclCoreShape.and.map((item) => item.length > 0
             ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -510,13 +757,13 @@ export var BaseShaclCoreShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], _baseShaclCoreShape.classes.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.comments["identifier"], _baseShaclCoreShape.comments.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], _baseShaclCoreShape.datatype);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], _baseShaclCoreShape.deactivated);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.flags["identifier"], _baseShaclCoreShape.flags.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], _baseShaclCoreShape.hasValues.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.in_["identifier"], _baseShaclCoreShape.in_.map((value) => value.length > 0
+        resource.add(BaseShaclCoreShapeStatic.$properties.classes["identifier"], _baseShaclCoreShape.classes.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.comments["identifier"], _baseShaclCoreShape.comments.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.datatype["identifier"], _baseShaclCoreShape.datatype);
+        resource.add(BaseShaclCoreShapeStatic.$properties.deactivated["identifier"], _baseShaclCoreShape.deactivated);
+        resource.add(BaseShaclCoreShapeStatic.$properties.flags["identifier"], _baseShaclCoreShape.flags.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.hasValues["identifier"], _baseShaclCoreShape.hasValues.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.in_["identifier"], _baseShaclCoreShape.in_.map((value) => value.length > 0
             ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -536,9 +783,9 @@ export var BaseShaclCoreShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], _baseShaclCoreShape.isDefinedBy);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], _baseShaclCoreShape.labels.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], _baseShaclCoreShape.languageIn.map((value) => value.length > 0
+        resource.add(BaseShaclCoreShapeStatic.$properties.isDefinedBy["identifier"], _baseShaclCoreShape.isDefinedBy);
+        resource.add(BaseShaclCoreShapeStatic.$properties.labels["identifier"], _baseShaclCoreShape.labels.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.languageIn["identifier"], _baseShaclCoreShape.languageIn.map((value) => value.length > 0
             ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -558,18 +805,18 @@ export var BaseShaclCoreShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], _baseShaclCoreShape.maxCount);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], _baseShaclCoreShape.maxExclusive);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], _baseShaclCoreShape.maxInclusive);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], _baseShaclCoreShape.maxLength);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], _baseShaclCoreShape.minCount);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], _baseShaclCoreShape.minExclusive);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], _baseShaclCoreShape.minInclusive);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], _baseShaclCoreShape.minLength);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], _baseShaclCoreShape.nodeKind);
-        _resource.add(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], _baseShaclCoreShape.nodes.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.not["identifier"], _baseShaclCoreShape.not.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.or["identifier"], _baseShaclCoreShape.or.map((item) => item.length > 0
+        resource.add(BaseShaclCoreShapeStatic.$properties.maxCount["identifier"], _baseShaclCoreShape.maxCount);
+        resource.add(BaseShaclCoreShapeStatic.$properties.maxExclusive["identifier"], _baseShaclCoreShape.maxExclusive);
+        resource.add(BaseShaclCoreShapeStatic.$properties.maxInclusive["identifier"], _baseShaclCoreShape.maxInclusive);
+        resource.add(BaseShaclCoreShapeStatic.$properties.maxLength["identifier"], _baseShaclCoreShape.maxLength);
+        resource.add(BaseShaclCoreShapeStatic.$properties.minCount["identifier"], _baseShaclCoreShape.minCount);
+        resource.add(BaseShaclCoreShapeStatic.$properties.minExclusive["identifier"], _baseShaclCoreShape.minExclusive);
+        resource.add(BaseShaclCoreShapeStatic.$properties.minInclusive["identifier"], _baseShaclCoreShape.minInclusive);
+        resource.add(BaseShaclCoreShapeStatic.$properties.minLength["identifier"], _baseShaclCoreShape.minLength);
+        resource.add(BaseShaclCoreShapeStatic.$properties.nodeKind["identifier"], _baseShaclCoreShape.nodeKind);
+        resource.add(BaseShaclCoreShapeStatic.$properties.nodes["identifier"], _baseShaclCoreShape.nodes.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.not["identifier"], _baseShaclCoreShape.not.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.or["identifier"], _baseShaclCoreShape.or.map((item) => item.length > 0
             ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -589,8 +836,8 @@ export var BaseShaclCoreShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], _baseShaclCoreShape.patterns.map((item) => item));
-        _resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], _baseShaclCoreShape.xone.map((item) => item.length > 0
+        resource.add(BaseShaclCoreShapeStatic.$properties.patterns["identifier"], _baseShaclCoreShape.patterns.map((item) => item));
+        resource.add(BaseShaclCoreShapeStatic.$properties.xone["identifier"], _baseShaclCoreShape.xone.map((item) => item.length > 0
             ? item.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -610,7 +857,7 @@ export var BaseShaclCoreShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        return _resource;
+        return resource;
     }
     BaseShaclCoreShapeStatic.$toRdf = $toRdf;
     BaseShaclCoreShapeStatic.$properties = {
@@ -691,13 +938,32 @@ export var ShaclCorePropertyShapeStatic;
 (function (ShaclCorePropertyShapeStatic) {
     ShaclCorePropertyShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     ShaclCorePropertyShapeStatic.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmatePropertyShape.$fromRdf(resource, {
+            ...context,
+            ignoreRdfType: false,
+            objectSet,
+        }).altLazy(() => ShaclCorePropertyShapeStatic.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        }));
+    }
+    ShaclCorePropertyShapeStatic.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
+            objectSet: $objectSet,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
@@ -712,10 +978,10 @@ export var ShaclCorePropertyShapeStatic;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclCorePropertyShape";
-        const _defaultValueEither = $resource
-            .values(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], { unique: true })
-            .head()
-            .chain((value) => purify.Either.of(value.toTerm()).chain((term) => {
+        const _defaultValueEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => purify.Either.of(value.toTerm()).chain((term) => {
             switch (term.termType) {
                 case "Literal":
                 case "NamedNode":
@@ -728,101 +994,168 @@ export var ShaclCorePropertyShapeStatic;
                         predicate: ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_defaultValueEither.isLeft()) {
             return _defaultValueEither;
         }
         const defaultValue = _defaultValueEither.unsafeCoerce();
-        const _descriptionsEither = purify.Either.sequence($resource
-            .values(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _descriptionsEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_descriptionsEither.isLeft()) {
             return _descriptionsEither;
         }
         const descriptions = _descriptionsEither.unsafeCoerce();
-        const _groupsEither = purify.Either.sequence($resource
-            .values(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier())));
+        const _groupsEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCorePropertyShapeStatic.$properties.groups["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_groupsEither.isLeft()) {
             return _groupsEither;
         }
         const groups = _groupsEither.unsafeCoerce();
-        const _namesEither = purify.Either.sequence($resource
-            .values(ShaclCorePropertyShapeStatic.$properties.names["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _namesEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.names["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCorePropertyShapeStatic.$properties.names["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_namesEither.isLeft()) {
             return _namesEither;
         }
         const names = _namesEither.unsafeCoerce();
-        const _orderEither = $resource
-            .values(ShaclCorePropertyShapeStatic.$properties.order["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toNumber())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _orderEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.order["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toNumber()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclCorePropertyShapeStatic.$properties.order["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_orderEither.isLeft()) {
             return _orderEither;
         }
         const order = _orderEither.unsafeCoerce();
-        const _pathEither = $resource
-            .values(ShaclCorePropertyShapeStatic.$properties.path["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toResource())
-            .chain((_resource) => PropertyPath.$fromRdf({
+        const _pathEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.path["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toResource().chain((resource) => PropertyPath.$fromRdf(resource, {
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
-            resource: _resource,
-        }));
+            objectSet: $objectSet,
+        }))))
+            .chain((values) => values.head());
         if (_pathEither.isLeft()) {
             return _pathEither;
         }
         const path = _pathEither.unsafeCoerce();
-        const _uniqueLangEither = $resource
-            .values(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _uniqueLangEither = purify.Either.of($resource.values(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_uniqueLangEither.isLeft()) {
             return _uniqueLangEither;
         }
@@ -841,32 +1174,34 @@ export var ShaclCorePropertyShapeStatic;
         });
     }
     ShaclCorePropertyShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        const { ignoreRdfType: _, ...otherParameters } = parameters;
-        return ShaclmatePropertyShape.$fromRdf(otherParameters).altLazy(() => ShaclCorePropertyShapeStatic.$propertiesFromRdf(parameters));
-    }
-    ShaclCorePropertyShapeStatic.$fromRdf = $fromRdf;
-    function $toRdf(_shaclCorePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCorePropertyShape, {
+    function $toRdf(_shaclCorePropertyShape, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCorePropertyShape, {
             ignoreRdfType: true,
             mutateGraph,
             resourceSet,
         });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCorePropertyShape"));
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
-        }
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.order["identifier"], _shaclCorePropertyShape.order);
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCorePropertyShape"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
+        }
+        resource.add(ShaclCorePropertyShapeStatic.$properties.defaultValue["identifier"], _shaclCorePropertyShape.defaultValue);
+        resource.add(ShaclCorePropertyShapeStatic.$properties.descriptions["identifier"], _shaclCorePropertyShape.descriptions.map((item) => item));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.groups["identifier"], _shaclCorePropertyShape.groups.map((item) => item));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.names["identifier"], _shaclCorePropertyShape.names.map((item) => item));
+        resource.add(ShaclCorePropertyShapeStatic.$properties.order["identifier"], _shaclCorePropertyShape.order);
+        resource.add(ShaclCorePropertyShapeStatic.$properties.path["identifier"], PropertyPath.$toRdf(_shaclCorePropertyShape.path, {
             mutateGraph: mutateGraph,
             resourceSet: resourceSet,
         }));
-        _resource.add(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
-        return _resource;
+        resource.add(ShaclCorePropertyShapeStatic.$properties.uniqueLang["identifier"], _shaclCorePropertyShape.uniqueLang);
+        return resource;
     }
     ShaclCorePropertyShapeStatic.$toRdf = $toRdf;
     ShaclCorePropertyShapeStatic.$properties = {
@@ -898,13 +1233,28 @@ export var ShaclmatePropertyShape;
 (function (ShaclmatePropertyShape) {
     ShaclmatePropertyShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
     ShaclmatePropertyShape.$Identifier = ShaclCorePropertyShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmatePropertyShape.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        });
+    }
+    ShaclmatePropertyShape.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = ShaclCorePropertyShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
+            objectSet: $objectSet,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
@@ -919,58 +1269,64 @@ export var ShaclmatePropertyShape;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclmatePropertyShape";
-        const _lazyEither = $resource
-            .values(ShaclmatePropertyShape.$properties.lazy["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _lazyEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.lazy["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmatePropertyShape.$properties.lazy["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_lazyEither.isLeft()) {
             return _lazyEither;
         }
         const lazy = _lazyEither.unsafeCoerce();
-        const _mutableEither = $resource
-            .values(ShaclmatePropertyShape.$properties.mutable["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _mutableEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.mutable["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.mutable["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_mutableEither.isLeft()) {
             return _mutableEither;
         }
         const mutable = _mutableEither.unsafeCoerce();
-        const _nameEither = $resource
-            .values(ShaclmatePropertyShape.$properties.name["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toString())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _nameEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.name["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.name["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_nameEither.isLeft()) {
             return _nameEither;
         }
         const name = _nameEither.unsafeCoerce();
-        const _stubEither = $resource
-            .values(ShaclmatePropertyShape.$properties.stub["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIdentifier())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _stubEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.stub["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmatePropertyShape.$properties.stub["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_stubEither.isLeft()) {
             return _stubEither;
         }
         const stub = _stubEither.unsafeCoerce();
-        const _visibilityEither = $resource
-            .values(ShaclmatePropertyShape.$properties.visibility["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _visibilityEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.visibility["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_Visibility_Private":
                     return purify.Either.of(iri);
@@ -986,23 +1342,29 @@ export var ShaclmatePropertyShape;
                         predicate: ShaclmatePropertyShape.$properties.visibility["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmatePropertyShape.$properties.visibility["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_visibilityEither.isLeft()) {
             return _visibilityEither;
         }
         const visibility = _visibilityEither.unsafeCoerce();
-        const _widenEither = $resource
-            .values(ShaclmatePropertyShape.$properties.widen["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _widenEither = purify.Either.of($resource.values(ShaclmatePropertyShape.$properties.widen["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmatePropertyShape.$properties.widen["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_widenEither.isLeft()) {
             return _widenEither;
         }
@@ -1020,22 +1382,25 @@ export var ShaclmatePropertyShape;
         });
     }
     ShaclmatePropertyShape.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        return ShaclmatePropertyShape.$propertiesFromRdf(parameters);
-    }
-    ShaclmatePropertyShape.$fromRdf = $fromRdf;
-    function $toRdf(_shaclmatePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = ShaclCorePropertyShapeStatic.$toRdf(_shaclmatePropertyShape, { ignoreRdfType: true, mutateGraph, resourceSet });
+    function $toRdf(_shaclmatePropertyShape, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = ShaclCorePropertyShapeStatic.$toRdf(_shaclmatePropertyShape, { ignoreRdfType: true, mutateGraph, resourceSet });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"));
         }
-        _resource.add(ShaclmatePropertyShape.$properties.lazy["identifier"], _shaclmatePropertyShape.lazy);
-        _resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmatePropertyShape.mutable);
-        _resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmatePropertyShape.name);
-        _resource.add(ShaclmatePropertyShape.$properties.stub["identifier"], _shaclmatePropertyShape.stub);
-        _resource.add(ShaclmatePropertyShape.$properties.visibility["identifier"], _shaclmatePropertyShape.visibility);
-        _resource.add(ShaclmatePropertyShape.$properties.widen["identifier"], _shaclmatePropertyShape.widen);
-        return _resource;
+        resource.add(ShaclmatePropertyShape.$properties.lazy["identifier"], _shaclmatePropertyShape.lazy);
+        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmatePropertyShape.mutable);
+        resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmatePropertyShape.name);
+        resource.add(ShaclmatePropertyShape.$properties.stub["identifier"], _shaclmatePropertyShape.stub);
+        resource.add(ShaclmatePropertyShape.$properties.visibility["identifier"], _shaclmatePropertyShape.visibility);
+        resource.add(ShaclmatePropertyShape.$properties.widen["identifier"], _shaclmatePropertyShape.widen);
+        return resource;
     }
     ShaclmatePropertyShape.$toRdf = $toRdf;
     ShaclmatePropertyShape.$properties = {
@@ -1074,7 +1439,25 @@ export var OwlOntologyStatic;
         $Identifier.fromString = fromString;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = OwlOntologyStatic.$Identifier || (OwlOntologyStatic.$Identifier = {}));
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmateOntology.$fromRdf(resource, {
+            ...context,
+            ignoreRdfType: false,
+            objectSet,
+        }).altLazy(() => OwlOntologyStatic.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        }));
+    }
+    OwlOntologyStatic.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         if (!$ignoreRdfType && !$resource.isInstanceOf(OwlOntologyStatic.$fromRdfType)) {
@@ -1085,23 +1468,51 @@ export var OwlOntologyStatic;
         }
         const $identifier = $resource.identifier;
         const $type = "OwlOntology";
-        const _labelsEither = purify.Either.sequence($resource
-            .values(OwlOntologyStatic.$properties.labels["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _labelsEither = purify.Either.of($resource.values(OwlOntologyStatic.$properties.labels["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: OwlOntologyStatic.$properties.labels["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
@@ -1109,21 +1520,23 @@ export var OwlOntologyStatic;
         return purify.Either.of({ $identifier, $type, labels });
     }
     OwlOntologyStatic.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        const { ignoreRdfType: _, ...otherParameters } = parameters;
-        return ShaclmateOntology.$fromRdf(otherParameters).altLazy(() => OwlOntologyStatic.$propertiesFromRdf(parameters));
-    }
-    OwlOntologyStatic.$fromRdf = $fromRdf;
-    function $toRdf(_owlOntology, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = resourceSet.mutableResource(_owlOntology.$identifier, {
+    function $toRdf(_owlOntology, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = resourceSet.mutableResource(_owlOntology.$identifier, {
             mutateGraph,
         });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#OwlOntology"));
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#OwlOntology"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
         }
-        _resource.add(OwlOntologyStatic.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
-        return _resource;
+        resource.add(OwlOntologyStatic.$properties.labels["identifier"], _owlOntology.labels.map((item) => item));
+        return resource;
     }
     OwlOntologyStatic.$toRdf = $toRdf;
     OwlOntologyStatic.$properties = {
@@ -1136,13 +1549,28 @@ export var ShaclmateOntology;
 (function (ShaclmateOntology) {
     ShaclmateOntology.$fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
     ShaclmateOntology.$Identifier = OwlOntologyStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmateOntology.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        });
+    }
+    ShaclmateOntology.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = OwlOntologyStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
+            objectSet: $objectSet,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
@@ -1157,12 +1585,10 @@ export var ShaclmateOntology;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclmateOntology";
-        const _tsFeatureExcludesEither = purify.Either.sequence($resource
-            .values(ShaclmateOntology.$properties.tsFeatureExcludes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _tsFeatureExcludesEither = purify.Either.of($resource.values(ShaclmateOntology.$properties.tsFeatureExcludes["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
                     return purify.Either.of(iri);
@@ -1192,17 +1618,22 @@ export var ShaclmateOntology;
                         predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
                     }));
             }
-        }))));
+        })))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsFeatureExcludesEither.isLeft()) {
             return _tsFeatureExcludesEither;
         }
         const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
-        const _tsFeatureIncludesEither = purify.Either.sequence($resource
-            .values(ShaclmateOntology.$properties.tsFeatureIncludes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _tsFeatureIncludesEither = purify.Either.of($resource.values(ShaclmateOntology.$properties.tsFeatureIncludes["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
                     return purify.Either.of(iri);
@@ -1232,27 +1663,35 @@ export var ShaclmateOntology;
                         predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
                     }));
             }
-        }))));
+        })))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsFeatureIncludesEither.isLeft()) {
             return _tsFeatureIncludesEither;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
-        const _tsImportsEither = purify.Either.sequence($resource
-            .values(ShaclmateOntology.$properties.tsImports["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toString())));
+        const _tsImportsEither = purify.Either.of($resource.values(ShaclmateOntology.$properties.tsImports["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsImports["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsImportsEither.isLeft()) {
             return _tsImportsEither;
         }
         const tsImports = _tsImportsEither.unsafeCoerce();
-        const _tsObjectDeclarationTypeEither = $resource
-            .values(ShaclmateOntology.$properties.tsObjectDeclarationType["identifier"], {
+        const _tsObjectDeclarationTypeEither = purify.Either.of($resource.values(ShaclmateOntology.$properties.tsObjectDeclarationType["identifier"], {
             unique: true,
-        })
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return purify.Either.of(iri);
@@ -1266,11 +1705,15 @@ export var ShaclmateOntology;
                         predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_tsObjectDeclarationTypeEither.isLeft()) {
             return _tsObjectDeclarationTypeEither;
         }
@@ -1286,24 +1729,27 @@ export var ShaclmateOntology;
         });
     }
     ShaclmateOntology.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        return ShaclmateOntology.$propertiesFromRdf(parameters);
-    }
-    ShaclmateOntology.$fromRdf = $fromRdf;
-    function $toRdf(_shaclmateOntology, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = OwlOntologyStatic.$toRdf(_shaclmateOntology, {
+    function $toRdf(_shaclmateOntology, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = OwlOntologyStatic.$toRdf(_shaclmateOntology, {
             ignoreRdfType: true,
             mutateGraph,
             resourceSet,
         });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"));
         }
-        _resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateOntology.tsFeatureExcludes.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateOntology.tsFeatureIncludes.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateOntology.tsImports.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateOntology.tsObjectDeclarationType);
-        return _resource;
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateOntology.tsFeatureExcludes.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateOntology.tsFeatureIncludes.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateOntology.tsImports.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateOntology.tsObjectDeclarationType);
+        return resource;
     }
     ShaclmateOntology.$toRdf = $toRdf;
     ShaclmateOntology.$properties = {
@@ -1326,13 +1772,32 @@ export var ShaclCoreNodeShapeStatic;
 (function (ShaclCoreNodeShapeStatic) {
     ShaclCoreNodeShapeStatic.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     ShaclCoreNodeShapeStatic.$Identifier = BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmateNodeShape.$fromRdf(resource, {
+            ...context,
+            ignoreRdfType: false,
+            objectSet,
+        }).altLazy(() => ShaclCoreNodeShapeStatic.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        }));
+    }
+    ShaclCoreNodeShapeStatic.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = BaseShaclCoreShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
+            objectSet: $objectSet,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
@@ -1347,40 +1812,51 @@ export var ShaclCoreNodeShapeStatic;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclCoreNodeShape";
-        const _closedEither = $resource
-            .values(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _closedEither = purify.Either.of($resource.values(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclCoreNodeShapeStatic.$properties.closed["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_closedEither.isLeft()) {
             return _closedEither;
         }
         const closed = _closedEither.unsafeCoerce();
-        const _ignoredPropertiesEither = $resource
-            .values(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toList())
-            .chain((values) => purify.Either.sequence(values.map((value) => value
-            .toValues()
-            .head()
-            .chain((value) => value.toIri()))))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _ignoredPropertiesEither = purify.Either.of($resource.values(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toList()))
+            .chain((valueLists) => valueLists.chainMap((valueList) => purify.Either.of(rdfjsResource.Resource.Values.fromArray({
+            objects: valueList,
+            predicate: ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"],
+            subject: $resource,
+        })).chain((values) => values.chainMap((value) => value.toIri()))))
+            .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_ignoredPropertiesEither.isLeft()) {
             return _ignoredPropertiesEither;
         }
         const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
-        const _propertiesEither = purify.Either.sequence($resource
-            .values(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIdentifier())));
+        const _propertiesEither = purify.Either.of($resource.values(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIdentifier()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCoreNodeShapeStatic.$properties.properties["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_propertiesEither.isLeft()) {
             return _propertiesEither;
         }
@@ -1395,23 +1871,25 @@ export var ShaclCoreNodeShapeStatic;
         });
     }
     ShaclCoreNodeShapeStatic.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        const { ignoreRdfType: _, ...otherParameters } = parameters;
-        return ShaclmateNodeShape.$fromRdf(otherParameters).altLazy(() => ShaclCoreNodeShapeStatic.$propertiesFromRdf(parameters));
-    }
-    ShaclCoreNodeShapeStatic.$fromRdf = $fromRdf;
-    function $toRdf(_shaclCoreNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCoreNodeShape, {
+    function $toRdf(_shaclCoreNodeShape, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = BaseShaclCoreShapeStatic.$toRdf(_shaclCoreNodeShape, {
             ignoreRdfType: true,
             mutateGraph,
             resourceSet,
         });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCoreNodeShape"));
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://purl.org/shaclmate/ontology#ShaclCoreNodeShape"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
         }
-        _resource.add(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
-        _resource.add(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], _shaclCoreNodeShape.ignoredProperties.map((value) => value.length > 0
+        resource.add(ShaclCoreNodeShapeStatic.$properties.closed["identifier"], _shaclCoreNodeShape.closed);
+        resource.add(ShaclCoreNodeShapeStatic.$properties.ignoredProperties["identifier"], _shaclCoreNodeShape.ignoredProperties.map((value) => value.length > 0
             ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                 if (itemIndex === 0) {
                     currentSubListResource = listResource;
@@ -1431,8 +1909,8 @@ export var ShaclCoreNodeShapeStatic;
                 listResource: resourceSet.mutableResource(dataFactory.blankNode(), { mutateGraph }),
             }).listResource.identifier
             : $RdfVocabularies.rdf.nil));
-        _resource.add(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], _shaclCoreNodeShape.properties.map((item) => item));
-        return _resource;
+        resource.add(ShaclCoreNodeShapeStatic.$properties.properties["identifier"], _shaclCoreNodeShape.properties.map((item) => item));
+        return resource;
     }
     ShaclCoreNodeShapeStatic.$toRdf = $toRdf;
     ShaclCoreNodeShapeStatic.$properties = {
@@ -1452,13 +1930,28 @@ export var ShaclmateNodeShape;
 (function (ShaclmateNodeShape) {
     ShaclmateNodeShape.$fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
     ShaclmateNodeShape.$Identifier = ShaclCoreNodeShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclmateNodeShape.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        });
+    }
+    ShaclmateNodeShape.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         const $super0Either = ShaclCoreNodeShapeStatic.$propertiesFromRdf({
             ...$context,
             ignoreRdfType: true,
             languageIn: $languageIn,
+            objectSet: $objectSet,
             resource: $resource,
         });
         if ($super0Either.isLeft()) {
@@ -1473,60 +1966,66 @@ export var ShaclmateNodeShape;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclmateNodeShape";
-        const _abstractEither = $resource
-            .values(ShaclmateNodeShape.$properties.abstract["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _abstractEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.abstract["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.abstract["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_abstractEither.isLeft()) {
             return _abstractEither;
         }
         const abstract = _abstractEither.unsafeCoerce();
-        const _export_Either = $resource
-            .values(ShaclmateNodeShape.$properties.export_["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _export_Either = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.export_["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.export_["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_export_Either.isLeft()) {
             return _export_Either;
         }
         const export_ = _export_Either.unsafeCoerce();
-        const _externEither = $resource
-            .values(ShaclmateNodeShape.$properties.extern["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _externEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.extern["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.extern["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_externEither.isLeft()) {
             return _externEither;
         }
         const extern = _externEither.unsafeCoerce();
-        const _fromRdfTypeEither = $resource
-            .values(ShaclmateNodeShape.$properties.fromRdfType["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIri())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _fromRdfTypeEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.fromRdfType["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.fromRdfType["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_fromRdfTypeEither.isLeft()) {
             return _fromRdfTypeEither;
         }
         const fromRdfType = _fromRdfTypeEither.unsafeCoerce();
-        const _identifierMintingStrategyEither = $resource
-            .values(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], {
+        const _identifierMintingStrategyEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], {
             unique: true,
-        })
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
                     return purify.Either.of(iri);
@@ -1542,67 +2041,80 @@ export var ShaclmateNodeShape;
                         predicate: ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_identifierMintingStrategyEither.isLeft()) {
             return _identifierMintingStrategyEither;
         }
         const identifierMintingStrategy = _identifierMintingStrategyEither.unsafeCoerce();
-        const _mutableEither = $resource
-            .values(ShaclmateNodeShape.$properties.mutable["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toBoolean())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _mutableEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.mutable["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toBoolean()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.mutable["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_mutableEither.isLeft()) {
             return _mutableEither;
         }
         const mutable = _mutableEither.unsafeCoerce();
-        const _nameEither = $resource
-            .values(ShaclmateNodeShape.$properties.name["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toString())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _nameEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.name["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.name["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_nameEither.isLeft()) {
             return _nameEither;
         }
         const name = _nameEither.unsafeCoerce();
-        const _rdfTypeEither = $resource
-            .values(ShaclmateNodeShape.$properties.rdfType["identifier"], { unique: true })
-            .head()
-            .chain((value) => value.toIri())
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        const _rdfTypeEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.rdfType["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toIri()))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.rdfType["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_rdfTypeEither.isLeft()) {
             return _rdfTypeEither;
         }
         const rdfType = _rdfTypeEither.unsafeCoerce();
-        const _toRdfTypesEither = purify.Either.sequence($resource
-            .values(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri())));
+        const _toRdfTypesEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.toRdfTypes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_toRdfTypesEither.isLeft()) {
             return _toRdfTypesEither;
         }
         const toRdfTypes = _toRdfTypesEither.unsafeCoerce();
-        const _tsFeatureExcludesEither = purify.Either.sequence($resource
-            .values(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _tsFeatureExcludesEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
                     return purify.Either.of(iri);
@@ -1632,17 +2144,22 @@ export var ShaclmateNodeShape;
                         predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
                     }));
             }
-        }))));
+        })))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsFeatureExcludesEither.isLeft()) {
             return _tsFeatureExcludesEither;
         }
         const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
-        const _tsFeatureIncludesEither = purify.Either.sequence($resource
-            .values(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        const _tsFeatureIncludesEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], {
+            unique: true,
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
                     return purify.Either.of(iri);
@@ -1672,27 +2189,35 @@ export var ShaclmateNodeShape;
                         predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
                     }));
             }
-        }))));
+        })))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsFeatureIncludesEither.isLeft()) {
             return _tsFeatureIncludesEither;
         }
         const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
-        const _tsImportsEither = purify.Either.sequence($resource
-            .values(ShaclmateNodeShape.$properties.tsImports["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .head()
-            .chain((value) => value.toString())));
+        const _tsImportsEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.tsImports["identifier"], { unique: true }))
+            .chain((values) => values.chainMap((value) => value.toString()))
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclmateNodeShape.$properties.tsImports["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_tsImportsEither.isLeft()) {
             return _tsImportsEither;
         }
         const tsImports = _tsImportsEither.unsafeCoerce();
-        const _tsObjectDeclarationTypeEither = $resource
-            .values(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], {
+        const _tsObjectDeclarationTypeEither = purify.Either.of($resource.values(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], {
             unique: true,
-        })
-            .head()
-            .chain((value) => value.toIri().chain((iri) => {
+        }))
+            .chain((values) => values.chainMap((value) => value.toIri().chain((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return purify.Either.of(iri);
@@ -1706,11 +2231,15 @@ export var ShaclmateNodeShape;
                         predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
                     }));
             }
-        }))
-            .map((value) => purify.Maybe.of(value))
-            .chainLeft((error) => error instanceof rdfjsResource.Resource.MissingValueError
-            ? purify.Right(purify.Maybe.empty())
-            : purify.Left(error));
+        })))
+            .map((values) => values.length > 0
+            ? values.map((value) => purify.Maybe.of(value))
+            : rdfjsResource.Resource.Values.fromValue({
+                object: purify.Maybe.empty(),
+                predicate: ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"],
+                subject: $resource,
+            }))
+            .chain((values) => values.head());
         if (_tsObjectDeclarationTypeEither.isLeft()) {
             return _tsObjectDeclarationTypeEither;
         }
@@ -1735,33 +2264,36 @@ export var ShaclmateNodeShape;
         });
     }
     ShaclmateNodeShape.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        return ShaclmateNodeShape.$propertiesFromRdf(parameters);
-    }
-    ShaclmateNodeShape.$fromRdf = $fromRdf;
-    function $toRdf(_shaclmateNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = ShaclCoreNodeShapeStatic.$toRdf(_shaclmateNodeShape, {
+    function $toRdf(_shaclmateNodeShape, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = ShaclCoreNodeShapeStatic.$toRdf(_shaclmateNodeShape, {
             ignoreRdfType: true,
             mutateGraph,
             resourceSet,
         });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
-        }
-        _resource.add(ShaclmateNodeShape.$properties.abstract["identifier"], _shaclmateNodeShape.abstract);
-        _resource.add(ShaclmateNodeShape.$properties.export_["identifier"], _shaclmateNodeShape.export_);
-        _resource.add(ShaclmateNodeShape.$properties.extern["identifier"], _shaclmateNodeShape.extern);
-        _resource.add(ShaclmateNodeShape.$properties.fromRdfType["identifier"], _shaclmateNodeShape.fromRdfType);
-        _resource.add(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], _shaclmateNodeShape.identifierMintingStrategy);
-        _resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmateNodeShape.mutable);
-        _resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmateNodeShape.name);
-        _resource.add(ShaclmateNodeShape.$properties.rdfType["identifier"], _shaclmateNodeShape.rdfType);
-        _resource.add(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], _shaclmateNodeShape.toRdfTypes.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateNodeShape.tsFeatureExcludes.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateNodeShape.tsFeatureIncludes.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateNodeShape.tsImports.map((item) => item));
-        _resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateNodeShape.tsObjectDeclarationType);
-        return _resource;
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"));
+        }
+        resource.add(ShaclmateNodeShape.$properties.abstract["identifier"], _shaclmateNodeShape.abstract);
+        resource.add(ShaclmateNodeShape.$properties.export_["identifier"], _shaclmateNodeShape.export_);
+        resource.add(ShaclmateNodeShape.$properties.extern["identifier"], _shaclmateNodeShape.extern);
+        resource.add(ShaclmateNodeShape.$properties.fromRdfType["identifier"], _shaclmateNodeShape.fromRdfType);
+        resource.add(ShaclmateNodeShape.$properties.identifierMintingStrategy["identifier"], _shaclmateNodeShape.identifierMintingStrategy);
+        resource.add(ShaclmateNodeShape.$properties.mutable["identifier"], _shaclmateNodeShape.mutable);
+        resource.add(ShaclmateNodeShape.$properties.name["identifier"], _shaclmateNodeShape.name);
+        resource.add(ShaclmateNodeShape.$properties.rdfType["identifier"], _shaclmateNodeShape.rdfType);
+        resource.add(ShaclmateNodeShape.$properties.toRdfTypes["identifier"], _shaclmateNodeShape.toRdfTypes.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureExcludes["identifier"], _shaclmateNodeShape.tsFeatureExcludes.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsFeatureIncludes["identifier"], _shaclmateNodeShape.tsFeatureIncludes.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsImports["identifier"], _shaclmateNodeShape.tsImports.map((item) => item));
+        resource.add(ShaclmateNodeShape.$properties.tsObjectDeclarationType["identifier"], _shaclmateNodeShape.tsObjectDeclarationType);
+        return resource;
     }
     ShaclmateNodeShape.$toRdf = $toRdf;
     ShaclmateNodeShape.$properties = {
@@ -1821,7 +2353,21 @@ export var ShaclCorePropertyGroup;
         $Identifier.fromString = fromString;
         $Identifier.toString = rdfjsResource.Resource.Identifier.toString;
     })($Identifier = ShaclCorePropertyGroup.$Identifier || (ShaclCorePropertyGroup.$Identifier = {}));
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, 
+    function $fromRdf(resource, options) {
+        let { ignoreRdfType = false, languageIn, objectSet, ...context } = options ?? {};
+        if (!objectSet) {
+            objectSet = new $RdfjsDatasetObjectSet({ dataset: resource.dataset });
+        }
+        return ShaclCorePropertyGroup.$propertiesFromRdf({
+            ...context,
+            ignoreRdfType,
+            languageIn,
+            objectSet,
+            resource,
+        });
+    }
+    ShaclCorePropertyGroup.$fromRdf = $fromRdf;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, 
     // @ts-ignore
     ...$context }) {
         if (!$ignoreRdfType && !$resource.isInstanceOf(ShaclCorePropertyGroup.$fromRdfType)) {
@@ -1832,44 +2378,100 @@ export var ShaclCorePropertyGroup;
         }
         const $identifier = $resource.identifier;
         const $type = "ShaclCorePropertyGroup";
-        const _commentsEither = purify.Either.sequence($resource
-            .values(ShaclCorePropertyGroup.$properties.comments["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _commentsEither = purify.Either.of($resource.values(ShaclCorePropertyGroup.$properties.comments["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCorePropertyGroup.$properties.comments["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_commentsEither.isLeft()) {
             return _commentsEither;
         }
         const comments = _commentsEither.unsafeCoerce();
-        const _labelsEither = purify.Either.sequence($resource
-            .values(ShaclCorePropertyGroup.$properties.labels["identifier"], { unique: true })
-            .map((item) => item
-            .toValues()
-            .filter((_value) => {
-            const _languageInOrDefault = $languageIn ?? [];
-            if (_languageInOrDefault.length === 0) {
-                return true;
-            }
-            const _valueLiteral = _value.toLiteral().toMaybe().extract();
-            if (typeof _valueLiteral === "undefined") {
-                return false;
-            }
-            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        const _labelsEither = purify.Either.of($resource.values(ShaclCorePropertyGroup.$properties.labels["identifier"], { unique: true }))
+            .chain((values) => {
+            const literalValuesEither = values.chainMap((value) => value.toLiteral());
+            if (literalValuesEither.isLeft()) {
+                return literalValuesEither;
+            }
+            const literalValues = literalValuesEither.unsafeCoerce();
+            const nonUniqueLanguageIn = $languageIn ?? [];
+            if (nonUniqueLanguageIn.length === 0) {
+                return purify.Either.of(literalValues);
+            }
+            let uniqueLanguageIn;
+            if (nonUniqueLanguageIn.length === 1) {
+                uniqueLanguageIn = [nonUniqueLanguageIn[0]];
+            }
+            else {
+                uniqueLanguageIn = [];
+                for (const languageIn of nonUniqueLanguageIn) {
+                    if (uniqueLanguageIn.indexOf(languageIn) === -1) {
+                        uniqueLanguageIn.push(languageIn);
+                    }
+                }
+            }
+            // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
+            // Within a languageIn the literals may be in any order.
+            let filteredLiteralValues;
+            for (const languageIn of uniqueLanguageIn) {
+                if (!filteredLiteralValues) {
+                    filteredLiteralValues = literalValues.filter((value) => value.language === languageIn);
+                }
+                else {
+                    filteredLiteralValues = filteredLiteralValues.concat(...literalValues
+                        .filter((value) => value.language === languageIn)
+                        .toArray());
+                }
+            }
+            return purify.Either.of(filteredLiteralValues);
         })
-            .head()
-            .chain((value) => value.toLiteral())));
+            .map((values) => values.toArray())
+            .map((valuesArray) => rdfjsResource.Resource.Values.fromValue({
+            object: valuesArray,
+            predicate: ShaclCorePropertyGroup.$properties.labels["identifier"],
+            subject: $resource,
+        }))
+            .chain((values) => values.head());
         if (_labelsEither.isLeft()) {
             return _labelsEither;
         }
@@ -1877,18 +2479,21 @@ export var ShaclCorePropertyGroup;
         return purify.Either.of({ $identifier, $type, comments, labels });
     }
     ShaclCorePropertyGroup.$propertiesFromRdf = $propertiesFromRdf;
-    function $fromRdf(parameters) {
-        return ShaclCorePropertyGroup.$propertiesFromRdf(parameters);
-    }
-    ShaclCorePropertyGroup.$fromRdf = $fromRdf;
-    function $toRdf(_shaclCorePropertyGroup, { ignoreRdfType, mutateGraph, resourceSet, }) {
-        const _resource = resourceSet.mutableResource(_shaclCorePropertyGroup.$identifier, { mutateGraph });
+    function $toRdf(_shaclCorePropertyGroup, options) {
+        const ignoreRdfType = !!options?.ignoreRdfType;
+        const mutateGraph = options?.mutateGraph;
+        const resourceSet = options?.resourceSet ??
+            new rdfjsResource.MutableResourceSet({
+                dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        const resource = resourceSet.mutableResource(_shaclCorePropertyGroup.$identifier, { mutateGraph });
         if (!ignoreRdfType) {
-            _resource.add($RdfVocabularies.rdf.type, _resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"));
+            resource.add($RdfVocabularies.rdf.type, resource.dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"));
         }
-        _resource.add(ShaclCorePropertyGroup.$properties.comments["identifier"], _shaclCorePropertyGroup.comments.map((item) => item));
-        _resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], _shaclCorePropertyGroup.labels.map((item) => item));
-        return _resource;
+        resource.add(ShaclCorePropertyGroup.$properties.comments["identifier"], _shaclCorePropertyGroup.comments.map((item) => item));
+        resource.add(ShaclCorePropertyGroup.$properties.labels["identifier"], _shaclCorePropertyGroup.labels.map((item) => item));
+        return resource;
     }
     ShaclCorePropertyGroup.$toRdf = $toRdf;
     ShaclCorePropertyGroup.$properties = {
@@ -1902,13 +2507,13 @@ export var ShaclCorePropertyGroup;
 })(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
-    function $fromRdf({ ignoreRdfType, resource, ...context }) {
-        return ShaclCoreNodeShapeStatic.$fromRdf({
-            ...context,
-            resource,
-        }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf({
-            ...context,
-            resource,
+    function $fromRdf(resource, options) {
+        return ShaclCoreNodeShapeStatic.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
         }));
     }
     ShaclCoreShape.$fromRdf = $fromRdf;
@@ -1940,10 +2545,13 @@ export var ShaclCoreShape;
 })(ShaclCoreShape || (ShaclCoreShape = {}));
 export var ShaclmateShape;
 (function (ShaclmateShape) {
-    function $fromRdf({ ignoreRdfType, resource, ...context }) {
-        return ShaclmateNodeShape.$fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf({
-            ...context,
-            resource,
+    function $fromRdf(resource, options) {
+        return ShaclmateNodeShape.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
+        }).altLazy(() => ShaclCorePropertyShapeStatic.$fromRdf(resource, {
+            ...options,
+            ignoreRdfType: false,
         }));
     }
     ShaclmateShape.$fromRdf = $fromRdf;
@@ -2253,9 +2861,7 @@ export class $RdfjsDatasetObjectSet {
             }
             const objects = [];
             for (const identifier of identifiers) {
-                const either = objectType.$fromRdf({
-                    resource: this.resourceSet.resource(identifier),
-                });
+                const either = objectType.$fromRdf(this.resourceSet.resource(identifier), { objectSet: this });
                 if (either.isLeft()) {
                     return either;
                 }
@@ -2274,7 +2880,7 @@ export class $RdfjsDatasetObjectSet {
         const objects = [];
         let objectI = 0;
         for (const resource of resources) {
-            const either = objectType.$fromRdf({ resource });
+            const either = objectType.$fromRdf(resource, { objectSet: this });
             if (either.isLeft()) {
                 return either;
             }
@@ -2335,7 +2941,7 @@ export class $RdfjsDatasetObjectSet {
                 const resource = this.resourceSet.resource(identifier);
                 const lefts = [];
                 for (const objectType of objectTypes) {
-                    const either = objectType.$fromRdf({ resource });
+                    const either = objectType.$fromRdf(resource, { objectSet: this });
                     if (either.isRight()) {
                         objects.push(either.unsafeCoerce());
                         break;
@@ -2363,7 +2969,7 @@ export class $RdfjsDatasetObjectSet {
         let objectI = 0;
         const objects = [];
         for (const { objectType, resource } of resources) {
-            const either = objectType.$fromRdf({ resource });
+            const either = objectType.$fromRdf(resource, { objectSet: this });
             if (either.isLeft()) {
                 return either;
             }