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

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

@@ -0,0 +1,384 @@
+"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 expression_exports = {};
+__export(expression_exports, {
+  additiveExpression: () => additiveExpression,
+  argList: () => argList,
+  brackettedExpression: () => brackettedExpression,
+  conditionalAndExpression: () => conditionalAndExpression,
+  conditionalOrExpression: () => conditionalOrExpression,
+  expression: () => expression,
+  expressionList: () => expressionList,
+  iriOrFunction: () => iriOrFunction,
+  multiplicativeExpression: () => multiplicativeExpression,
+  numericExpression: () => numericExpression,
+  primaryExpression: () => primaryExpression,
+  relationalExpression: () => relationalExpression,
+  unaryExpression: () => unaryExpression,
+  valueLogical: () => valueLogical
+});
+module.exports = __toCommonJS(expression_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_builtIn = require("./builtIn.js");
+var import_general = require("./general.js");
+var import_literals = require("./literals.js");
+var import_whereClause = require("./whereClause.js");
+const argList = {
+  name: "argList",
+  impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
+    { ALT: () => {
+      const nil = CONSUME(l.terminals.nil);
+      return ACTION(() => C.astFactory.wrap({ args: [], distinct: false }, C.astFactory.sourceLocation(nil)));
+    } },
+    { ALT: () => {
+      const args = [];
+      const open = CONSUME(l.symbols.LParen);
+      const distinct = OPTION(() => {
+        CONSUME(l.distinct);
+        return true;
+      }) ?? false;
+      AT_LEAST_ONE_SEP({
+        SEP: l.symbols.comma,
+        DEF: () => {
+          const arg = SUBRULE1(expression);
+          args.push(arg);
+        }
+      });
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.wrap({ args, distinct }, C.astFactory.sourceLocation(open, close)));
+    } }
+  ]),
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD("(");
+      if (ast.val.distinct) {
+        PRINT_WORD("DISTINCT");
+      }
+    });
+    const [head, ...tail] = ast.val.args;
+    if (head) {
+      SUBRULE(expression, head);
+    }
+    for (const expr of tail) {
+      F.printFilter(ast, () => PRINT_WORD(","));
+      SUBRULE(expression, expr);
+    }
+    F.printFilter(ast, () => PRINT_WORD(")"));
+  }
+};
+const expressionList = {
+  name: "expressionList",
+  impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => (C) => OR([
+    { ALT: () => {
+      const nil = CONSUME(l.terminals.nil);
+      return ACTION(() => C.astFactory.wrap([], C.astFactory.sourceLocation(nil)));
+    } },
+    { ALT: () => {
+      const open = CONSUME(l.symbols.LParen);
+      const expr1 = SUBRULE1(expression);
+      const args = [expr1];
+      MANY(() => {
+        CONSUME(l.symbols.comma);
+        const expr = SUBRULE2(expression);
+        args.push(expr);
+      });
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.wrap(args, C.astFactory.sourceLocation(open, close)));
+    } }
+  ])
+};
+const infixOperators = /* @__PURE__ */ new Set(["in", "notin", "||", "&&", "=", "!=", "<", ">", "<=", ">=", "+", "-", "*", "/"]);
+const prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
+const expression = {
+  name: "expression",
+  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    if (F.isTerm(ast)) {
+      SUBRULE(import_general.varOrTerm, ast);
+    } else if (F.isExpressionOperator(ast)) {
+      if (infixOperators.has(ast.operator)) {
+        const [left, ...right] = ast.args;
+        F.printFilter(ast, () => PRINT_WORD("("));
+        SUBRULE(expression, left);
+        F.printFilter(ast, () => {
+          if (ast.operator === "notin") {
+            PRINT_WORD("NOT IN");
+          } else if (ast.operator === "in") {
+            PRINT_WORD("IN");
+          } else {
+            PRINT_WORD(ast.operator.toUpperCase());
+          }
+        });
+        if (right.length === 1) {
+          SUBRULE(expression, right[0]);
+        } else {
+          SUBRULE(argList, F.wrap({ args: right, distinct: false }, ast.loc));
+        }
+        F.printFilter(ast, () => PRINT_WORD(")"));
+      } else if (prefixOperator.has(ast.operator)) {
+        const [expr] = ast.args;
+        F.printFilter(ast, () => PRINT_WORD(ast.operator.toUpperCase()));
+        SUBRULE(expression, expr);
+      } else {
+        F.printFilter(ast, () => PRINT_WORD(ast.operator.toUpperCase(), "("));
+        const [head, ...tail] = ast.args;
+        if (head) {
+          SUBRULE(expression, head);
+        }
+        for (const arg of tail) {
+          F.printFilter(ast, () => PRINT_WORD(","));
+          SUBRULE(expression, arg);
+        }
+        F.printFilter(ast, () => PRINT_WORD(")"));
+      }
+    } else if (F.isExpressionPatternOperation(ast)) {
+      const patterns = ast.args;
+      F.printFilter(ast, () => PRINT_WORD(ast.operator === "exists" ? "EXISTS" : "NOT EXISTS"));
+      SUBRULE(import_whereClause.groupGraphPattern, patterns);
+    } else if (F.isExpressionFunctionCall(ast)) {
+      SUBRULE(iriOrFunction, ast);
+    } else if (F.isExpressionAggregate(ast)) {
+      SUBRULE(import_builtIn.aggregate, ast);
+    }
+  }
+};
+function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
+  let iterExpr = startGenerator();
+  MANY(() => {
+    const res = restGenerator();
+    ACTION(() => {
+      iterExpr = res(iterExpr);
+    });
+  });
+  return iterExpr;
+}
+const conditionalOrExpression = {
+  name: "conditionalOrExpression",
+  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
+    CONSUME(l.symbols.logicOr);
+    const args = SUBRULE2(conditionalAndExpression);
+    return (left) => ACTION(() => C.astFactory.expressionOperation("||", [left, args], C.astFactory.sourceLocation(left, args)));
+  }, ACTION, MANY)
+};
+const conditionalAndExpression = {
+  name: "conditionalAndExpression",
+  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
+    CONSUME(l.symbols.logicAnd);
+    const arg = SUBRULE2(valueLogical);
+    return (left) => ACTION(() => C.astFactory.expressionOperation("&&", [left, arg], C.astFactory.sourceLocation(left, arg)));
+  }, ACTION, MANY)
+};
+const valueLogical = {
+  name: "valueLogical",
+  impl: ({ SUBRULE }) => () => SUBRULE(relationalExpression)
+};
+const relationalExpression = {
+  name: "relationalExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, OR3 }) => (C) => {
+    const args1 = SUBRULE1(numericExpression);
+    const expression2 = OPTION(() => OR1([
+      { ALT: () => {
+        const operator = OR2([
+          { ALT: () => CONSUME(l.symbols.equal) },
+          { ALT: () => CONSUME(l.symbols.notEqual) },
+          { ALT: () => CONSUME(l.symbols.lessThan) },
+          { ALT: () => CONSUME(l.symbols.greaterThan) },
+          { ALT: () => CONSUME(l.symbols.lessThanEqual) },
+          { ALT: () => CONSUME(l.symbols.greaterThanEqual) }
+        ]);
+        const expr = SUBRULE2(numericExpression);
+        return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, expr], C.astFactory.sourceLocation(args1, expr)));
+      } },
+      { ALT: () => {
+        const operator = OR3([
+          { ALT: () => CONSUME(l.in_) },
+          { ALT: () => CONSUME(l.notIn) }
+        ]);
+        const args = SUBRULE1(expressionList);
+        return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, ...args.val], C.astFactory.sourceLocation(args1, args)));
+      } }
+    ]));
+    return expression2 ?? args1;
+  }
+};
+const numericExpression = {
+  name: "numericExpression",
+  impl: ({ SUBRULE }) => () => SUBRULE(additiveExpression)
+};
+const additiveExpression = {
+  name: "additiveExpression",
+  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OR1, OR2, OR3, OR4 }) => (C) => constructLeftDeep(() => SUBRULE1(multiplicativeExpression), () => OR1([
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(l.symbols.opPlus) },
+        { ALT: () => CONSUME(l.symbols.opMinus) }
+      ]);
+      const arg = SUBRULE2(multiplicativeExpression);
+      return ACTION(() => (left) => C.astFactory.expressionOperation(operator.image, [left, arg], C.astFactory.sourceLocation(left, arg)));
+    } },
+    { ALT: () => {
+      const { operator, startInt } = OR3([
+        { ALT: () => {
+          const integer = SUBRULE(import_literals.numericLiteralPositive);
+          return ACTION(() => {
+            integer.value = integer.value.replace(/^\+/u, "");
+            return {
+              operator: "+",
+              startInt: integer
+            };
+          });
+        } },
+        { ALT: () => {
+          const integer = SUBRULE(import_literals.numericLiteralNegative);
+          return ACTION(() => {
+            integer.value = integer.value.replace(/^-/u, "");
+            return {
+              operator: "-",
+              startInt: integer
+            };
+          });
+        } }
+      ]);
+      const multiplicativeExpr = constructLeftDeep(() => ACTION(() => startInt), () => {
+        const innerOperator = OR4([
+          { ALT: () => CONSUME(l.symbols.star) },
+          { ALT: () => CONSUME(l.symbols.slash) }
+        ]);
+        const innerExpr = SUBRULE1(unaryExpression);
+        return ACTION(() => (leftInner) => C.astFactory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.astFactory.sourceLocation(leftInner, innerExpr)));
+      }, ACTION, MANY2);
+      return (left) => C.astFactory.expressionOperation(operator, [left, multiplicativeExpr], C.astFactory.sourceLocation(left, multiplicativeExpr));
+    } }
+  ]), ACTION, MANY1)
+};
+const multiplicativeExpression = {
+  name: "multiplicativeExpression",
+  impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OR }) => (C) => constructLeftDeep(() => SUBRULE1(unaryExpression), () => {
+    const operator = OR([
+      { ALT: () => CONSUME(l.symbols.star) },
+      { ALT: () => CONSUME(l.symbols.slash) }
+    ]);
+    const expr = SUBRULE2(unaryExpression);
+    return (left) => ({
+      type: "expression",
+      subType: "operation",
+      operator: operator.image,
+      args: [left, expr],
+      loc: C.astFactory.sourceLocation(left, expr)
+    });
+  }, ACTION, MANY)
+};
+const unaryExpression = {
+  name: "unaryExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(primaryExpression) },
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(l.symbols.exclamation) },
+        { ALT: () => CONSUME(l.symbols.opPlus) },
+        { ALT: () => CONSUME(l.symbols.opMinus) }
+      ]);
+      const expr = SUBRULE2(primaryExpression);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
+    } }
+  ])
+};
+const primaryExpression = {
+  name: "primaryExpression",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(brackettedExpression) },
+    { ALT: () => SUBRULE(import_builtIn.builtInCall) },
+    { ALT: () => SUBRULE(iriOrFunction) },
+    { ALT: () => SUBRULE(import_literals.rdfLiteral) },
+    { ALT: () => SUBRULE(import_literals.numericLiteral) },
+    { ALT: () => SUBRULE(import_literals.booleanLiteral) },
+    { ALT: () => SUBRULE(import_general.var_) }
+  ])
+};
+const brackettedExpression = {
+  name: "brackettedExpression",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const open = CONSUME(l.symbols.LParen);
+    const expr = SUBRULE(expression);
+    const close = CONSUME(l.symbols.RParen);
+    return ACTION(() => {
+      expr.loc = C.astFactory.sourceLocation(open, close);
+      return expr;
+    });
+  }
+};
+const iriOrFunction = {
+  name: "iriOrFunction",
+  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
+    const iriVal = SUBRULE(import_literals.iri);
+    const functionCall = OPTION(() => {
+      const args = SUBRULE(argList);
+      return ACTION(() => {
+        const distinct = args.val.distinct;
+        if (!C.parseMode.has("canParseAggregate") && distinct) {
+          throw new Error(`DISTINCT implies that this function is an aggregated function, which is not allowed in this context.`);
+        }
+        return {
+          type: "expression",
+          subType: "functionCall",
+          function: iriVal,
+          args: args.val.args,
+          distinct,
+          loc: C.astFactory.sourceLocation(iriVal, args)
+        };
+      });
+    });
+    return functionCall ?? iriVal;
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    if (F.isTermNamed(ast)) {
+      SUBRULE(import_literals.iri, ast);
+    } else {
+      SUBRULE(import_literals.iri, ast.function);
+      SUBRULE(argList, F.wrap({ args: ast.args, distinct: ast.distinct }, ast.loc));
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  additiveExpression,
+  argList,
+  brackettedExpression,
+  conditionalAndExpression,
+  conditionalOrExpression,
+  expression,
+  expressionList,
+  iriOrFunction,
+  multiplicativeExpression,
+  numericExpression,
+  primaryExpression,
+  relationalExpression,
+  unaryExpression,
+  valueLogical
+});

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

@@ -0,0 +1,168 @@
+"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 general_exports = {};
+__export(general_exports, {
+  baseDecl: () => baseDecl,
+  graphTerm: () => graphTerm,
+  prefixDecl: () => prefixDecl,
+  prologue: () => prologue,
+  varOrIri: () => varOrIri,
+  varOrTerm: () => varOrTerm,
+  var_: () => var_,
+  verb: () => verb
+});
+module.exports = __toCommonJS(general_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_utils = require("../utils.js");
+var import_literals = require("./literals.js");
+const prologue = {
+  name: "prologue",
+  impl: ({ SUBRULE, MANY, OR }) => () => {
+    const result = [];
+    MANY(() => OR([
+      { ALT: () => result.push(SUBRULE(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(prefixDecl)) }
+    ]));
+    return result;
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    for (const context of ast) {
+      if (F.isContextDefinitionBase(context)) {
+        SUBRULE(baseDecl, context);
+      } else if (F.isContextDefinitionPrefix(context)) {
+        SUBRULE(prefixDecl, context);
+      }
+    }
+  }
+};
+const baseDecl = {
+  name: "baseDecl",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const base = CONSUME(l.baseDecl);
+    const val = SUBRULE(import_literals.iriFull);
+    return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
+  },
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_ON_EMPTY("BASE "));
+    SUBRULE(import_literals.iri, ast.value);
+    F.printFilter(ast, () => NEW_LINE());
+  }
+};
+const prefixDecl = {
+  name: "prefixDecl",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const prefix = CONSUME(l.prefixDecl);
+    const name = CONSUME(l.terminals.pNameNs).image.slice(0, -1);
+    const value = SUBRULE(import_literals.iriFull);
+    return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
+  },
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("PREFIX ", `${ast.key}: `);
+    });
+    SUBRULE(import_literals.iri, ast.value);
+    F.printFilter(ast, () => NEW_LINE());
+  }
+};
+const verb = {
+  name: "verb",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(varOrIri) },
+    { ALT: () => SUBRULE(import_literals.verbA) }
+  ])
+};
+const varOrTerm = {
+  name: "varOrTerm",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(graphTerm) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    if (F.isTermVariable(ast)) {
+      return SUBRULE(var_, ast);
+    }
+    return SUBRULE(graphTerm, ast);
+  }
+};
+const varOrIri = {
+  name: "varOrIri",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(import_literals.iri) }
+  ])
+};
+const var_ = {
+  name: "var",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const varToken = OR([
+      { ALT: () => CONSUME(l.terminals.var1) },
+      { ALT: () => CONSUME(l.terminals.var2) }
+    ]);
+    return ACTION(() => C.astFactory.termVariable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
+  },
+  gImpl: ({ PRINT }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT(`?${ast.value}`));
+  }
+};
+const graphTerm = {
+  name: "graphTerm",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
+    { ALT: () => SUBRULE(import_literals.iri) },
+    { ALT: () => SUBRULE(import_literals.rdfLiteral) },
+    { ALT: () => SUBRULE(import_literals.numericLiteral) },
+    { ALT: () => SUBRULE(import_literals.booleanLiteral) },
+    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(import_literals.blankNode) },
+    { ALT: () => {
+      const tokenNil = CONSUME(l.terminals.nil);
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(tokenNil), import_utils.CommonIRIs.NIL));
+    } }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    if (F.isTermNamed(ast)) {
+      SUBRULE(import_literals.iri, ast);
+    } else if (F.isTermLiteral(ast)) {
+      SUBRULE(import_literals.rdfLiteral, ast);
+    } else if (F.isTermBlank(ast)) {
+      SUBRULE(import_literals.blankNode, ast);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baseDecl,
+  graphTerm,
+  prefixDecl,
+  prologue,
+  varOrIri,
+  varOrTerm,
+  var_,
+  verb
+});

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

@@ -0,0 +1,115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grammar_exports = {};
+__export(grammar_exports, {
+  queryOrUpdate: () => queryOrUpdate
+});
+module.exports = __toCommonJS(grammar_exports);
+var import_lexer = require("../lexer/index.js");
+var import_validators = require("../validation/validators.js");
+var import_general = require("./general.js");
+var import_queryUnit = require("./queryUnit.js");
+var import_updateUnit = require("./updateUnit.js");
+__reExport(grammar_exports, require("./queryUnit.js"), module.exports);
+__reExport(grammar_exports, require("./updateUnit.js"), module.exports);
+__reExport(grammar_exports, require("./builtIn.js"), module.exports);
+__reExport(grammar_exports, require("./dataSetClause.js"), module.exports);
+__reExport(grammar_exports, require("./expression.js"), module.exports);
+__reExport(grammar_exports, require("../expressionHelpers.js"), module.exports);
+__reExport(grammar_exports, require("./general.js"), module.exports);
+__reExport(grammar_exports, require("./literals.js"), module.exports);
+__reExport(grammar_exports, require("./propertyPaths.js"), module.exports);
+__reExport(grammar_exports, require("./solutionModifier.js"), module.exports);
+__reExport(grammar_exports, require("./tripleBlock.js"), module.exports);
+__reExport(grammar_exports, require("./whereClause.js"), module.exports);
+const queryOrUpdate = {
+  name: "queryOrUpdate",
+  impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {
+    const prologueValues = SUBRULE(import_general.prologue);
+    return OR1([
+      { ALT: () => {
+        const subType = OR2([
+          { ALT: () => SUBRULE(import_queryUnit.selectQuery) },
+          { ALT: () => SUBRULE(import_queryUnit.constructQuery) },
+          { ALT: () => SUBRULE(import_queryUnit.describeQuery) },
+          { ALT: () => SUBRULE(import_queryUnit.askQuery) }
+        ]);
+        const values = SUBRULE(import_queryUnit.valuesClause);
+        return ACTION(() => ({
+          context: prologueValues,
+          ...subType,
+          type: "query",
+          ...values && { values },
+          loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values)
+        }));
+      } },
+      { ALT: () => {
+        const updates = [];
+        updates.push({ context: prologueValues });
+        let parsedSemi = true;
+        MANY({
+          GATE: () => parsedSemi,
+          DEF: () => {
+            parsedSemi = false;
+            updates.at(-1).operation = SUBRULE(import_updateUnit.update1);
+            OPTION1(() => {
+              CONSUME(import_lexer.symbols.semi);
+              parsedSemi = true;
+              const innerPrologue = SUBRULE2(import_general.prologue);
+              updates.push({ context: innerPrologue });
+            });
+          }
+        });
+        return ACTION(() => {
+          const update2 = {
+            type: "update",
+            updates,
+            loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
+          };
+          (0, import_validators.updateNoReuseBlankNodeLabels)(update2);
+          return update2;
+        });
+      } }
+    ]);
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    if (F.isQuery(ast)) {
+      SUBRULE(import_queryUnit.query, ast);
+    } else {
+      SUBRULE(import_updateUnit.update, ast);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  queryOrUpdate,
+  ...require("./queryUnit.js"),
+  ...require("./updateUnit.js"),
+  ...require("./builtIn.js"),
+  ...require("./dataSetClause.js"),
+  ...require("./expression.js"),
+  ...require("../expressionHelpers.js"),
+  ...require("./general.js"),
+  ...require("./literals.js"),
+  ...require("./propertyPaths.js"),
+  ...require("./solutionModifier.js"),
+  ...require("./tripleBlock.js"),
+  ...require("./whereClause.js")
+});