@traqula/rules-sparql-1-1 0.0.23 → 0.0.25

package/dist/cjs/lib/grammar/tripleBlock.js

@@ -1,384 +1,425 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var tripleBlock_exports = {};
-__export(tripleBlock_exports, {
-  blankNodePropertyList: () => blankNodePropertyList,
-  blankNodePropertyListPath: () => blankNodePropertyListPath,
-  collection: () => collection,
-  collectionPath: () => collectionPath,
-  graphNode: () => graphNode,
-  graphNodePath: () => graphNodePath,
-  object: () => object,
-  objectList: () => objectList,
-  objectListPath: () => objectListPath,
-  objectPath: () => objectPath,
-  propertyList: () => propertyList,
-  propertyListNotEmpty: () => propertyListNotEmpty,
-  propertyListPath: () => propertyListPath,
-  propertyListPathNotEmpty: () => propertyListPathNotEmpty,
-  triplesBlock: () => triplesBlock,
-  triplesNode: () => triplesNode,
-  triplesNodePath: () => triplesNodePath,
-  triplesSameSubject: () => triplesSameSubject,
-  triplesSameSubjectPath: () => triplesSameSubjectPath,
-  triplesTemplate: () => triplesTemplate,
-  verbPath: () => verbPath,
-  verbSimple: () => verbSimple
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-module.exports = __toCommonJS(tripleBlock_exports);
-var import_core = require("@traqula/core");
-var l = __toESM(require("../lexer/index.js"), 1);
-var import_utils = require("../utils.js");
-var import_general = require("./general.js");
-var import_propertyPaths = require("./propertyPaths.js");
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphNodePath = exports.graphNode = exports.blankNodePropertyListPath = exports.blankNodePropertyList = exports.triplesNodePath = exports.triplesNode = exports.collectionPath = exports.collection = exports.objectPath = exports.object = exports.objectListPath = exports.objectList = exports.verbSimple = exports.verbPath = exports.propertyListPathNotEmpty = exports.propertyListNotEmpty = exports.propertyListPath = exports.propertyList = exports.triplesTemplate = exports.triplesSameSubjectPath = exports.triplesSameSubject = exports.triplesBlock = void 0;
+const core_1 = require("@traqula/core");
+const l = __importStar(require("../lexer/index.js"));
+const utils_js_1 = require("../utils.js");
+const general_js_1 = require("./general.js");
+const propertyPaths_js_1 = require("./propertyPaths.js");
 function triplesDotSeperated(triplesSameSubjectSubrule) {
-  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
-    const triples = [];
-    let parsedDot = true;
-    let dotToken;
-    AT_LEAST_ONE({
-      GATE: () => parsedDot,
-      DEF: () => {
-        parsedDot = false;
-        const template = SUBRULE(triplesSameSubjectSubrule);
-        ACTION(() => {
-          triples.push(...template);
-        });
-        OPTION(() => {
-          dotToken = CONSUME(l.symbols.dot);
-          parsedDot = true;
+    return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
+        const triples = [];
+        let parsedDot = true;
+        let dotToken;
+        AT_LEAST_ONE({
+            GATE: () => parsedDot,
+            DEF: () => {
+                parsedDot = false;
+                const template = SUBRULE(triplesSameSubjectSubrule);
+                ACTION(() => {
+                    triples.push(...template);
+                });
+                OPTION(() => {
+                    dotToken = CONSUME(l.symbols.dot);
+                    parsedDot = true;
+                });
+            },
         });
-      }
-    });
-    return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
-  };
+        return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
+    };
 }
-const triplesBlock = {
-  name: "triplesBlock",
-  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE }) => (ast, { astFactory: F }) => {
-    for (const [index, triple] of ast.triples.entries()) {
-      HANDLE_LOC(triple, () => {
-        const nextTriple = ast.triples.at(index);
-        if (F.isTripleCollection(triple)) {
-          SUBRULE(graphNodePath, triple);
-          F.printFilter(triple, () => {
-            PRINT_WORD(".");
-            NEW_LINE();
-          });
-        } else {
-          SUBRULE(graphNodePath, triple.subject);
-          F.printFilter(triple, () => PRINT_WORD(""));
-          if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
-            SUBRULE(import_general.varOrTerm, triple.predicate);
-          } else {
-            SUBRULE(import_propertyPaths.pathGenerator, triple.predicate, void 0);
-          }
-          F.printFilter(triple, () => PRINT_WORD(""));
-          SUBRULE(graphNodePath, triple.object);
-          if (nextTriple === void 0 || F.isTripleCollection(nextTriple) || !F.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F.printFilter(ast, () => {
-              PRINT_WORD(".");
-              NEW_LINE();
-            });
-          } else if (F.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
-            F.printFilter(ast, () => PRINT_WORD(","));
-          } else {
-            F.printFilter(ast, () => {
-              PRINT_WORD(";");
-              NEW_LINE();
+/**
+ * [[55]](https://www.w3.org/TR/sparql11-query/#rTriplesBlock)
+ */
+exports.triplesBlock = {
+    name: 'triplesBlock',
+    impl: implArgs => C => triplesDotSeperated(exports.triplesSameSubjectPath)(implArgs)(C),
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE }) => (ast, { astFactory: F }) => {
+        for (const [index, triple] of ast.triples.entries()) {
+            HANDLE_LOC(triple, () => {
+                const nextTriple = ast.triples.at(index + 1);
+                if (F.isTripleCollection(triple)) {
+                    SUBRULE(exports.graphNodePath, triple);
+                    // A top level tripleCollection block means that it is either not used in a triple
+                    //   - or is the subject of a triple. In case it is the subject,
+                    //   the identifier of the block will be the subject of the next triple and that subject is not materialized.
+                    const isSubjectOfTriple = nextTriple?.type === 'triple' &&
+                        F.isSourceLocationNoMaterialize(nextTriple.subject.loc);
+                    if (!isSubjectOfTriple) {
+                        F.printFilter(triple, () => {
+                            PRINT_WORD('.');
+                            NEW_LINE();
+                        });
+                    }
+                }
+                else {
+                    // Subject
+                    SUBRULE(exports.graphNodePath, triple.subject);
+                    F.printFilter(triple, () => PRINT_WORD(''));
+                    // Predicate
+                    if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
+                        SUBRULE(general_js_1.varOrTerm, triple.predicate);
+                    }
+                    else {
+                        SUBRULE(propertyPaths_js_1.pathGenerator, triple.predicate, undefined);
+                    }
+                    F.printFilter(triple, () => PRINT_WORD(''));
+                    // Object
+                    SUBRULE(exports.graphNodePath, triple.object);
+                    // If no more things, or a top level collection (only possible if new block was part), or new subject: add DOT
+                    if (nextTriple === undefined || F.isTripleCollection(nextTriple) ||
+                        !F.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
+                        F.printFilter(ast, () => {
+                            PRINT_WORD('.');
+                            NEW_LINE();
+                        });
+                    }
+                    else if (F.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
+                        F.printFilter(ast, () => PRINT_WORD(','));
+                    }
+                    else {
+                        F.printFilter(ast, () => {
+                            PRINT_WORD(';');
+                            NEW_LINE();
+                        });
+                    }
+                }
             });
-          }
         }
-      });
-    }
-  }
+    },
 };
+/**
+ * [[75]](https://www.w3.org/TR/sparql11-query/#rTriplesSameSubject)
+ * [[81]](https://www.w3.org/TR/sparql11-query/#rTriplesSameSubjectPath)
+ * CONTRACT: triples generated from the subject come first, then comes the main triple,
+ *  and then come the triples from the object. Only the first occurrence of a term has `SourceLocationType = source`
+ */
 function triplesSameSubjectImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
-      { ALT: () => {
-        const subject = SUBRULE(import_general.varOrTerm);
-        const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
-        return ACTION(() => {
-          if (res.length > 0) {
-            res[0].subject = subject;
-            res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
-          }
-          return res;
-        });
-      } },
-      { ALT: () => {
-        const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
-        const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
-        return ACTION(() => {
-          if (restNode.length === 0) {
-            return [subjectNode];
-          }
-          restNode[0].subject = subjectNode;
-          restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
-          return restNode;
-        });
-      } }
-    ])
-  };
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE, OR }) => C => OR([
+            { ALT: () => {
+                    const subject = SUBRULE(general_js_1.varOrTerm);
+                    const res = SUBRULE(allowPaths ? exports.propertyListPathNotEmpty : exports.propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
+                    // Only the first occurrence of a subject is actually materialized.
+                    return ACTION(() => {
+                        if (res.length > 0) {
+                            res[0].subject = subject;
+                            res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
+                        }
+                        return res;
+                    });
+                } },
+            { ALT: () => {
+                    const subjectNode = SUBRULE(allowPaths ? exports.triplesNodePath : exports.triplesNode);
+                    const restNode = SUBRULE(allowPaths ? exports.propertyListPath : exports.propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
+                    return ACTION(() => {
+                        if (restNode.length === 0) {
+                            return [subjectNode];
+                        }
+                        restNode[0].subject = subjectNode;
+                        restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
+                        return restNode;
+                    });
+                } },
+        ]),
+    };
 }
-const triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
-const triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
-const triplesTemplate = {
-  name: "triplesTemplate",
-  impl: triplesDotSeperated(triplesSameSubject)
+exports.triplesSameSubject = triplesSameSubjectImpl('triplesSameSubject', false);
+exports.triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubjectPath', true);
+/**
+ * [[52]](https://www.w3.org/TR/sparql11-query/#rTriplesTemplate)
+ */
+exports.triplesTemplate = {
+    name: 'triplesTemplate',
+    impl: triplesDotSeperated(exports.triplesSameSubject),
 };
+/**
+ * [[76]](https://www.w3.org/TR/sparql11-query/#rPropertyList)
+ * [[82]](https://www.w3.org/TR/sparql11-query/#rPropertyListPath)
+ */
 function propertyListImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ SUBRULE, OPTION }) => (_, subject) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, subject)) ?? []
-  };
+    return {
+        name,
+        impl: ({ SUBRULE, OPTION }) => (_, subject) => OPTION(() => SUBRULE(allowPaths ? exports.propertyListPathNotEmpty : exports.propertyListNotEmpty, subject)) ?? [],
+    };
 }
-const propertyList = propertyListImpl("propertyList", false);
-const propertyListPath = propertyListImpl("propertyListPath", true);
+exports.propertyList = propertyListImpl('propertyList', false);
+exports.propertyListPath = propertyListImpl('propertyListPath', true);
+// We could use gates for this, but in that case,
+// a grammar not in need of paths would still have to include the path rules
+/**
+ * [[77]](https://www.w3.org/TR/sparql11-query/#rPropertyListNotEmpty)
+ * [[83]](https://www.w3.org/TR/sparql11-query/#rPropertyListPathNotEmpty)
+ */
 function propertyListNotEmptyImplementation(name, allowPaths) {
-  return {
-    name,
-    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, subject) => {
-      const result = [];
-      let parsedSemi = true;
-      AT_LEAST_ONE({
-        GATE: () => parsedSemi,
-        DEF: () => {
-          parsedSemi = false;
-          const predicate = allowPaths ? OR1([
-            { ALT: () => SUBRULE1(verbPath) },
-            { ALT: () => SUBRULE1(verbSimple) }
-          ]) : SUBRULE1(import_general.verb);
-          const triples = SUBRULE1(allowPaths ? objectListPath : objectList, subject, predicate);
-          MANY2(() => {
-            CONSUME(l.symbols.semi);
-            parsedSemi = true;
-          });
-          ACTION(() => {
-            result.push(...triples);
-          });
-        }
-      });
-      return result;
-    }
-  };
+    return {
+        name,
+        impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, subject) => {
+            const result = [];
+            let parsedSemi = true;
+            AT_LEAST_ONE({
+                GATE: () => parsedSemi,
+                DEF: () => {
+                    parsedSemi = false;
+                    const predicate = allowPaths ?
+                        OR1([
+                            { ALT: () => SUBRULE1(exports.verbPath) },
+                            { ALT: () => SUBRULE1(exports.verbSimple) },
+                        ]) :
+                        SUBRULE1(general_js_1.verb);
+                    const triples = SUBRULE1(allowPaths ? exports.objectListPath : exports.objectList, subject, predicate);
+                    MANY2(() => {
+                        CONSUME(l.symbols.semi);
+                        parsedSemi = true;
+                    });
+                    ACTION(() => {
+                        result.push(...triples);
+                    });
+                },
+            });
+            return result;
+        },
+    };
 }
-const propertyListNotEmpty = propertyListNotEmptyImplementation("propertyListNotEmpty", false);
-const propertyListPathNotEmpty = propertyListNotEmptyImplementation("propertyListPathNotEmpty", true);
-const verbPath = {
-  name: "verbPath",
-  impl: ({ SUBRULE }) => () => SUBRULE(import_propertyPaths.path)
+exports.propertyListNotEmpty = propertyListNotEmptyImplementation('propertyListNotEmpty', false);
+exports.propertyListPathNotEmpty = propertyListNotEmptyImplementation('propertyListPathNotEmpty', true);
+/**
+ * [[84]](https://www.w3.org/TR/sparql11-query/#rVerbPath)
+ */
+exports.verbPath = {
+    name: 'verbPath',
+    impl: ({ SUBRULE }) => () => SUBRULE(propertyPaths_js_1.path),
 };
-const verbSimple = {
-  name: "verbSimple",
-  impl: ({ SUBRULE }) => () => SUBRULE(import_general.var_)
+/**
+ * [[85]](https://www.w3.org/TR/sparql11-query/#rVerbSimple)
+ */
+exports.verbSimple = {
+    name: 'verbSimple',
+    impl: ({ SUBRULE }) => () => SUBRULE(general_js_1.var_),
 };
+/**
+ * [[79]](https://www.w3.org/TR/sparql11-query/#rObjectList)
+ * [[86]](https://www.w3.org/TR/sparql11-query/#rObjectListPath)
+ */
 function objectListImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, subj, pred) => {
-      const objects = [];
-      AT_LEAST_ONE_SEP({
-        SEP: l.symbols.comma,
-        DEF: () => {
-          const objectTriple = SUBRULE(allowPaths ? objectPath : object, subj, pred);
-          ACTION(() => {
-            objects.push(objectTriple);
-          });
-        }
-      });
-      return objects;
-    }
-  };
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, subj, pred) => {
+            const objects = [];
+            AT_LEAST_ONE_SEP({
+                SEP: l.symbols.comma,
+                DEF: () => {
+                    const objectTriple = SUBRULE(allowPaths ? exports.objectPath : exports.object, subj, pred);
+                    ACTION(() => {
+                        objects.push(objectTriple);
+                    });
+                },
+            });
+            return objects;
+        },
+    };
 }
-const objectList = objectListImpl("objectList", false);
-const objectListPath = objectListImpl("objectListPath", true);
+exports.objectList = objectListImpl('objectList', false);
+exports.objectListPath = objectListImpl('objectListPath', true);
+/**
+ * [[80]](https://www.w3.org/TR/sparql11-query/#rObject)
+ * [[87]](https://www.w3.org/TR/sparql11-query/#rObjectPath)
+ */
 function objectImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
-      const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
-      return ACTION(() => C.astFactory.triple(subject, predicate, node));
-    }
-  };
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+            const node = SUBRULE(allowPaths ? exports.graphNodePath : exports.graphNode);
+            return ACTION(() => C.astFactory.triple(subject, predicate, node));
+        },
+    };
 }
-const object = objectImpl("object", false);
-const objectPath = objectImpl("objectPath", true);
+exports.object = objectImpl('object', false);
+exports.objectPath = objectImpl('objectPath', true);
+/**
+ * [[102]](https://www.w3.org/TR/sparql11-query/#rCollection)
+ * [[103]](https://www.w3.org/TR/sparql11-query/#rCollectionPath)
+ */
 function collectionImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
-      const terms = [];
-      const startToken = CONSUME(l.symbols.LParen);
-      AT_LEAST_ONE(() => {
-        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode));
-      });
-      const endToken = CONSUME(l.symbols.RParen);
-      return ACTION(() => {
-        const F = C.astFactory;
-        const triples = [];
-        const predFirst = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.FIRST, void 0);
-        const predRest = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.REST, void 0);
-        const predNil = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.NIL, void 0);
-        const listHead = F.termBlank(void 0, F.sourceLocationNoMaterialize());
-        let iterHead = listHead;
-        for (const [index, term] of terms.entries()) {
-          const lastInList = index === terms.length - 1;
-          const headTriple = F.triple(iterHead, predFirst, term);
-          triples.push(headTriple);
-          if (lastInList) {
-            const nilTriple = F.triple(iterHead, predRest, predNil);
-            triples.push(nilTriple);
-          } else {
-            const tail = F.termBlank(void 0, F.sourceLocationNoMaterialize());
-            const linkTriple = F.triple(iterHead, predRest, tail);
-            triples.push(linkTriple);
-            iterHead = tail;
-          }
-        }
-        return F.tripleCollectionList(listHead, triples, F.sourceLocation(startToken, endToken));
-      });
-    },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
-      F.printFilter(ast, () => PRINT_WORD("("));
-      for (const [idx, triple] of ast.triples.entries()) {
-        if (idx % 2 === 0) {
-          SUBRULE(allowPaths ? graphNodePath : graphNode, triple.object);
-        }
-      }
-      F.printFilter(ast, () => PRINT_WORD(")"));
-    }
-  };
+    return {
+        name,
+        impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
+            // Construct a [cons list](https://en.wikipedia.org/wiki/Cons#Lists),
+            // here called a [RDF collection](https://www.w3.org/TR/sparql11-query/#collections).
+            const terms = [];
+            const startToken = CONSUME(l.symbols.LParen);
+            AT_LEAST_ONE(() => {
+                terms.push(SUBRULE(allowPaths ? exports.graphNodePath : exports.graphNode));
+            });
+            const endToken = CONSUME(l.symbols.RParen);
+            return ACTION(() => {
+                const F = C.astFactory;
+                const triples = [];
+                // The triples created in your recursion
+                const predFirst = F.termNamed(F.sourceLocation(), utils_js_1.CommonIRIs.FIRST, undefined);
+                const predRest = F.termNamed(F.sourceLocation(), utils_js_1.CommonIRIs.REST, undefined);
+                const predNil = F.termNamed(F.sourceLocation(), utils_js_1.CommonIRIs.NIL, undefined);
+                const listHead = F.termBlank(undefined, F.sourceLocation());
+                let iterHead = listHead;
+                for (const [index, term] of terms.entries()) {
+                    const lastInList = index === terms.length - 1;
+                    const headTriple = F.triple(iterHead, predFirst, term);
+                    triples.push(headTriple);
+                    // If not the last, create new iterHead, otherwise, close list
+                    if (lastInList) {
+                        const nilTriple = F.triple(iterHead, predRest, predNil);
+                        triples.push(nilTriple);
+                    }
+                    else {
+                        const tail = F.termBlank(undefined, F.sourceLocation());
+                        const linkTriple = F.triple(iterHead, predRest, tail);
+                        triples.push(linkTriple);
+                        iterHead = tail;
+                    }
+                }
+                return F.tripleCollectionList(listHead, triples, F.sourceLocation(startToken, endToken));
+            });
+        },
+        gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+            F.printFilter(ast, () => PRINT_WORD('('));
+            // Only every 2 triple is relevant. The odd triples are linking triples.
+            for (const [idx, triple] of ast.triples.entries()) {
+                if (idx % 2 === 0) {
+                    SUBRULE(allowPaths ? exports.graphNodePath : exports.graphNode, triple.object);
+                }
+            }
+            F.printFilter(ast, () => PRINT_WORD(')'));
+        },
+    };
 }
-const collection = collectionImpl("collection", false);
-const collectionPath = collectionImpl("collectionPath", true);
+exports.collection = collectionImpl('collection', false);
+exports.collectionPath = collectionImpl('collectionPath', true);
+/**
+ * [[98]](https://www.w3.org/TR/sparql11-query/#rTriplesNode)
+ * [[100]](https://www.w3.org/TR/sparql11-query/#rTriplesNodePath)
+ */
 function triplesNodeImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ SUBRULE, OR }) => () => OR([
-      { ALT: () => SUBRULE(allowPaths ? collectionPath : collection) },
-      { ALT: () => SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList) }
-    ]),
-    gImpl: ({ SUBRULE }) => (ast) => ast.subType === "list" ? SUBRULE(allowPaths ? collectionPath : collection, ast) : SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList, ast)
-  };
+    return {
+        name,
+        impl: ({ SUBRULE, OR }) => () => OR([
+            { ALT: () => SUBRULE(allowPaths ? exports.collectionPath : exports.collection) },
+            { ALT: () => SUBRULE(allowPaths ? exports.blankNodePropertyListPath : exports.blankNodePropertyList) },
+        ]),
+        gImpl: ({ SUBRULE }) => ast => ast.subType === 'list' ?
+            SUBRULE(allowPaths ? exports.collectionPath : exports.collection, ast) :
+            SUBRULE(allowPaths ? exports.blankNodePropertyListPath : exports.blankNodePropertyList, ast),
+    };
 }
-const triplesNode = triplesNodeImpl("triplesNode", false);
-const triplesNodePath = triplesNodeImpl("triplesNodePath", true);
+exports.triplesNode = triplesNodeImpl('triplesNode', false);
+exports.triplesNodePath = triplesNodeImpl('triplesNodePath', true);
+/**
+ * [[99]](https://www.w3.org/TR/sparql11-query/#rBlankNodePropertyList)
+ * [[101]](https://www.w3.org/TR/sparql11-query/#rBlankNodePropertyListPath)
+ */
 function blankNodePropertyListImpl(name, allowPaths) {
-  const propertyPathNotEmptyImpl = allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty;
-  return {
-    name,
-    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-      const startToken = CONSUME(l.symbols.LSquare);
-      const blankNode = ACTION(() => C.astFactory.termBlank(void 0, C.astFactory.sourceLocationNoMaterialize()));
-      const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode);
-      const endToken = CONSUME(l.symbols.RSquare);
-      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode, propList, C.astFactory.sourceLocation(startToken, endToken)));
-    },
-    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY, NEW_LINE }) => (ast, c) => {
-      const { astFactory: F, indentInc } = c;
-      F.printFilter(ast, () => {
-        c[import_core.traqulaIndentation] += indentInc;
-        PRINT("[");
-        NEW_LINE();
-      });
-      for (const triple of ast.triples) {
-        HANDLE_LOC(triple, () => {
-          if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
-            SUBRULE(import_general.varOrTerm, triple.predicate);
-          } else {
-            SUBRULE(import_propertyPaths.pathGenerator, triple.predicate, void 0);
-          }
-          F.printFilter(triple, () => PRINT_WORD(""));
-          SUBRULE(graphNodePath, triple.object);
-          F.printFilter(ast, () => {
-            PRINT_WORD(";");
-            NEW_LINE();
-          });
-        });
-      }
-      F.printFilter(ast, () => {
-        c[import_core.traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("]");
-      });
-    }
-  };
+    const propertyPathNotEmptyImpl = allowPaths ? exports.propertyListPathNotEmpty : exports.propertyListNotEmpty;
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+            const startToken = CONSUME(l.symbols.LSquare);
+            const blankNode = ACTION(() => C.astFactory.termBlank(undefined, C.astFactory.sourceLocation()));
+            const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode);
+            const endToken = CONSUME(l.symbols.RSquare);
+            return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode, propList, C.astFactory.sourceLocation(startToken, endToken)));
+        },
+        gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY, NEW_LINE }) => (ast, c) => {
+            const { astFactory: F, indentInc } = c;
+            F.printFilter(ast, () => {
+                c[core_1.traqulaIndentation] += indentInc;
+                PRINT('[');
+                NEW_LINE();
+            });
+            for (const triple of ast.triples) {
+                HANDLE_LOC(triple, () => {
+                    // Predicate
+                    if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
+                        SUBRULE(general_js_1.varOrTerm, triple.predicate);
+                    }
+                    else {
+                        SUBRULE(propertyPaths_js_1.pathGenerator, triple.predicate, undefined);
+                    }
+                    F.printFilter(triple, () => PRINT_WORD(''));
+                    // Object
+                    SUBRULE(exports.graphNodePath, triple.object);
+                    F.printFilter(ast, () => {
+                        PRINT_WORD(';');
+                        NEW_LINE();
+                    });
+                });
+            }
+            F.printFilter(ast, () => {
+                c[core_1.traqulaIndentation] -= indentInc;
+                PRINT_ON_EMPTY(']');
+            });
+        },
+    };
 }
-const blankNodePropertyList = blankNodePropertyListImpl("blankNodePropertyList", false);
-const blankNodePropertyListPath = blankNodePropertyListImpl("blankNodePropertyListPath", true);
+exports.blankNodePropertyList = blankNodePropertyListImpl('blankNodePropertyList', false);
+exports.blankNodePropertyListPath = blankNodePropertyListImpl('blankNodePropertyListPath', true);
+/**
+ * [[103]](https://www.w3.org/TR/sparql11-query/#rGraphNode)
+ * [[105]](https://www.w3.org/TR/sparql11-query/#rGraphNodePath)
+ */
 function graphNodeImpl(name, allowPaths) {
-  const triplesNodeRule = allowPaths ? triplesNodePath : triplesNode;
-  return {
-    name,
-    impl: ({ SUBRULE, OR }) => (C) => OR([
-      { ALT: () => SUBRULE(import_general.varOrTerm) },
-      {
-        GATE: () => C.parseMode.has("canCreateBlankNodes"),
-        ALT: () => SUBRULE(triplesNodeRule)
-      }
-    ]),
-    gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
-      if (F.isTerm(ast)) {
-        SUBRULE(import_general.varOrTerm, ast);
-      } else {
-        SUBRULE(triplesNodeRule, ast);
-      }
-    }
-  };
+    const triplesNodeRule = allowPaths ? exports.triplesNodePath : exports.triplesNode;
+    return {
+        name,
+        impl: ({ SUBRULE, OR }) => C => OR([
+            { ALT: () => SUBRULE(general_js_1.varOrTerm) },
+            {
+                GATE: () => C.parseMode.has('canCreateBlankNodes'),
+                ALT: () => SUBRULE(triplesNodeRule),
+            },
+        ]),
+        gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+            if (F.isTerm(ast)) {
+                SUBRULE(general_js_1.varOrTerm, ast);
+            }
+            else {
+                SUBRULE(triplesNodeRule, ast);
+            }
+        },
+    };
 }
-const graphNode = graphNodeImpl("graphNode", false);
-const graphNodePath = graphNodeImpl("graphNodePath", true);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  blankNodePropertyList,
-  blankNodePropertyListPath,
-  collection,
-  collectionPath,
-  graphNode,
-  graphNodePath,
-  object,
-  objectList,
-  objectListPath,
-  objectPath,
-  propertyList,
-  propertyListNotEmpty,
-  propertyListPath,
-  propertyListPathNotEmpty,
-  triplesBlock,
-  triplesNode,
-  triplesNodePath,
-  triplesSameSubject,
-  triplesSameSubjectPath,
-  triplesTemplate,
-  verbPath,
-  verbSimple
-});
+exports.graphNode = graphNodeImpl('graphNode', false);
+exports.graphNodePath = graphNodeImpl('graphNodePath', true);
+//# sourceMappingURL=tripleBlock.js.map