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

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

@@ -0,0 +1,385 @@
+"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 builtIn_exports = {};
+__export(builtIn_exports, {
+  aggregate: () => aggregate,
+  aggregateAvg: () => aggregateAvg,
+  aggregateCount: () => aggregateCount,
+  aggregateGroup_concat: () => aggregateGroup_concat,
+  aggregateMax: () => aggregateMax,
+  aggregateMin: () => aggregateMin,
+  aggregateSample: () => aggregateSample,
+  aggregateSum: () => aggregateSum,
+  builtInAbs: () => builtInAbs,
+  builtInBnodeSparqlJs: () => builtInBnodeSparqlJs,
+  builtInBound: () => builtInBound,
+  builtInCall: () => builtInCall,
+  builtInCallList: () => builtInCallList,
+  builtInCeil: () => builtInCeil,
+  builtInCoalesce: () => builtInCoalesce,
+  builtInConcat: () => builtInConcat,
+  builtInContains: () => builtInContains,
+  builtInDatatype: () => builtInDatatype,
+  builtInDay: () => builtInDay,
+  builtInEncode_for_uri: () => builtInEncode_for_uri,
+  builtInFloor: () => builtInFloor,
+  builtInHours: () => builtInHours,
+  builtInIf: () => builtInIf,
+  builtInIri: () => builtInIri,
+  builtInIsblank: () => builtInIsblank,
+  builtInIsiri: () => builtInIsiri,
+  builtInIsliteral: () => builtInIsliteral,
+  builtInIsnumeric: () => builtInIsnumeric,
+  builtInIsuri: () => builtInIsuri,
+  builtInLang: () => builtInLang,
+  builtInLangmatches: () => builtInLangmatches,
+  builtInLcase: () => builtInLcase,
+  builtInMd5: () => builtInMd5,
+  builtInMinutes: () => builtInMinutes,
+  builtInMonth: () => builtInMonth,
+  builtInNow: () => builtInNow,
+  builtInRand: () => builtInRand,
+  builtInRound: () => builtInRound,
+  builtInSameterm: () => builtInSameterm,
+  builtInSeconds: () => builtInSeconds,
+  builtInSha1: () => builtInSha1,
+  builtInSha256: () => builtInSha256,
+  builtInSha384: () => builtInSha384,
+  builtInSha512: () => builtInSha512,
+  builtInStr: () => builtInStr,
+  builtInStrafter: () => builtInStrafter,
+  builtInStrbefore: () => builtInStrbefore,
+  builtInStrdt: () => builtInStrdt,
+  builtInStrends: () => builtInStrends,
+  builtInStrlang: () => builtInStrlang,
+  builtInStrlen: () => builtInStrlen,
+  builtInStrstarts: () => builtInStrstarts,
+  builtInStruuid: () => builtInStruuid,
+  builtInTimezone: () => builtInTimezone,
+  builtInTz: () => builtInTz,
+  builtInUcase: () => builtInUcase,
+  builtInUri: () => builtInUri,
+  builtInUuid: () => builtInUuid,
+  builtInYear: () => builtInYear,
+  existsFunc: () => existsFunc,
+  notExistsFunc: () => notExistsFunc,
+  regexExpression: () => regexExpression,
+  strReplaceExpression: () => strReplaceExpression,
+  substringExpression: () => substringExpression
+});
+module.exports = __toCommonJS(builtIn_exports);
+var import_core = require("@traqula/core");
+var import_expressionHelpers = require("../expressionHelpers.js");
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_expression = require("./expression.js");
+var import_literals = require("./literals.js");
+const builtInStr = (0, import_expressionHelpers.funcExpr1)(l.builtIn.str);
+const builtInLang = (0, import_expressionHelpers.funcExpr1)(l.builtIn.lang);
+const builtInLangmatches = (0, import_expressionHelpers.funcExpr2)(l.builtIn.langmatches);
+const builtInDatatype = (0, import_expressionHelpers.funcExpr1)(l.builtIn.datatype);
+const builtInBound = (0, import_expressionHelpers.funcVar1)(l.builtIn.bound);
+const builtInIri = (0, import_expressionHelpers.funcExpr1)(l.builtIn.iri);
+const builtInUri = (0, import_expressionHelpers.funcExpr1)(l.builtIn.uri);
+const builtInBnodeSparqlJs = (0, import_expressionHelpers.funcExprOrNil1)(l.builtIn.bnode);
+const builtInRand = (0, import_expressionHelpers.funcNil1)(l.builtIn.rand);
+const builtInAbs = (0, import_expressionHelpers.funcExpr1)(l.builtIn.abs);
+const builtInCeil = (0, import_expressionHelpers.funcExpr1)(l.builtIn.ceil);
+const builtInFloor = (0, import_expressionHelpers.funcExpr1)(l.builtIn.floor);
+const builtInRound = (0, import_expressionHelpers.funcExpr1)(l.builtIn.round);
+const builtInConcat = (0, import_expressionHelpers.funcExprList1)(l.builtIn.concat);
+const builtInStrlen = (0, import_expressionHelpers.funcExpr1)(l.builtIn.strlen);
+const builtInUcase = (0, import_expressionHelpers.funcExpr1)(l.builtIn.ucase);
+const builtInLcase = (0, import_expressionHelpers.funcExpr1)(l.builtIn.lcase);
+const builtInEncode_for_uri = (0, import_expressionHelpers.funcExpr1)(l.builtIn.encode_for_uri);
+const builtInContains = (0, import_expressionHelpers.funcExpr2)(l.builtIn.contains);
+const builtInStrstarts = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strstarts);
+const builtInStrends = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strends);
+const builtInStrbefore = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strbefore);
+const builtInStrafter = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strafter);
+const builtInYear = (0, import_expressionHelpers.funcExpr1)(l.builtIn.year);
+const builtInMonth = (0, import_expressionHelpers.funcExpr1)(l.builtIn.month);
+const builtInDay = (0, import_expressionHelpers.funcExpr1)(l.builtIn.day);
+const builtInHours = (0, import_expressionHelpers.funcExpr1)(l.builtIn.hours);
+const builtInMinutes = (0, import_expressionHelpers.funcExpr1)(l.builtIn.minutes);
+const builtInSeconds = (0, import_expressionHelpers.funcExpr1)(l.builtIn.seconds);
+const builtInTimezone = (0, import_expressionHelpers.funcExpr1)(l.builtIn.timezone);
+const builtInTz = (0, import_expressionHelpers.funcExpr1)(l.builtIn.tz);
+const builtInNow = (0, import_expressionHelpers.funcNil1)(l.builtIn.now);
+const builtInUuid = (0, import_expressionHelpers.funcNil1)(l.builtIn.uuid);
+const builtInStruuid = (0, import_expressionHelpers.funcNil1)(l.builtIn.struuid);
+const builtInMd5 = (0, import_expressionHelpers.funcExpr1)(l.builtIn.md5);
+const builtInSha1 = (0, import_expressionHelpers.funcExpr1)(l.builtIn.sha1);
+const builtInSha256 = (0, import_expressionHelpers.funcExpr1)(l.builtIn.sha256);
+const builtInSha384 = (0, import_expressionHelpers.funcExpr1)(l.builtIn.sha384);
+const builtInSha512 = (0, import_expressionHelpers.funcExpr1)(l.builtIn.sha512);
+const builtInCoalesce = (0, import_expressionHelpers.funcExprList1)(l.builtIn.coalesce);
+const builtInIf = (0, import_expressionHelpers.funcExpr3)(l.builtIn.if_);
+const builtInStrlang = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strlang);
+const builtInStrdt = (0, import_expressionHelpers.funcExpr2)(l.builtIn.strdt);
+const builtInSameterm = (0, import_expressionHelpers.funcExpr2)(l.builtIn.sameterm);
+const builtInIsiri = (0, import_expressionHelpers.funcExpr1)(l.builtIn.isiri);
+const builtInIsuri = (0, import_expressionHelpers.funcExpr1)(l.builtIn.isuri);
+const builtInIsblank = (0, import_expressionHelpers.funcExpr1)(l.builtIn.isblank);
+const builtInIsliteral = (0, import_expressionHelpers.funcExpr1)(l.builtIn.isliteral);
+const builtInIsnumeric = (0, import_expressionHelpers.funcExpr1)(l.builtIn.isnumeric);
+function builtInCallList(SUBRULE) {
+  return [
+    { ALT: () => SUBRULE(aggregate) },
+    { ALT: () => SUBRULE(builtInStr) },
+    { ALT: () => SUBRULE(builtInLang) },
+    { ALT: () => SUBRULE(builtInLangmatches) },
+    { ALT: () => SUBRULE(builtInDatatype) },
+    { ALT: () => SUBRULE(builtInBound) },
+    { ALT: () => SUBRULE(builtInIri) },
+    { ALT: () => SUBRULE(builtInUri) },
+    { ALT: () => SUBRULE(builtInBnodeSparqlJs) },
+    { ALT: () => SUBRULE(builtInRand) },
+    { ALT: () => SUBRULE(builtInAbs) },
+    { ALT: () => SUBRULE(builtInCeil) },
+    { ALT: () => SUBRULE(builtInFloor) },
+    { ALT: () => SUBRULE(builtInRound) },
+    { ALT: () => SUBRULE(builtInConcat) },
+    { ALT: () => SUBRULE(substringExpression) },
+    { ALT: () => SUBRULE(builtInStrlen) },
+    { ALT: () => SUBRULE(strReplaceExpression) },
+    { ALT: () => SUBRULE(builtInUcase) },
+    { ALT: () => SUBRULE(builtInLcase) },
+    { ALT: () => SUBRULE(builtInEncode_for_uri) },
+    { ALT: () => SUBRULE(builtInContains) },
+    { ALT: () => SUBRULE(builtInStrstarts) },
+    { ALT: () => SUBRULE(builtInStrends) },
+    { ALT: () => SUBRULE(builtInStrbefore) },
+    { ALT: () => SUBRULE(builtInStrafter) },
+    { ALT: () => SUBRULE(builtInYear) },
+    { ALT: () => SUBRULE(builtInMonth) },
+    { ALT: () => SUBRULE(builtInDay) },
+    { ALT: () => SUBRULE(builtInHours) },
+    { ALT: () => SUBRULE(builtInMinutes) },
+    { ALT: () => SUBRULE(builtInSeconds) },
+    { ALT: () => SUBRULE(builtInTimezone) },
+    { ALT: () => SUBRULE(builtInTz) },
+    { ALT: () => SUBRULE(builtInNow) },
+    { ALT: () => SUBRULE(builtInUuid) },
+    { ALT: () => SUBRULE(builtInStruuid) },
+    { ALT: () => SUBRULE(builtInMd5) },
+    { ALT: () => SUBRULE(builtInSha1) },
+    { ALT: () => SUBRULE(builtInSha256) },
+    { ALT: () => SUBRULE(builtInSha384) },
+    { ALT: () => SUBRULE(builtInSha512) },
+    { ALT: () => SUBRULE(builtInCoalesce) },
+    { ALT: () => SUBRULE(builtInIf) },
+    { ALT: () => SUBRULE(builtInStrlang) },
+    { ALT: () => SUBRULE(builtInStrdt) },
+    { ALT: () => SUBRULE(builtInSameterm) },
+    { ALT: () => SUBRULE(builtInIsiri) },
+    { ALT: () => SUBRULE(builtInIsuri) },
+    { ALT: () => SUBRULE(builtInIsblank) },
+    { ALT: () => SUBRULE(builtInIsliteral) },
+    { ALT: () => SUBRULE(builtInIsnumeric) },
+    { ALT: () => SUBRULE(regexExpression) },
+    { ALT: () => SUBRULE(existsFunc) },
+    { ALT: () => SUBRULE(notExistsFunc) }
+  ];
+}
+const builtInCall = {
+  name: "builtInCall",
+  impl: ({ OR, SUBRULE, cache }) => () => {
+    const cached = cache.get(builtInCall);
+    if (cached) {
+      return OR(cached);
+    }
+    const builtIns = builtInCallList(SUBRULE);
+    cache.set(builtInCall, builtIns);
+    return OR(builtIns);
+  }
+};
+const regexExpression = (0, import_expressionHelpers.funcExpr2or3)(l.builtIn.regex);
+const substringExpression = (0, import_expressionHelpers.funcExpr2or3)(l.builtIn.substr);
+const strReplaceExpression = (0, import_expressionHelpers.funcExpr3or4)(l.builtIn.replace);
+const existsFunc = (0, import_expressionHelpers.funcGroupGraphPattern)(l.builtIn.exists);
+const notExistsFunc = (0, import_expressionHelpers.funcGroupGraphPattern)(l.builtIn.notexists);
+const aggregateCount = {
+  name: (0, import_core.unCapitalize)(l.builtIn.count.name),
+  impl: ({ ACTION, CONSUME, SUBRULE, OR, OPTION }) => (C) => {
+    const operatorToken = CONSUME(l.builtIn.count);
+    CONSUME(l.symbols.LParen);
+    const distinctToken = OPTION(() => CONSUME(l.distinct));
+    const expressionVal = OR([
+      { ALT: () => {
+        const starToken = CONSUME(l.symbols.star);
+        return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
+      } },
+      { ALT: () => SUBRULE(import_expression.expression) }
+    ]);
+    const closeToken = CONSUME(l.symbols.RParen);
+    return ACTION(() => {
+      const F = C.astFactory;
+      if (C.astFactory.isWildcard(expressionVal)) {
+        return F.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
+      }
+      return F.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
+    });
+  }
+};
+const aggregateSum = (0, import_expressionHelpers.baseAggregateFunc)(l.builtIn.sum);
+const aggregateMin = (0, import_expressionHelpers.baseAggregateFunc)(l.builtIn.min);
+const aggregateMax = (0, import_expressionHelpers.baseAggregateFunc)(l.builtIn.max);
+const aggregateAvg = (0, import_expressionHelpers.baseAggregateFunc)(l.builtIn.avg);
+const aggregateSample = (0, import_expressionHelpers.baseAggregateFunc)(l.builtIn.sample);
+const aggregateGroup_concat = {
+  name: (0, import_core.unCapitalize)(l.builtIn.groupConcat.name),
+  impl: ({ ACTION, CONSUME, OPTION1, SUBRULE, OPTION2 }) => (C) => {
+    const operatorToken = CONSUME(l.builtIn.groupConcat);
+    CONSUME(l.symbols.LParen);
+    const distinctToken = OPTION1(() => CONSUME(l.distinct));
+    const expr = SUBRULE(import_expression.expression);
+    const sep = OPTION2(() => {
+      CONSUME(l.symbols.semi);
+      CONSUME(l.separator);
+      CONSUME(l.symbols.equal);
+      return SUBRULE(import_literals.string);
+    });
+    const closeToken = CONSUME(l.symbols.RParen);
+    return ACTION(() => {
+      const F = C.astFactory;
+      return F.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F.sourceLocation(operatorToken, closeToken));
+    });
+  }
+};
+const aggregate = {
+  name: "aggregate",
+  impl: ({ ACTION, SUBRULE, OR }) => (C) => {
+    const wasInAggregate = ACTION(() => C.parseMode.has("inAggregate"));
+    ACTION(() => C.parseMode.add("inAggregate"));
+    const result = OR([
+      { ALT: () => SUBRULE(aggregateCount) },
+      { ALT: () => SUBRULE(aggregateSum) },
+      { ALT: () => SUBRULE(aggregateMin) },
+      { ALT: () => SUBRULE(aggregateMax) },
+      { ALT: () => SUBRULE(aggregateAvg) },
+      { ALT: () => SUBRULE(aggregateSample) },
+      { ALT: () => SUBRULE(aggregateGroup_concat) }
+    ]);
+    ACTION(() => !wasInAggregate && C.parseMode.delete("inAggregate"));
+    ACTION(() => {
+      if (!C.parseMode.has("canParseAggregate")) {
+        throw new Error("Aggregates are only allowed in SELECT, HAVING, and ORDER BY clauses.");
+      }
+      if (C.parseMode.has("inAggregate")) {
+        throw new Error("An aggregate function is not allowed within an aggregate function.");
+      }
+    });
+    return result;
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD(ast.aggregation.toUpperCase(), "(");
+      if (ast.distinct) {
+        PRINT_WORD("DISTINCT");
+      }
+    });
+    const arg = ast.expression[0];
+    if (F.isWildcard(arg)) {
+      F.printFilter(ast, () => PRINT_WORD("*"));
+    } else {
+      SUBRULE(import_expression.expression, arg);
+    }
+    if (F.isExpressionAggregateSeparator(ast)) {
+      F.printFilter(ast, () => PRINT_WORD(";", "SEPARATOR", "=", (0, import_literals.stringEscapedLexical)(ast.separator)));
+    }
+    F.printFilter(ast, () => PRINT_WORD(")"));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aggregate,
+  aggregateAvg,
+  aggregateCount,
+  aggregateGroup_concat,
+  aggregateMax,
+  aggregateMin,
+  aggregateSample,
+  aggregateSum,
+  builtInAbs,
+  builtInBnodeSparqlJs,
+  builtInBound,
+  builtInCall,
+  builtInCallList,
+  builtInCeil,
+  builtInCoalesce,
+  builtInConcat,
+  builtInContains,
+  builtInDatatype,
+  builtInDay,
+  builtInEncode_for_uri,
+  builtInFloor,
+  builtInHours,
+  builtInIf,
+  builtInIri,
+  builtInIsblank,
+  builtInIsiri,
+  builtInIsliteral,
+  builtInIsnumeric,
+  builtInIsuri,
+  builtInLang,
+  builtInLangmatches,
+  builtInLcase,
+  builtInMd5,
+  builtInMinutes,
+  builtInMonth,
+  builtInNow,
+  builtInRand,
+  builtInRound,
+  builtInSameterm,
+  builtInSeconds,
+  builtInSha1,
+  builtInSha256,
+  builtInSha384,
+  builtInSha512,
+  builtInStr,
+  builtInStrafter,
+  builtInStrbefore,
+  builtInStrdt,
+  builtInStrends,
+  builtInStrlang,
+  builtInStrlen,
+  builtInStrstarts,
+  builtInStruuid,
+  builtInTimezone,
+  builtInTz,
+  builtInUcase,
+  builtInUri,
+  builtInUuid,
+  builtInYear,
+  existsFunc,
+  notExistsFunc,
+  regexExpression,
+  strReplaceExpression,
+  substringExpression
+});

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

@@ -0,0 +1,118 @@
+"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 dataSetClause_exports = {};
+__export(dataSetClause_exports, {
+  datasetClause: () => datasetClause,
+  datasetClauseStar: () => datasetClauseStar,
+  datasetClauseUsing: () => datasetClauseUsing,
+  datasetClauseUsingStar: () => datasetClauseUsingStar,
+  defaultGraphClause: () => defaultGraphClause,
+  namedGraphClause: () => namedGraphClause,
+  sourceSelector: () => sourceSelector,
+  usingClause: () => usingClause,
+  usingClauseStar: () => usingClauseStar
+});
+module.exports = __toCommonJS(dataSetClause_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_literals = require("./literals.js");
+function datasetClauseUsing(name, token) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
+      const start = CONSUME(token);
+      return OR([
+        { ALT: () => {
+          const iri2 = SUBRULE(defaultGraphClause);
+          return ACTION(() => C.astFactory.wrap({ clauseType: "default", value: iri2 }, C.astFactory.sourceLocation(start, iri2)));
+        } },
+        { ALT: () => {
+          const namedClause = SUBRULE(namedGraphClause);
+          return ACTION(() => C.astFactory.wrap({
+            clauseType: "named",
+            value: namedClause.val
+          }, C.astFactory.sourceLocation(start, namedClause)));
+        } }
+      ]);
+    }
+  };
+}
+const datasetClause = datasetClauseUsing("datasetClause", l.from);
+const defaultGraphClause = {
+  name: "defaultGraphClause",
+  impl: ({ SUBRULE }) => () => SUBRULE(sourceSelector)
+};
+const usingClause = datasetClauseUsing("usingClause", l.usingClause);
+function datasetClauseUsingStar(name, subRule, fromUsing) {
+  return {
+    name,
+    impl: ({ ACTION, MANY, SUBRULE }) => (C) => {
+      const clauses = [];
+      MANY(() => {
+        const clause = SUBRULE(subRule);
+        clauses.push(clause);
+      });
+      return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+      for (const clause of ast.clauses) {
+        F.printFilter(ast, () => PRINT_WORD(fromUsing));
+        if (clause.clauseType === "named") {
+          F.printFilter(ast, () => PRINT_WORD("NAMED"));
+        }
+        SUBRULE(import_literals.iri, clause.value);
+      }
+    }
+  };
+}
+const datasetClauseStar = datasetClauseUsingStar("datasetClauses", datasetClause, "FROM");
+const usingClauseStar = datasetClauseUsingStar("usingClauses", usingClause, "USING");
+const namedGraphClause = {
+  name: "namedGraphClause",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const named = CONSUME(l.graph.named);
+    const iri2 = SUBRULE(sourceSelector);
+    return ACTION(() => C.astFactory.wrap(iri2, C.astFactory.sourceLocation(named, iri2)));
+  }
+};
+const sourceSelector = {
+  name: "sourceSelector",
+  impl: ({ SUBRULE }) => () => SUBRULE(import_literals.iri)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  datasetClause,
+  datasetClauseStar,
+  datasetClauseUsing,
+  datasetClauseUsingStar,
+  defaultGraphClause,
+  namedGraphClause,
+  sourceSelector,
+  usingClause,
+  usingClauseStar
+});