@traqula/rules-sparql-1-2 0.0.21 → 0.0.22

package/dist/cjs/lib/grammar.js

@@ -0,0 +1,644 @@
+"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 grammar_exports = {};
+__export(grammar_exports, {
+  annotation: () => annotation,
+  annotationBlock: () => annotationBlock,
+  annotationBlockPath: () => annotationBlockPath,
+  annotationPath: () => annotationPath,
+  buildInHasLang: () => buildInHasLang,
+  buildInHasLangDir: () => buildInHasLangDir,
+  buildInIsTriple: () => buildInIsTriple,
+  buildInLangDir: () => buildInLangDir,
+  buildInLangStrDir: () => buildInLangStrDir,
+  buildInObject: () => buildInObject,
+  buildInPredicate: () => buildInPredicate,
+  buildInSubject: () => buildInSubject,
+  buildInTriple: () => buildInTriple,
+  builtInCall: () => builtInCall,
+  dataBlockValue: () => dataBlockValue,
+  exprTripleTerm: () => exprTripleTerm,
+  exprTripleTermObject: () => exprTripleTermObject,
+  exprTripleTermSubject: () => exprTripleTermSubject,
+  generateGraphTerm: () => generateGraphTerm,
+  generateTriplesBlock: () => generateTriplesBlock,
+  graphNode: () => graphNode,
+  graphNodePath: () => graphNodePath,
+  object: () => object,
+  objectPath: () => objectPath,
+  primaryExpression: () => primaryExpression,
+  prologue: () => prologue,
+  rdfLiteral: () => rdfLiteral,
+  reifiedTriple: () => reifiedTriple,
+  reifiedTripleBlock: () => reifiedTripleBlock,
+  reifiedTripleBlockPath: () => reifiedTripleBlockPath,
+  reifiedTripleObject: () => reifiedTripleObject,
+  reifiedTripleSubject: () => reifiedTripleSubject,
+  reifier: () => reifier,
+  tripleTerm: () => tripleTerm,
+  tripleTermData: () => tripleTermData,
+  tripleTermDataObject: () => tripleTermDataObject,
+  tripleTermDataSubject: () => tripleTermDataSubject,
+  tripleTermObject: () => tripleTermObject,
+  tripleTermSubject: () => tripleTermSubject,
+  triplesSameSubject: () => triplesSameSubject,
+  triplesSameSubjectPath: () => triplesSameSubjectPath,
+  unaryExpression: () => unaryExpression,
+  varOrReifierId: () => varOrReifierId,
+  varOrTerm: () => varOrTerm,
+  versionDecl: () => versionDecl,
+  versionSpecifier: () => versionSpecifier
+});
+module.exports = __toCommonJS(grammar_exports);
+var import_core = require("@traqula/core");
+var import_rules_sparql_1_1 = require("@traqula/rules-sparql-1-1");
+var l12 = __toESM(require("./lexer.js"), 1);
+var import_validators = require("./validators.js");
+const versionDecl = {
+  name: "versionDecl",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const versionToken = CONSUME(l12.version);
+    const identifier = SUBRULE(versionSpecifier);
+    return ACTION(() => C.astFactory.contextDefinitionVersion(identifier.val, C.astFactory.sourceLocation(versionToken, identifier)));
+  },
+  gImpl: ({ PRINT_ON_OWN_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_OWN_LINE("VERSION ", `${import_rules_sparql_1_1.gram.stringEscapedLexical(ast.version)}`);
+    });
+  }
+};
+const versionSpecifier = {
+  name: "versionSpecifier",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const token = OR([
+      { ALT: () => CONSUME(import_rules_sparql_1_1.lex.terminals.stringLiteral1) },
+      { ALT: () => CONSUME(import_rules_sparql_1_1.lex.terminals.stringLiteral2) }
+    ]);
+    return ACTION(() => C.astFactory.wrap(token.image.slice(1, -1), C.astFactory.sourceLocation(token)));
+  }
+};
+const prologue = {
+  name: "prologue",
+  impl: ({ SUBRULE, MANY, OR }) => () => {
+    const result = [];
+    MANY(() => OR([
+      { ALT: () => result.push(SUBRULE(import_rules_sparql_1_1.gram.baseDecl)) },
+      // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
+      //  We might need to check this.
+      { ALT: () => result.push(SUBRULE(import_rules_sparql_1_1.gram.prefixDecl)) },
+      { ALT: () => result.push(SUBRULE(versionDecl)) }
+    ]));
+    return result;
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    for (const context of ast) {
+      if (F.isContextDefinitionBase(context)) {
+        SUBRULE(import_rules_sparql_1_1.gram.baseDecl, context);
+      } else if (F.isContextDefinitionPrefix(context)) {
+        SUBRULE(import_rules_sparql_1_1.gram.prefixDecl, context);
+      } else if (F.isContextDefinitionVersion(context)) {
+        SUBRULE(versionDecl, context);
+      }
+    }
+  }
+};
+function reifiedTripleBlockImpl(name, allowPath) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE }) => (C) => {
+      const triple = SUBRULE(reifiedTriple);
+      const properties = SUBRULE(allowPath ? import_rules_sparql_1_1.gram.propertyListPath : import_rules_sparql_1_1.gram.propertyList, ACTION(() => C.astFactory.dematerialized(triple.identifier)));
+      return ACTION(() => [triple, ...properties]);
+    }
+  };
+}
+const reifiedTripleBlock = reifiedTripleBlockImpl("reifiedTripleBlock", false);
+const reifiedTripleBlockPath = reifiedTripleBlockImpl("reifiedTripleBlockPath", true);
+const dataBlockValue = {
+  name: "dataBlockValue",
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => import_rules_sparql_1_1.gram.dataBlockValue.impl($)(C) },
+    { ALT: () => $.SUBRULE(tripleTermData) }
+  ])
+};
+const reifier = {
+  name: "reifier",
+  impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
+    const tildeToken = CONSUME(l12.tilde);
+    const reifier2 = OPTION(() => SUBRULE(varOrReifierId));
+    return ACTION(() => {
+      if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
+        throw new Error("Cannot create blanknodes in current parse mode");
+      }
+      return C.astFactory.wrap(reifier2 ?? C.astFactory.termBlank(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
+    });
+  }
+};
+const varOrReifierId = {
+  name: "varOrReifierId",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(import_rules_sparql_1_1.gram.var_) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.blankNode) }
+  ])
+};
+function triplesSameSubjectImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ($) => (C) => $.OR2([
+      { ALT: () => allowPaths ? import_rules_sparql_1_1.gram.triplesSameSubjectPath.impl($)(C) : import_rules_sparql_1_1.gram.triplesSameSubject.impl($)(C) },
+      { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) }
+    ])
+  };
+}
+const triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
+const triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
+function objectImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+      const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode);
+      const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
+      return ACTION(() => {
+        const F = C.astFactory;
+        if (F.isPathPure(predicate) && annotationVal.length > 0) {
+          throw new Error("Note 17 violation");
+        }
+        return F.annotatedTriple(subject, predicate, objectVal, annotationVal);
+      });
+    }
+  };
+}
+const object = objectImpl("object", false);
+const objectPath = objectImpl("objectPath", true);
+function annotationImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, OR, MANY }) => (C) => {
+      const annotations = [];
+      let currentReifier;
+      MANY(() => {
+        OR([
+          { ALT: () => {
+            const node = SUBRULE(reifier);
+            annotations.push(node);
+            currentReifier = node.val;
+          } },
+          { ALT: () => {
+            ACTION(() => {
+              if (!currentReifier && !C.parseMode.has("canCreateBlankNodes")) {
+                throw new Error("Cannot create blanknodes in current parse mode");
+              }
+              currentReifier = currentReifier ?? C.astFactory.termBlank(void 0, C.astFactory.sourceLocation());
+            });
+            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
+            ACTION(() => {
+              annotations.push(block);
+              currentReifier = void 0;
+            });
+          } }
+        ]);
+      });
+      return annotations;
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+      for (const annotation2 of ast) {
+        if (F.isTripleCollectionBlankNodeProperties(annotation2)) {
+          SUBRULE(annotationBlockPath, annotation2);
+        } else {
+          F.printFilter(annotation2, () => PRINT_WORD("~"));
+          SUBRULE(graphNodePath, annotation2.val);
+        }
+      }
+    }
+  };
+}
+const annotationPath = annotationImpl("annotationPath", true);
+const annotation = annotationImpl("annotation", false);
+function annotationBlockImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C, arg) => {
+      const open = CONSUME(l12.annotationOpen);
+      const res = SUBRULE(allowPaths ? import_rules_sparql_1_1.gram.propertyListPathNotEmpty : import_rules_sparql_1_1.gram.propertyListNotEmpty, arg);
+      const close = CONSUME(l12.annotationClose);
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(arg, res, C.astFactory.sourceLocation(open, close)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
+      const { astFactory: F, indentInc } = C;
+      F.printFilter(ast, () => {
+        PRINT_WORD("{|");
+        if (ast.triples.length > 1) {
+          C[import_core.traqulaIndentation] += indentInc;
+          NEW_LINE();
+        }
+      });
+      function printTriple(triple) {
+        HANDLE_LOC(triple, () => {
+          if (F.isTerm(triple.predicate)) {
+            SUBRULE(graphNodePath, triple.predicate);
+          } else {
+            SUBRULE(import_rules_sparql_1_1.gram.pathGenerator, triple.predicate, void 0);
+          }
+          F.printFilter(triple, () => PRINT_WORD(""));
+          SUBRULE(graphNodePath, triple.object);
+        });
+      }
+      const [head, ...tail] = ast.triples;
+      printTriple(head);
+      for (const triple of tail) {
+        F.printFilter(ast, () => {
+          PRINT_WORD(";");
+          NEW_LINE();
+        });
+        printTriple(triple);
+      }
+      F.printFilter(ast, () => {
+        if (ast.triples.length > 1) {
+          PRINT_ON_OWN_LINE("|}");
+        } else {
+          PRINT_WORD("|}");
+        }
+      });
+    }
+  };
+}
+const annotationBlockPath = annotationBlockImpl("annotationBlockPath", true);
+const annotationBlock = annotationBlockImpl("annotationBlock", false);
+const graphNode = {
+  name: "graphNode",
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => import_rules_sparql_1_1.gram.graphNode.impl($)(C) },
+    { ALT: () => $.SUBRULE(reifiedTriple) }
+  ])
+};
+const graphNodePath = {
+  name: "graphNodePath",
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => import_rules_sparql_1_1.gram.graphNodePath.impl($)(C) },
+    { ALT: () => $.SUBRULE(reifiedTriple) }
+  ]),
+  gImpl: ($) => (ast, C) => {
+    if (C.astFactory.isTripleCollectionReifiedTriple(ast)) {
+      $.SUBRULE(reifiedTriple, ast);
+    } else {
+      import_rules_sparql_1_1.gram.graphNodePath.gImpl($)(ast, C);
+    }
+  }
+};
+const varOrTerm = {
+  name: "varOrTerm",
+  impl: ({ ACTION, SUBRULE, OR, CONSUME }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(import_rules_sparql_1_1.gram.var_) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.numericLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.booleanLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.blankNode) },
+    { ALT: () => {
+      const token = CONSUME(import_rules_sparql_1_1.lex.terminals.nil);
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), import_rules_sparql_1_1.CommonIRIs.NIL));
+    } },
+    { ALT: () => SUBRULE(tripleTerm) }
+  ])
+  // Generation remains untouched - go through graphTerm
+};
+const reifiedTriple = {
+  name: "reifiedTriple",
+  impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
+    const open = CONSUME(l12.reificationOpen);
+    const subject = SUBRULE(reifiedTripleSubject);
+    const predicate = SUBRULE(import_rules_sparql_1_1.gram.verb);
+    const object2 = SUBRULE(reifiedTripleObject);
+    const reifierVal = OPTION(() => SUBRULE(reifier));
+    const close = CONSUME(l12.reificationClose);
+    return ACTION(() => {
+      if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
+        throw new Error("Cannot create blanknodes in current parse mode");
+      }
+      return C.astFactory.tripleCollectionReifiedTriple(C.astFactory.sourceLocation(open, close), subject, predicate, object2, reifierVal?.val);
+    });
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("<<"));
+    const triple = ast.triples[0];
+    SUBRULE(graphNodePath, triple.subject);
+    F.printFilter(ast, () => PRINT_WORD(""));
+    if (F.isPathPure(triple.predicate)) {
+      SUBRULE(import_rules_sparql_1_1.gram.pathGenerator, triple.predicate, void 0);
+    } else {
+      SUBRULE(graphNodePath, triple.predicate);
+    }
+    F.printFilter(ast, () => PRINT_WORD(""));
+    SUBRULE(graphNodePath, triple.object);
+    SUBRULE(annotationPath, [F.wrap(ast.identifier, ast.identifier.loc)]);
+    F.printFilter(ast, () => PRINT_WORD(">>"));
+  }
+};
+const reifiedTripleSubject = {
+  name: "reifiedTripleSubject",
+  impl: ({ OR, SUBRULE }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(import_rules_sparql_1_1.gram.var_) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.numericLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.booleanLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.blankNode) },
+    { ALT: () => SUBRULE(reifiedTriple) },
+    { ALT: () => SUBRULE(tripleTerm) }
+  ])
+};
+const reifiedTripleObject = {
+  name: "reifiedTripleObject",
+  impl: reifiedTripleSubject.impl
+};
+const tripleTerm = {
+  name: "tripleTerm",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const open = CONSUME(l12.tripleTermOpen);
+    const subject = SUBRULE(tripleTermSubject);
+    const predicate = SUBRULE(import_rules_sparql_1_1.gram.verb);
+    const object2 = SUBRULE(tripleTermObject);
+    const close = CONSUME(l12.tripleTermClose);
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object2, C.astFactory.sourceLocation(open, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("<<("));
+    SUBRULE(graphNodePath, ast.subject);
+    F.printFilter(ast, () => PRINT_WORD(""));
+    SUBRULE(graphNodePath, ast.predicate);
+    F.printFilter(ast, () => PRINT_WORD(""));
+    SUBRULE(graphNodePath, ast.object);
+    F.printFilter(ast, () => PRINT_WORD(")>>"));
+  }
+};
+const tripleTermSubject = {
+  name: "tripleTermSubject",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(import_rules_sparql_1_1.gram.var_) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.numericLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.booleanLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.blankNode) },
+    { ALT: () => SUBRULE(tripleTerm) }
+  ])
+};
+const tripleTermObject = {
+  name: "tripleTermObject",
+  impl: tripleTermSubject.impl
+};
+const tripleTermData = {
+  name: "tripleTermData",
+  impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
+    const open = CONSUME(l12.tripleTermOpen);
+    const subject = SUBRULE(tripleTermDataSubject);
+    const predicate = OR([
+      { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+      { ALT: () => {
+        const token = CONSUME(import_rules_sparql_1_1.lex.a);
+        return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), import_rules_sparql_1_1.CommonIRIs.TYPE));
+      } }
+    ]);
+    const object2 = SUBRULE(tripleTermDataObject);
+    const close = CONSUME(l12.tripleTermClose);
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object2, C.astFactory.sourceLocation(open, close)));
+  }
+};
+const tripleTermDataSubject = {
+  name: "tripleTermDataSubject",
+  impl: ({ OR, SUBRULE }) => () => OR([
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.numericLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.booleanLiteral) },
+    { ALT: () => SUBRULE(tripleTermData) }
+  ])
+};
+const tripleTermDataObject = {
+  name: "tripleTermDataObject",
+  impl: tripleTermDataSubject.impl
+};
+const primaryExpression = {
+  name: "primaryExpression",
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => import_rules_sparql_1_1.gram.primaryExpression.impl($)(C) },
+    { ALT: () => $.SUBRULE(exprTripleTerm) }
+  ])
+};
+const exprTripleTerm = {
+  name: "exprTripleTerm",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const open = CONSUME(l12.tripleTermOpen);
+    const subject = SUBRULE(exprTripleTermSubject);
+    const predicate = SUBRULE(import_rules_sparql_1_1.gram.verb);
+    const object2 = SUBRULE(exprTripleTermObject);
+    const close = CONSUME(l12.tripleTermClose);
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object2, C.astFactory.sourceLocation(open, close)));
+  }
+};
+const exprTripleTermSubject = {
+  name: "exprTripleTermSubject",
+  impl: ({ OR, SUBRULE }) => (C) => OR([
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.iri) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.numericLiteral) },
+    { ALT: () => SUBRULE(import_rules_sparql_1_1.gram.booleanLiteral) },
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(import_rules_sparql_1_1.gram.var_) },
+    { ALT: () => SUBRULE(exprTripleTerm) }
+  ])
+};
+const exprTripleTermObject = {
+  name: "exprTripleTermObject",
+  impl: exprTripleTermSubject.impl
+};
+const buildInLangDir = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInLangDir);
+const buildInLangStrDir = (0, import_rules_sparql_1_1.funcExpr3)(l12.buildInStrLangDir);
+const buildInHasLang = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInHasLang);
+const buildInHasLangDir = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInHasLangDir);
+const buildInIsTriple = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInIsTRIPLE);
+const buildInTriple = (0, import_rules_sparql_1_1.funcExpr3)(l12.buildInTRIPLE);
+const buildInSubject = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInSUBJECT);
+const buildInPredicate = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInPREDICATE);
+const buildInObject = (0, import_rules_sparql_1_1.funcExpr1)(l12.buildInOBJECT);
+const builtInCall = {
+  name: "builtInCall",
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => import_rules_sparql_1_1.gram.builtInCall.impl($)(C) },
+    { ALT: () => $.SUBRULE(buildInLangDir) },
+    { ALT: () => $.SUBRULE(buildInLangStrDir) },
+    { ALT: () => $.SUBRULE(buildInHasLang) },
+    { ALT: () => $.SUBRULE(buildInHasLangDir) },
+    { ALT: () => $.SUBRULE(buildInIsTriple) },
+    { ALT: () => $.SUBRULE(buildInTriple) },
+    { ALT: () => $.SUBRULE(buildInSubject) },
+    { ALT: () => $.SUBRULE(buildInPredicate) },
+    { ALT: () => $.SUBRULE(buildInObject) }
+  ])
+};
+const rdfLiteral = {
+  name: "rdfLiteral",
+  impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
+    const value = SUBRULE(import_rules_sparql_1_1.gram.string);
+    return OPTION(() => OR([
+      { ALT: () => {
+        const langTag = CONSUME(l12.LANG_DIR);
+        return ACTION(() => {
+          const literal = C.astFactory.termLiteral(C.astFactory.sourceLocation(value, langTag), value.value, langTag.image.slice(1).toLowerCase());
+          (0, import_validators.langTagHasCorrectRange)(literal);
+          return literal;
+        });
+      } },
+      { ALT: () => {
+        CONSUME(import_rules_sparql_1_1.lex.symbols.hathat);
+        const iriVal = SUBRULE(import_rules_sparql_1_1.gram.iri);
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
+      } }
+    ])) ?? value;
+  }
+};
+const unaryExpression = {
+  name: "unaryExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(primaryExpression) },
+    { ALT: () => {
+      const operator = CONSUME(import_rules_sparql_1_1.lex.symbols.exclamation);
+      const expr = SUBRULE1(unaryExpression);
+      return ACTION(() => C.astFactory.expressionOperation("!", [expr], C.astFactory.sourceLocation(operator, expr)));
+    } },
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(import_rules_sparql_1_1.lex.symbols.opPlus) },
+        { ALT: () => CONSUME(import_rules_sparql_1_1.lex.symbols.opMinus) }
+      ]);
+      const expr = SUBRULE2(primaryExpression);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
+    } }
+  ])
+};
+const generateTriplesBlock = {
+  name: "triplesBlock",
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, HANDLE_LOC }) => (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(ast, () => PRINT_WORD(""));
+          if (F.isPathPure(triple.predicate)) {
+            SUBRULE(import_rules_sparql_1_1.gram.pathGenerator, triple.predicate, void 0);
+          } else {
+            SUBRULE(graphNodePath, triple.predicate);
+          }
+          F.printFilter(ast, () => PRINT_WORD(""));
+          SUBRULE(graphNodePath, triple.object);
+          SUBRULE(annotationPath, triple.annotations ?? []);
+          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();
+            });
+          }
+        }
+      });
+    }
+  }
+};
+const generateGraphTerm = {
+  name: "graphTerm",
+  gImpl: ($) => (ast, C) => {
+    if (C.astFactory.isTermTriple(ast)) {
+      $.SUBRULE(tripleTerm, ast);
+    } else {
+      import_rules_sparql_1_1.gram.graphTerm.gImpl($)(ast, C);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  annotation,
+  annotationBlock,
+  annotationBlockPath,
+  annotationPath,
+  buildInHasLang,
+  buildInHasLangDir,
+  buildInIsTriple,
+  buildInLangDir,
+  buildInLangStrDir,
+  buildInObject,
+  buildInPredicate,
+  buildInSubject,
+  buildInTriple,
+  builtInCall,
+  dataBlockValue,
+  exprTripleTerm,
+  exprTripleTermObject,
+  exprTripleTermSubject,
+  generateGraphTerm,
+  generateTriplesBlock,
+  graphNode,
+  graphNodePath,
+  object,
+  objectPath,
+  primaryExpression,
+  prologue,
+  rdfLiteral,
+  reifiedTriple,
+  reifiedTripleBlock,
+  reifiedTripleBlockPath,
+  reifiedTripleObject,
+  reifiedTripleSubject,
+  reifier,
+  tripleTerm,
+  tripleTermData,
+  tripleTermDataObject,
+  tripleTermDataSubject,
+  tripleTermObject,
+  tripleTermSubject,
+  triplesSameSubject,
+  triplesSameSubjectPath,
+  unaryExpression,
+  varOrReifierId,
+  varOrTerm,
+  versionDecl,
+  versionSpecifier
+});

package/dist/cjs/lib/index.js

@@ -0,0 +1,52 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, {
+  gram: () => gram,
+  lex: () => lex
+});
+module.exports = __toCommonJS(index_exports);
+var gram = __toESM(require("./grammar.js"), 1);
+var lex = __toESM(require("./lexer.js"), 1);
+__reExport(index_exports, require("./sparql12Types.js"), module.exports);
+__reExport(index_exports, require("./sparql12HelperTypes.js"), module.exports);
+__reExport(index_exports, require("./parserUtils.js"), module.exports);
+__reExport(index_exports, require("./AstFactory.js"), module.exports);
+__reExport(index_exports, require("./validators.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gram,
+  lex,
+  ...require("./sparql12Types.js"),
+  ...require("./sparql12HelperTypes.js"),
+  ...require("./parserUtils.js"),
+  ...require("./AstFactory.js"),
+  ...require("./validators.js")
+});