@shaclmate/compiler 4.0.25 → 4.0.27

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -11,13 +11,13 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain4(Either.sequence(shape.and
+        return Eithers.chain3(Either.sequence(shape.and
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.nodes.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), shape.$type === "NodeShape"
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), shape.$type === "NodeShape"
             ? nodeShapeTsFeatures.call(this, shape)
             : Either.of(new Set()), Either.sequence(shape.xone
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, tsFeatures, xoneConstraintShapes]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.
@@ -26,10 +26,6 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 memberShapes = andConstraintShapes;
                 compoundTypeKind = "IntersectionType";
             }
-            else if (nodeConstraintShapes.length > 0) {
-                memberShapes = nodeConstraintShapes;
-                compoundTypeKind = "IntersectionType";
-            }
             else if (xoneConstraintShapes.length > 0) {
                 memberShapes = xoneConstraintShapes;
                 compoundTypeKind = "UnionType";

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.d.ts

@@ -3,5 +3,5 @@ import * as ast from "../ast/index.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import { ShapeStack } from "./ShapeStack.js";
-export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ObjectType>>;
+export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
 //# sourceMappingURL=transformShapeToAstObjectType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -43,6 +43,12 @@ function isObjectTypePropertyRequired(property) {
 export function transformShapeToAstObjectType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
+        if (shape.node.isJust()) {
+            return this.shapesGraph
+                .nodeShape(shape.node.unsafeCoerce())
+                .chain((nodeShape) => transformShapeToAstType.call(this, nodeShape, shapeStack))
+                .map(Maybe.of);
+        }
         if (shape.$type !== "NodeShape") {
             return Either.of(Maybe.empty());
         }

package/dist/generators/ts/TsGenerator.js

@@ -3,6 +3,7 @@ import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
 import { snippets } from "./snippets.js";
 import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
@@ -32,13 +33,20 @@ export class TsGenerator {
         }
         const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
         const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        if (namedObjectTypesToposorted.length > 0) {
-            const uberObjectUnionType = synthesizeUberObjectUnionType({
-                logger: this.logger,
-                namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
-            });
-            declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-            namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+        switch (namedObjectTypesNameSorted.length) {
+            case 0:
+                break;
+            case 1:
+                declarations.push(code `type ${syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                break;
+            default: {
+                const uberObjectUnionType = synthesizeUberObjectUnionType({
+                    logger: this.logger,
+                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                });
+                declarations = declarations.concat(uberObjectUnionType.declaration.toList());
+                namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+            }
         }
         declarations.push(...objectSetDeclarations({
             namedObjectTypes: namedObjectTypesNameSorted,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_objectSetMethodNames.js

@@ -1,9 +1,14 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function NamedObjectType_objectSetMethodNames() {
-    const prefixSingular = camelCase(this.name);
-    const thisNameParts = trainCase(this.name).split("-");
-    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
+    const prefixSingular = camelCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    });
+    const thisNameParts = trainCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    }).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });
     if (prefixPlural === prefixSingular) {
         // Happens with singular-s nouns like "series"
         prefixPlural = `${prefixPlural}s`;

package/dist/generators/ts/_snippets/snippets_compactRecord.js

@@ -6,7 +6,7 @@ export const snippets_compactRecord = conditionalOutput(`${syntheticNamePrefix}c
  */  
 function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
   return \
-    Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+    globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
       if (propertyValue !== undefined) {
         definedProperties[propertyName as KeyT] = propertyValue as ValueT;
       }

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -98,13 +98,13 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                 case "NamedObjectType": {
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.${syntheticNamePrefix}objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+  return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                 }
                 case "NamedObjectUnionType":
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.${syntheticNamePrefix}objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+  return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
@@ -116,7 +116,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
         ...(namedObjectTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -208,7 +208,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
         ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -14,6 +14,7 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
         selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
+    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }`;
     const typeParameters = {
         ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
@@ -21,13 +22,15 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
     };
     return code `\
 export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
-  protected readonly ${syntheticNamePrefix}countVariable = ${imports.dataFactory}.variable!("count");;
-  protected readonly graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  protected readonly ${syntheticNamePrefix}objectVariable = ${imports.dataFactory}.variable!("object");
-  protected readonly ${syntheticNamePrefix}sparqlGenerator = new ${imports.sparqljs}.Generator();
-
-  constructor(protected readonly ${syntheticNamePrefix}sparqlClient: { queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
-    this.graph = options?.graph;
+  readonly #countVariable = ${imports.dataFactory}.variable!("count");;
+  readonly #graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+  readonly #objectVariable = ${imports.dataFactory}.variable!("object");
+  readonly #sparqlClient: ${sparqlClientType};
+  readonly #sparqlGenerator = new ${imports.sparqljs}.Generator();
+
+  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+    this.#graph = options?.graph;
+    this.#sparqlClient = sparqlClient;
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
@@ -48,20 +51,20 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
-  return this.${syntheticNamePrefix}objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
-  return this.${syntheticNamePrefix}objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.${syntheticNamePrefix}objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
         ];
     }), { on: "\n\n" })}
 
-  protected ${syntheticNamePrefix}mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
+  #mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
     if (bindings.length === 0) {
       return ${imports.Left}(new Error("empty result rows"));
     }
@@ -82,7 +85,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return ${imports.Right}(parsedCount);
   }
 
-  protected ${syntheticNamePrefix}mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
+  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
     const identifiers: ${imports.NamedNode}[] = [];
     for (const bindings_ of bindings) {
       const identifier = bindings_[variable];
@@ -96,7 +99,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return identifiers;
   }
 
-  protected async ${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
     if (query?.identifiers) {
       return ${imports.Right}(query.identifiers);
     }
@@ -111,41 +114,41 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       offset = 0;
     }
 
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
 
     const selectQueryString = \
-      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+      this.#sparqlGenerator.stringify({
         distinct: true,
         limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
         offset,
-        order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
+        order: query?.order ? query.order(this.#objectVariable).concat() : [{ expression: this.#objectVariable }],
         prefixes: {},
         queryType: "SELECT",
         type: "query",
-        variables: [this.${syntheticNamePrefix}objectVariable],
+        variables: [this.#objectVariable],
         where: wherePatterns.concat()
       });
       
     return ${imports.EitherAsync}(async () =>
-      this.${syntheticNamePrefix}mapBindingsToIdentifiers(
-        await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-        this.${syntheticNamePrefix}objectVariable.value,
+      this.#mapBindingsToIdentifiers(
+        await this.#sparqlClient.queryBindings(selectQueryString),
+        this.#objectVariable.value,
       ) as readonly ObjectIdentifierT[],
     );  
   }
 
-  protected async ${syntheticNamePrefix}objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
+  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
     return ${imports.EitherAsync}(async ({ liftEither }) => {
-      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
+      const identifiers = await liftEither(await this.#objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
       const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
-        subject: this.${syntheticNamePrefix}objectVariable,
+        subject: this.#objectVariable,
         where: [{
           type: "values" as const,
           values: identifiers.map((identifier) => {
@@ -156,7 +159,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         }]
       });
 
-      const quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
+      const quads = await this.#sparqlClient.queryQuads(constructQueryString);
 
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
@@ -167,14 +170,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     });
   }
 
-  protected async ${syntheticNamePrefix}objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
+  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
 
     const selectQueryString = \
-      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+      this.#sparqlGenerator.stringify({
         prefixes: {},
         queryType: "SELECT",
         type: "query",
@@ -183,10 +186,10 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
             expression: {
               aggregation: "COUNT",
               distinct: true,
-              expression: this.${syntheticNamePrefix}objectVariable,
+              expression: this.#objectVariable,
               type: "aggregate",
             },
-            variable: this.${syntheticNamePrefix}countVariable,
+            variable: this.#countVariable,
           },
         ],
         where: wherePatterns.concat()
@@ -194,27 +197,27 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
     return ${imports.EitherAsync}(async ({ liftEither }) =>
       liftEither(
-        this.${syntheticNamePrefix}mapBindingsToCount(
-          await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-          this.${syntheticNamePrefix}countVariable.value,
+        this.#mapBindingsToCount(
+          await this.#sparqlClient.queryBindings(selectQueryString),
+          this.#countVariable.value,
         ),
       ),
     );
   }
 
-  protected ${syntheticNamePrefix}wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
+  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
     // Patterns should be most to least specific.
     let patterns: ${imports.sparqljs}.Pattern[] = [];
 
     if (query?.where) {
-      patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
+      patterns = patterns.concat(query.where(this.#objectVariable));
     }
 
-    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 
-    const graph = query?.graph ?? this.graph;
+    const graph = query?.graph ?? this.#graph;
     if (graph) {
       switch (graph.termType) {
         case "DefaultGraph":

package/dist/input/generated.d.ts

@@ -155,8 +155,8 @@ export interface PropertyShape {
     readonly minLength: Maybe<number>;
     readonly mutable: Maybe<boolean>;
     readonly name: Maybe<string>;
+    readonly node: Maybe<BlankNode | NamedNode>;
     readonly nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-    readonly nodes: readonly (BlankNode | NamedNode)[];
     readonly not: readonly (BlankNode | NamedNode)[];
     readonly or: Maybe<readonly (BlankNode | NamedNode)[]>;
     readonly order: Maybe<number>;
@@ -195,8 +195,8 @@ export declare namespace PropertyShape {
         readonly minLength?: Maybe<number> | number;
         readonly mutable?: Maybe<boolean> | boolean;
         readonly name?: Maybe<string> | string;
+        readonly node?: Maybe<BlankNode | NamedNode> | (BlankNode | NamedNode) | string;
         readonly nodeKind?: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">> | NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal"> | "http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal";
-        readonly nodes?: readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly not?: readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly or?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly order?: Maybe<number> | number;
@@ -240,8 +240,8 @@ export declare namespace PropertyShape {
         readonly minLength?: $MaybeFilter<$NumericFilter<number>>;
         readonly mutable?: $MaybeFilter<$BooleanFilter>;
         readonly name?: $MaybeFilter<$StringFilter>;
+        readonly node?: $MaybeFilter<$IdentifierFilter>;
         readonly nodeKind?: $MaybeFilter<$IriFilter>;
-        readonly nodes?: $CollectionFilter<$IdentifierFilter>;
         readonly not?: $CollectionFilter<$IdentifierFilter>;
         readonly or?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
         readonly order?: $MaybeFilter<$NumericFilter<number>>;
@@ -284,8 +284,8 @@ export declare namespace PropertyShape {
         minLength: Maybe<number>;
         mutable: Maybe<boolean>;
         name: Maybe<string>;
+        node: Maybe<BlankNode | NamedNode>;
         nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-        nodes: readonly (BlankNode | NamedNode)[];
         not: readonly (BlankNode | NamedNode)[];
         or: Maybe<readonly (BlankNode | NamedNode)[]>;
         order: Maybe<number>;
@@ -571,26 +571,26 @@ export declare namespace PropertyShape {
                 };
                 readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#name">;
             };
-            readonly nodeKind: {
+            readonly node: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Maybe";
                     item: () => {
-                        kind: "Iri";
-                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                        kind: "Identifier";
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
             };
-            readonly nodes: {
+            readonly nodeKind: {
                 readonly kind: "Shacl";
                 readonly type: () => {
-                    kind: "Set";
+                    kind: "Maybe";
                     item: () => {
-                        kind: "Identifier";
+                        kind: "Iri";
+                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
             };
             readonly not: {
                 readonly kind: "Shacl";
@@ -912,8 +912,8 @@ export interface NodeShape {
     readonly minInclusive: Maybe<Literal>;
     readonly minLength: Maybe<number>;
     readonly mutable: Maybe<boolean>;
+    readonly node: Maybe<BlankNode | NamedNode>;
     readonly nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-    readonly nodes: readonly (BlankNode | NamedNode)[];
     readonly not: readonly (BlankNode | NamedNode)[];
     readonly or: Maybe<readonly (BlankNode | NamedNode)[]>;
     readonly patterns: readonly string[];
@@ -956,8 +956,8 @@ export declare namespace NodeShape {
         readonly minInclusive?: Maybe<Literal> | bigint | boolean | Date | number | string | Literal;
         readonly minLength?: Maybe<number> | number;
         readonly mutable?: Maybe<boolean> | boolean;
+        readonly node?: Maybe<BlankNode | NamedNode> | (BlankNode | NamedNode) | string;
         readonly nodeKind?: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">> | NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal"> | "http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal";
-        readonly nodes?: readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly not?: readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly or?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly patterns?: readonly string[];
@@ -1005,8 +1005,8 @@ export declare namespace NodeShape {
         readonly minInclusive?: $MaybeFilter<$LiteralFilter>;
         readonly minLength?: $MaybeFilter<$NumericFilter<number>>;
         readonly mutable?: $MaybeFilter<$BooleanFilter>;
+        readonly node?: $MaybeFilter<$IdentifierFilter>;
         readonly nodeKind?: $MaybeFilter<$IriFilter>;
-        readonly nodes?: $CollectionFilter<$IdentifierFilter>;
         readonly not?: $CollectionFilter<$IdentifierFilter>;
         readonly or?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
         readonly patterns?: $CollectionFilter<$StringFilter>;
@@ -1053,8 +1053,8 @@ export declare namespace NodeShape {
         minInclusive: Maybe<Literal>;
         minLength: Maybe<number>;
         mutable: Maybe<boolean>;
+        node: Maybe<BlankNode | NamedNode>;
         nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-        nodes: readonly (BlankNode | NamedNode)[];
         not: readonly (BlankNode | NamedNode)[];
         or: Maybe<readonly (BlankNode | NamedNode)[]>;
         patterns: readonly string[];
@@ -1346,26 +1346,26 @@ export declare namespace NodeShape {
                 };
                 readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
             };
-            readonly nodeKind: {
+            readonly node: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Maybe";
                     item: () => {
-                        kind: "Iri";
-                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                        kind: "Identifier";
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
             };
-            readonly nodes: {
+            readonly nodeKind: {
                 readonly kind: "Shacl";
                 readonly type: () => {
-                    kind: "Set";
+                    kind: "Maybe";
                     item: () => {
-                        kind: "Identifier";
+                        kind: "Iri";
+                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
             };
             readonly not: {
                 readonly kind: "Shacl";
@@ -1811,26 +1811,26 @@ export declare namespace Shape {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
                         };
-                        readonly nodeKind: {
+                        readonly node: {
                             readonly kind: "Shacl";
                             readonly type: () => {
                                 kind: "Maybe";
                                 item: () => {
-                                    kind: "Iri";
-                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                    kind: "Identifier";
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
                         };
-                        readonly nodes: {
+                        readonly nodeKind: {
                             readonly kind: "Shacl";
                             readonly type: () => {
-                                kind: "Set";
+                                kind: "Maybe";
                                 item: () => {
-                                    kind: "Identifier";
+                                    kind: "Iri";
+                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
                         };
                         readonly not: {
                             readonly kind: "Shacl";
@@ -2250,26 +2250,26 @@ export declare namespace Shape {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#name">;
                         };
-                        readonly nodeKind: {
+                        readonly node: {
                             readonly kind: "Shacl";
                             readonly type: () => {
                                 kind: "Maybe";
                                 item: () => {
-                                    kind: "Iri";
-                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                    kind: "Identifier";
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
                         };
-                        readonly nodes: {
+                        readonly nodeKind: {
                             readonly kind: "Shacl";
                             readonly type: () => {
-                                kind: "Set";
+                                kind: "Maybe";
                                 item: () => {
-                                    kind: "Identifier";
+                                    kind: "Iri";
+                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
                         };
                         readonly not: {
                             readonly kind: "Shacl";
@@ -2576,26 +2576,26 @@ export declare namespace Shape {
                 };
                 readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
             };
-            readonly nodeKind: {
+            readonly node: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Maybe";
                     item: () => {
-                        kind: "Iri";
-                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                        kind: "Identifier";
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
             };
-            readonly nodes: {
+            readonly nodeKind: {
                 readonly kind: "Shacl";
                 readonly type: () => {
-                    kind: "Set";
+                    kind: "Maybe";
                     item: () => {
-                        kind: "Identifier";
+                        kind: "Iri";
+                        in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                     };
                 };
-                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
             };
             readonly not: {
                 readonly kind: "Shacl";
@@ -2967,26 +2967,26 @@ export declare namespace $Object {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
                         };
-                        readonly nodeKind: {
+                        readonly node: {
                             readonly kind: "Shacl";
                             readonly type: () => {
                                 kind: "Maybe";
                                 item: () => {
-                                    kind: "Iri";
-                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                    kind: "Identifier";
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
                         };
-                        readonly nodes: {
+                        readonly nodeKind: {
                             readonly kind: "Shacl";
                             readonly type: () => {
-                                kind: "Set";
+                                kind: "Maybe";
                                 item: () => {
-                                    kind: "Identifier";
+                                    kind: "Iri";
+                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
                         };
                         readonly not: {
                             readonly kind: "Shacl";
@@ -3518,26 +3518,26 @@ export declare namespace $Object {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#name">;
                         };
-                        readonly nodeKind: {
+                        readonly node: {
                             readonly kind: "Shacl";
                             readonly type: () => {
                                 kind: "Maybe";
                                 item: () => {
-                                    kind: "Iri";
-                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                    kind: "Identifier";
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
                         };
-                        readonly nodes: {
+                        readonly nodeKind: {
                             readonly kind: "Shacl";
                             readonly type: () => {
-                                kind: "Set";
+                                kind: "Maybe";
                                 item: () => {
-                                    kind: "Identifier";
+                                    kind: "Iri";
+                                    in: (import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRI"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
                                 };
                             };
-                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#node">;
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
                         };
                         readonly not: {
                             readonly kind: "Shacl";
@@ -3698,12 +3698,12 @@ export interface $ObjectSet {
     shapeCount(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Promise<Either<Error, number>>;
     shapeIdentifiers(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape.$Identifier[]>>;
     shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
-    object(identifier: $Object.$Identifier, options?: {
+    $object(identifier: $Object.$Identifier, options?: {
         preferredLanguages?: readonly string[];
     }): Promise<Either<Error, $Object>>;
-    objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
-    objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
+    $objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    $objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
+    $objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
 }
 export declare namespace $ObjectSet {
     interface Query<ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode> {
@@ -3783,32 +3783,18 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
     shapeIdentifiersSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape.$Identifier[]>;
     shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
     shapesSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape[]>;
-    object(identifier: $Object.$Identifier, options?: {
+    $object(identifier: $Object.$Identifier, options?: {
         preferredLanguages?: readonly string[];
     }): Promise<Either<Error, $Object>>;
-    objectSync(identifier: $Object.$Identifier, options?: {
+    $objectSync(identifier: $Object.$Identifier, options?: {
         preferredLanguages?: readonly string[];
     }): Either<Error, $Object>;
-    objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    objectCountSync(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Either<Error, number>;
-    objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
-    objectIdentifiersSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object.$Identifier[]>;
-    objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
-    objectsSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object[]>;
-    protected $objectsSync<ObjectT extends {
-        readonly $identifier: () => ObjectIdentifierT;
-    }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(namedObjectType: {
-        $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
-        $fromRdfTypes: readonly NamedNode[];
-    }, query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
-    protected $objectUnionsSync<ObjectT extends {
-        readonly $identifier: () => ObjectIdentifierT;
-    }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(namedObjectTypes: readonly {
-        $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
-        $fromRdfTypes: readonly NamedNode[];
-    }[], query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
+    $objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    $objectCountSync(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Either<Error, number>;
+    $objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
+    $objectIdentifiersSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object.$Identifier[]>;
+    $objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
+    $objectsSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object[]>;
 }
 export {};
 //# sourceMappingURL=generated.d.ts.map

package/dist/input/generated.js

@@ -8,7 +8,7 @@ import { Either, Left, Maybe, Right } from "purify-ts";
  * Remove undefined values from a record.
  */
 function $compactRecord(record) {
-    return Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+    return globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
         if (propertyValue !== undefined) {
             definedProperties[propertyName] = propertyValue;
         }
@@ -715,6 +715,22 @@ export var PropertyShape;
         else {
             name = parameters.name;
         }
+        let node;
+        if (Maybe.isMaybe(parameters.node)) {
+            node = parameters.node;
+        }
+        else if (typeof parameters.node === "object") {
+            node = Maybe.of(parameters.node);
+        }
+        else if (typeof parameters.node === "string") {
+            node = Maybe.of(dataFactory.namedNode(parameters.node));
+        }
+        else if (parameters.node === undefined) {
+            node = Maybe.empty();
+        }
+        else {
+            node = parameters.node;
+        }
         let nodeKind;
         if (Maybe.isMaybe(parameters.nodeKind)) {
             nodeKind = parameters.nodeKind;
@@ -731,19 +747,6 @@ export var PropertyShape;
         else {
             nodeKind = parameters.nodeKind;
         }
-        let nodes;
-        if (parameters.nodes === undefined) {
-            nodes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters.nodes)) {
-            nodes = parameters.nodes;
-        }
-        else if ($isReadonlyStringArray(parameters.nodes)) {
-            nodes = parameters.nodes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            nodes = parameters.nodes;
-        }
         let not;
         if (parameters.not === undefined) {
             not = [];
@@ -883,8 +886,8 @@ export var PropertyShape;
             minLength,
             mutable,
             name,
+            node,
             nodeKind,
-            nodes,
             not,
             or,
             order,
@@ -1007,12 +1010,12 @@ export var PropertyShape;
             !$filterMaybe($filterString)(filter.name, value.name)) {
             return false;
         }
-        if (filter.nodeKind !== undefined &&
-            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+        if (filter.node !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.node, value.node)) {
             return false;
         }
-        if (filter.nodes !== undefined &&
-            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
             return false;
         }
         if (filter.not !== undefined &&
@@ -1577,6 +1580,26 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((name) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema
+                .properties
+                .node,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .node
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((node) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema
@@ -1604,24 +1627,6 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((nodeKind) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.$schema
-                .properties
-                .nodes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: PropertyShape
-                    .$schema
-                    .properties
-                    .nodes
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((nodes) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema
@@ -1850,8 +1855,8 @@ export var PropertyShape;
             minLength,
             mutable,
             name,
+            node,
             nodeKind,
-            nodes,
             not,
             or,
             order,
@@ -2086,6 +2091,14 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
             },
+            node: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -2104,14 +2117,6 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
             },
-            nodes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
-            },
             not: {
                 kind: "Shacl",
                 type: () => ({
@@ -2323,8 +2328,8 @@ export var PropertyShape;
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), _propertyShape.name
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _propertyShape.node.toList(), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _propertyShape.nodeKind.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _propertyShape.nodes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _propertyShape.not.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _propertyShape.or.toList().flatMap((value) => [
             value.length > 0
@@ -3468,6 +3473,22 @@ export var NodeShape;
         else {
             mutable = parameters?.mutable;
         }
+        let node;
+        if (Maybe.isMaybe(parameters?.node)) {
+            node = parameters?.node;
+        }
+        else if (typeof parameters?.node === "object") {
+            node = Maybe.of(parameters?.node);
+        }
+        else if (typeof parameters?.node === "string") {
+            node = Maybe.of(dataFactory.namedNode(parameters?.node));
+        }
+        else if (parameters?.node === undefined) {
+            node = Maybe.empty();
+        }
+        else {
+            node = parameters?.node;
+        }
         let nodeKind;
         if (Maybe.isMaybe(parameters?.nodeKind)) {
             nodeKind = parameters?.nodeKind;
@@ -3484,19 +3505,6 @@ export var NodeShape;
         else {
             nodeKind = parameters?.nodeKind;
         }
-        let nodes;
-        if (parameters?.nodes === undefined) {
-            nodes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.nodes)) {
-            nodes = parameters?.nodes;
-        }
-        else if ($isReadonlyStringArray(parameters?.nodes)) {
-            nodes = parameters?.nodes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            nodes = parameters?.nodes;
-        }
         let not;
         if (parameters?.not === undefined) {
             not = [];
@@ -3697,8 +3705,8 @@ export var NodeShape;
             minInclusive,
             minLength,
             mutable,
+            node,
             nodeKind,
-            nodes,
             not,
             or,
             patterns,
@@ -3825,12 +3833,12 @@ export var NodeShape;
             !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
             return false;
         }
-        if (filter.nodeKind !== undefined &&
-            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+        if (filter.node !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.node, value.node)) {
             return false;
         }
-        if (filter.nodes !== undefined &&
-            !$filterArray($filterIdentifier)(filter.nodes, value.nodes)) {
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
             return false;
         }
         if (filter.not !== undefined &&
@@ -4406,6 +4414,26 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((mutable) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: NodeShape.$schema
+                .properties
+                .node,
+            typeFromRdf: (resourceValues) => resourceValues
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .map((values) => values.length >
+                0
+                ? values.map((value) => Maybe.of(value))
+                : Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: PropertyShape
+                        .$schema
+                        .properties
+                        .node
+                        .path,
+                    value: Maybe.empty(),
+                })),
+        }).chain((node) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema
@@ -4433,24 +4461,6 @@ export var NodeShape;
                     value: Maybe.empty(),
                 })),
         }).chain((nodeKind) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.$schema
-                .properties
-                .nodes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: PropertyShape
-                    .$schema
-                    .properties
-                    .nodes
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((nodes) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: NodeShape.$schema
@@ -4769,8 +4779,8 @@ export var NodeShape;
             minInclusive,
             minLength,
             mutable,
+            node,
             nodeKind,
-            nodes,
             not,
             or,
             patterns,
@@ -5011,6 +5021,14 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
             },
+            node: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -5029,14 +5047,6 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
             },
-            nodes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
-            },
             not: {
                 kind: "Shacl",
                 type: () => ({
@@ -5334,8 +5344,8 @@ export var NodeShape;
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), options?.graph);
+        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.node.toList(), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), _nodeShape.nodeKind.toList(), options?.graph);
-        resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), _nodeShape.nodes.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), _nodeShape.not.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), _nodeShape.or.toList().flatMap((value) => [
             value.length > 0
@@ -5645,6 +5655,14 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
             },
+            node: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "Identifier" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+            },
             nodeKind: {
                 kind: "Shacl",
                 type: () => ({
@@ -5663,14 +5681,6 @@ export var Shape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
             },
-            nodes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
-            },
             not: {
                 kind: "Shacl",
                 type: () => ({
@@ -5997,7 +6007,7 @@ export class $RdfjsDatasetObjectSet {
         return this.nodeShapesSync(query);
     }
     nodeShapesSync(query) {
-        return this.$objectsSync({
+        return this.#objectsSync({
             $filter: NodeShape.$filter,
             $fromRdfResource: NodeShape.$fromRdfResource,
             $fromRdfTypes: [NodeShape.$fromRdfType],
@@ -6028,7 +6038,7 @@ export class $RdfjsDatasetObjectSet {
         return this.ontologiesSync(query);
     }
     ontologiesSync(query) {
-        return this.$objectsSync({
+        return this.#objectsSync({
             $filter: Ontology.$filter,
             $fromRdfResource: Ontology.$fromRdfResource,
             $fromRdfTypes: [Ontology.$fromRdfType],
@@ -6059,7 +6069,7 @@ export class $RdfjsDatasetObjectSet {
         return this.propertyGroupsSync(query);
     }
     propertyGroupsSync(query) {
-        return this.$objectsSync({
+        return this.#objectsSync({
             $filter: PropertyGroup.$filter,
             $fromRdfResource: PropertyGroup.$fromRdfResource,
             $fromRdfTypes: [PropertyGroup.$fromRdfType],
@@ -6090,7 +6100,7 @@ export class $RdfjsDatasetObjectSet {
         return this.propertyShapesSync(query);
     }
     propertyShapesSync(query) {
-        return this.$objectsSync({
+        return this.#objectsSync({
             $filter: PropertyShape.$filter,
             $fromRdfResource: PropertyShape.$fromRdfResource,
             $fromRdfTypes: [PropertyShape.$fromRdfType],
@@ -6121,7 +6131,7 @@ export class $RdfjsDatasetObjectSet {
         return this.shapesSync(query);
     }
     shapesSync(query) {
-        return this.$objectUnionsSync([
+        return this.#objectUnionsSync([
             {
                 $filter: Shape.$filter,
                 $fromRdfResource: NodeShape.$fromRdfResource,
@@ -6134,32 +6144,32 @@ export class $RdfjsDatasetObjectSet {
             },
         ], query);
     }
-    async object(identifier, options) {
-        return this.objectSync(identifier, options);
+    async $object(identifier, options) {
+        return this.$objectSync(identifier, options);
     }
-    objectSync(identifier, options) {
-        return this.objectsSync({
+    $objectSync(identifier, options) {
+        return this.$objectsSync({
             identifiers: [identifier],
             preferredLanguages: options?.preferredLanguages,
         }).map((objects) => objects[0]);
     }
-    async objectCount(query) {
-        return this.objectCountSync(query);
+    async $objectCount(query) {
+        return this.$objectCountSync(query);
     }
-    objectCountSync(query) {
-        return this.objectsSync(query).map((objects) => objects.length);
+    $objectCountSync(query) {
+        return this.$objectsSync(query).map((objects) => objects.length);
     }
-    async objectIdentifiers(query) {
-        return this.objectIdentifiersSync(query);
+    async $objectIdentifiers(query) {
+        return this.$objectIdentifiersSync(query);
     }
-    objectIdentifiersSync(query) {
-        return this.objectsSync(query).map((objects) => objects.map((object) => object.$identifier()));
+    $objectIdentifiersSync(query) {
+        return this.$objectsSync(query).map((objects) => objects.map((object) => object.$identifier()));
     }
-    async objects(query) {
-        return this.objectsSync(query);
+    async $objects(query) {
+        return this.$objectsSync(query);
     }
-    objectsSync(query) {
-        return this.$objectUnionsSync([
+    $objectsSync(query) {
+        return this.#objectUnionsSync([
             {
                 $filter: $Object.$filter,
                 $fromRdfResource: NodeShape.$fromRdfResource,
@@ -6182,7 +6192,7 @@ export class $RdfjsDatasetObjectSet {
             },
         ], query);
     }
-    $objectsSync(namedObjectType, query) {
+    #objectsSync(namedObjectType, query) {
         const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {
@@ -6275,7 +6285,7 @@ export class $RdfjsDatasetObjectSet {
         }
         return Right(objects);
     }
-    $objectUnionsSync(namedObjectTypes, query) {
+    #objectUnionsSync(namedObjectTypes, query) {
         const graph = query?.graph ?? this.$graph;
         const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
         if (limit <= 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.25",
+    "@shaclmate/shacl-ast": "4.0.27",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.25"
+  "version": "4.0.27"
 }