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

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

@@ -0,0 +1,390 @@
+"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 queryUnit_exports = {};
+__export(queryUnit_exports, {
+  askQuery: () => askQuery,
+  constructQuery: () => constructQuery,
+  constructTemplate: () => constructTemplate,
+  constructTriples: () => constructTriples,
+  describeQuery: () => describeQuery,
+  query: () => query,
+  queryUnit: () => queryUnit,
+  selectClause: () => selectClause,
+  selectQuery: () => selectQuery,
+  subSelect: () => subSelect,
+  valuesClause: () => valuesClause
+});
+module.exports = __toCommonJS(queryUnit_exports);
+var import_core = require("@traqula/core");
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_validators = require("../validation/validators.js");
+var import_dataSetClause = require("./dataSetClause.js");
+var import_expression = require("./expression.js");
+var import_general = require("./general.js");
+var import_solutionModifier = require("./solutionModifier.js");
+var import_tripleBlock = require("./tripleBlock.js");
+var import_whereClause = require("./whereClause.js");
+const queryUnit = {
+  name: "queryUnit",
+  impl: ({ SUBRULE }) => () => SUBRULE(query)
+};
+const query = {
+  name: "query",
+  impl: ({ ACTION, SUBRULE, OR }) => (C) => {
+    const prologueValues = SUBRULE(import_general.prologue);
+    const subType = OR([
+      { ALT: () => SUBRULE(selectQuery) },
+      { ALT: () => SUBRULE(constructQuery) },
+      { ALT: () => SUBRULE(describeQuery) },
+      { ALT: () => SUBRULE(askQuery) }
+    ]);
+    const values = SUBRULE(valuesClause);
+    return ACTION(() => ({
+      context: prologueValues,
+      ...subType,
+      type: "query",
+      ...values && { values },
+      loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values)
+    }));
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    SUBRULE(import_general.prologue, ast.context);
+    if (F.isQuerySelect(ast)) {
+      SUBRULE(selectQuery, ast);
+    } else if (F.isQueryConstruct(ast)) {
+      SUBRULE(constructQuery, ast);
+    } else if (F.isQueryDescribe(ast)) {
+      SUBRULE(describeQuery, ast);
+    } else if (F.isQueryAsk(ast)) {
+      SUBRULE(askQuery, ast);
+    }
+    if (ast.values) {
+      SUBRULE(import_whereClause.inlineData, ast.values);
+    }
+  }
+};
+const selectQuery = {
+  name: "selectQuery",
+  impl: ({ ACTION, SUBRULE }) => (C) => {
+    const selectVal = SUBRULE(selectClause);
+    const from = SUBRULE(import_dataSetClause.datasetClauseStar);
+    const where = SUBRULE(import_whereClause.whereClause);
+    const modifiers = SUBRULE(import_solutionModifier.solutionModifier);
+    return ACTION(() => {
+      const ret = {
+        subType: "select",
+        where: where.val,
+        solutionModifiers: modifiers,
+        datasets: from,
+        ...selectVal.val,
+        loc: C.astFactory.sourceLocation(selectVal, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+      };
+      (0, import_validators.queryIsGood)(ret);
+      return ret;
+    });
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    SUBRULE(selectClause, F.wrap({
+      variables: ast.variables,
+      distinct: ast.distinct,
+      reduced: ast.reduced
+    }, F.sourceLocation(...ast.variables)));
+    SUBRULE(import_dataSetClause.datasetClauseStar, ast.datasets);
+    SUBRULE(import_whereClause.whereClause, F.wrap(ast.where, ast.where.loc));
+    SUBRULE(import_solutionModifier.solutionModifier, ast.solutionModifiers);
+  }
+};
+const subSelect = {
+  name: "subSelect",
+  impl: ({ ACTION, SUBRULE }) => (C) => {
+    const selectVal = SUBRULE(selectClause);
+    const where = SUBRULE(import_whereClause.whereClause);
+    const modifiers = SUBRULE(import_solutionModifier.solutionModifier);
+    const values = SUBRULE(valuesClause);
+    return ACTION(() => C.astFactory.querySelect({
+      where: where.val,
+      datasets: C.astFactory.datasetClauses([], C.astFactory.sourceLocation()),
+      context: [],
+      solutionModifiers: modifiers,
+      ...selectVal.val,
+      ...values && { values }
+    }, C.astFactory.sourceLocation(selectVal, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values)));
+  }
+};
+const selectClause = {
+  name: "selectClause",
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, SUBRULE2, CONSUME, OPTION, OR1, OR2, OR3 }) => (C) => {
+    const select = CONSUME(l.select);
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
+    const distinctAndReduced = OPTION(() => OR1([
+      { ALT: () => {
+        CONSUME(l.distinct);
+        return [true, false];
+      } },
+      { ALT: () => {
+        CONSUME(l.reduced);
+        return [false, true];
+      } }
+    ])) ?? [false, false];
+    const distRed = ACTION(() => {
+      const [distinct, reduced] = distinctAndReduced;
+      return {
+        ...distinct && { distinct },
+        ...reduced && { reduced }
+      };
+    });
+    let last;
+    const val = OR2([
+      { ALT: () => {
+        const star = CONSUME(l.symbols.star);
+        return ACTION(() => {
+          last = star;
+          return { variables: [C.astFactory.wildcard(C.astFactory.sourceLocation(star))], ...distRed };
+        });
+      } },
+      { ALT: () => {
+        const usedVars = [];
+        const variables = [];
+        AT_LEAST_ONE(() => OR3([
+          { ALT: () => {
+            const raw = SUBRULE1(import_general.var_);
+            ACTION(() => {
+              if (usedVars.some((v) => v.value === raw.value)) {
+                throw new Error(`Variable ${raw.value} used more than once in SELECT clause`);
+              }
+              usedVars.push(raw);
+              variables.push(raw);
+              last = raw;
+            });
+          } },
+          { ALT: () => {
+            const open = CONSUME(l.symbols.LParen);
+            const expr = SUBRULE1(import_expression.expression);
+            CONSUME(l.as);
+            const variable = SUBRULE2(import_general.var_);
+            const close = CONSUME(l.symbols.RParen);
+            ACTION(() => {
+              last = close;
+              if (usedVars.some((v) => v.value === variable.value)) {
+                throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
+              }
+              usedVars.push(variable);
+              variables.push(C.astFactory.patternBind(expr, variable, C.astFactory.sourceLocation(open, last)));
+            });
+          } }
+        ]));
+        return { variables, ...distRed };
+      } }
+    ]);
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select, last)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("SELECT ");
+      if (ast.val.distinct) {
+        PRINT_WORD("DISTINCT");
+      } else if (ast.val.reduced) {
+        PRINT_WORD("REDUCED");
+      }
+    });
+    for (const variable of ast.val.variables) {
+      if (F.isWildcard(variable)) {
+        F.printFilter(ast, () => PRINT_WORD("*"));
+      } else if (F.isTerm(variable)) {
+        SUBRULE(import_general.var_, variable);
+      } else {
+        F.printFilter(ast, () => PRINT_WORD("("));
+        SUBRULE(import_expression.expression, variable.expression);
+        F.printFilter(ast, () => PRINT_WORD("AS"));
+        SUBRULE(import_general.var_, variable.variable);
+        F.printFilter(ast, () => PRINT_WORD(")"));
+      }
+      F.printFilter(ast, () => PRINT_WORD(""));
+    }
+    F.printFilter(ast, () => PRINT_WORD(""));
+  }
+};
+const constructQuery = {
+  name: "constructQuery",
+  impl: ({ ACTION, SUBRULE1, SUBRULE2, CONSUME, OR }) => (C) => {
+    const construct = CONSUME(l.construct);
+    return OR([
+      { ALT: () => {
+        const template = SUBRULE1(constructTemplate);
+        const from = SUBRULE1(import_dataSetClause.datasetClauseStar);
+        const where = SUBRULE1(import_whereClause.whereClause);
+        const modifiers = SUBRULE1(import_solutionModifier.solutionModifier);
+        return ACTION(() => ({
+          subType: "construct",
+          template: template.val,
+          datasets: from,
+          where: where.val,
+          solutionModifiers: modifiers,
+          loc: C.astFactory.sourceLocation(construct, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+        }));
+      } },
+      { ALT: () => {
+        const from = SUBRULE2(import_dataSetClause.datasetClauseStar);
+        CONSUME(l.where);
+        const template = SUBRULE2(constructTemplate);
+        const modifiers = SUBRULE2(import_solutionModifier.solutionModifier);
+        return ACTION(() => ({
+          subType: "construct",
+          template: template.val,
+          datasets: from,
+          where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
+          solutionModifiers: modifiers,
+          loc: C.astFactory.sourceLocation(construct, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+        }));
+      } }
+    ]);
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, PRINT_ON_OWN_LINE, NEW_LINE }) => (ast, C) => {
+    const { astFactory: F, indentInc } = C;
+    F.printFilter(ast, () => PRINT_ON_EMPTY("CONSTRUCT "));
+    if (!F.isSourceLocationNoMaterialize(ast.where.loc)) {
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] += indentInc;
+        PRINT_WORD("{");
+        NEW_LINE();
+      });
+      SUBRULE(import_tripleBlock.triplesBlock, ast.template);
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] -= indentInc;
+        PRINT_ON_OWN_LINE("}");
+      });
+    }
+    SUBRULE(import_dataSetClause.datasetClauseStar, ast.datasets);
+    if (F.isSourceLocationNoMaterialize(ast.where.loc)) {
+      SUBRULE(import_whereClause.whereClause, F.wrap(F.patternGroup([ast.template], ast.template.loc), ast.template.loc));
+    } else {
+      SUBRULE(import_whereClause.whereClause, F.wrap(ast.where, ast.where.loc));
+    }
+    SUBRULE(import_solutionModifier.solutionModifier, ast.solutionModifiers);
+  }
+};
+const describeQuery = {
+  name: "describeQuery",
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, CONSUME, OPTION, OR }) => (C) => {
+    const describe = CONSUME(l.describe);
+    const variables = OR([
+      { ALT: () => {
+        const variables2 = [];
+        AT_LEAST_ONE(() => {
+          variables2.push(SUBRULE1(import_general.varOrIri));
+        });
+        return variables2;
+      } },
+      { ALT: () => {
+        const star = CONSUME(l.symbols.star);
+        return [ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(star)))];
+      } }
+    ]);
+    const from = SUBRULE1(import_dataSetClause.datasetClauseStar);
+    const where = OPTION(() => SUBRULE1(import_whereClause.whereClause));
+    const modifiers = SUBRULE1(import_solutionModifier.solutionModifier);
+    return ACTION(() => ({
+      subType: "describe",
+      variables,
+      datasets: from,
+      ...where && { where: where.val },
+      solutionModifiers: modifiers,
+      loc: C.astFactory.sourceLocation(describe, ...variables, from, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+    }));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_ON_EMPTY("DESCRIBE "));
+    if (F.isWildcard(ast.variables[0])) {
+      F.printFilter(ast, () => PRINT_WORD("*"));
+    } else {
+      for (const variable of ast.variables) {
+        SUBRULE(import_general.varOrTerm, variable);
+      }
+    }
+    SUBRULE(import_dataSetClause.datasetClauseStar, ast.datasets);
+    if (ast.where) {
+      SUBRULE(import_whereClause.whereClause, F.wrap(ast.where, ast.loc));
+    }
+    SUBRULE(import_solutionModifier.solutionModifier, ast.solutionModifiers);
+  }
+};
+const askQuery = {
+  name: "askQuery",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const ask = CONSUME(l.ask);
+    const from = SUBRULE(import_dataSetClause.datasetClauseStar);
+    const where = SUBRULE(import_whereClause.whereClause);
+    const modifiers = SUBRULE(import_solutionModifier.solutionModifier);
+    return ACTION(() => ({
+      subType: "ask",
+      datasets: from,
+      where: where.val,
+      solutionModifiers: modifiers,
+      loc: C.astFactory.sourceLocation(ask, from, where, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+    }));
+  },
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_ON_EMPTY("ASK "));
+    SUBRULE(import_dataSetClause.datasetClauseStar, ast.datasets);
+    SUBRULE(import_whereClause.whereClause, F.wrap(ast.where, ast.loc));
+    SUBRULE(import_solutionModifier.solutionModifier, ast.solutionModifiers);
+  }
+};
+const valuesClause = {
+  name: "valuesClause",
+  impl: ({ OPTION, SUBRULE }) => () => OPTION(() => SUBRULE(import_whereClause.inlineData))
+};
+const constructTemplate = {
+  name: "constructTemplate",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+    const open = CONSUME(l.symbols.LCurly);
+    const triples = OPTION(() => SUBRULE1(constructTriples));
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.wrap(triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocation()), C.astFactory.sourceLocation(open, close)));
+  }
+};
+const constructTriples = {
+  name: "constructTriples",
+  impl: import_tripleBlock.triplesTemplate.impl
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  askQuery,
+  constructQuery,
+  constructTemplate,
+  constructTriples,
+  describeQuery,
+  query,
+  queryUnit,
+  selectClause,
+  selectQuery,
+  subSelect,
+  valuesClause
+});

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

@@ -0,0 +1,280 @@
+"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 solutionModifier_exports = {};
+__export(solutionModifier_exports, {
+  groupClause: () => groupClause,
+  groupCondition: () => groupCondition,
+  havingClause: () => havingClause,
+  havingCondition: () => havingCondition,
+  limitClause: () => limitClause,
+  limitOffsetClauses: () => limitOffsetClauses,
+  offsetClause: () => offsetClause,
+  orderClause: () => orderClause,
+  orderCondition: () => orderCondition,
+  solutionModifier: () => solutionModifier
+});
+module.exports = __toCommonJS(solutionModifier_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_builtIn = require("./builtIn.js");
+var import_expression = require("./expression.js");
+var import_general = require("./general.js");
+var import_whereClause = require("./whereClause.js");
+const solutionModifier = {
+  name: "solutionModifier",
+  impl: ({ ACTION, SUBRULE, OPTION1, OPTION2, OPTION3, OPTION4 }) => () => {
+    const group = OPTION1(() => SUBRULE(groupClause));
+    const having = OPTION2(() => SUBRULE(havingClause));
+    const order = OPTION3(() => SUBRULE(orderClause));
+    const limitOffset = OPTION4(() => SUBRULE(limitOffsetClauses));
+    return ACTION(() => ({
+      ...limitOffset && { limitOffset },
+      ...group && { group },
+      ...having && { having },
+      ...order && { order }
+    }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.group) {
+      SUBRULE(groupClause, ast.group);
+    }
+    if (ast.having) {
+      SUBRULE(havingClause, ast.having);
+    }
+    if (ast.order) {
+      SUBRULE(orderClause, ast.order);
+    }
+    if (ast.limitOffset) {
+      SUBRULE(limitOffsetClauses, ast.limitOffset);
+    }
+  }
+};
+const groupClause = {
+  name: "groupClause",
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, CONSUME }) => (C) => {
+    const groupings = [];
+    const start = CONSUME(l.groupByGroup);
+    CONSUME(l.by);
+    AT_LEAST_ONE(() => {
+      groupings.push(SUBRULE1(groupCondition));
+    });
+    return ACTION(() => ({
+      type: "solutionModifier",
+      subType: "group",
+      groupings,
+      loc: C.astFactory.sourceLocation(start, groupings.at(-1))
+    }));
+  },
+  gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("GROUP BY ");
+    });
+    for (const grouping of ast.groupings) {
+      if (F.isExpression(grouping)) {
+        SUBRULE(import_expression.expression, grouping);
+      } else {
+        F.printFilter(ast, () => PRINT_WORDS("("));
+        SUBRULE(import_expression.expression, grouping.value);
+        F.printFilter(ast, () => PRINT_WORDS("AS"));
+        SUBRULE(import_general.var_, grouping.variable);
+        F.printFilter(ast, () => PRINT_WORDS(")"));
+      }
+    }
+  }
+};
+const groupCondition = {
+  name: "groupCondition",
+  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR }) => (C) => OR([
+    { ALT: () => SUBRULE(import_builtIn.builtInCall) },
+    { ALT: () => SUBRULE(import_whereClause.functionCall) },
+    { ALT: () => SUBRULE2(import_general.var_) },
+    {
+      ALT: () => {
+        const open = CONSUME(l.symbols.LParen);
+        const expressionValue = SUBRULE(import_expression.expression);
+        const variable = OPTION(() => {
+          CONSUME(l.as);
+          return SUBRULE1(import_general.var_);
+        });
+        const close = CONSUME(l.symbols.RParen);
+        return ACTION(() => {
+          if (variable !== void 0) {
+            return {
+              variable,
+              value: expressionValue,
+              loc: C.astFactory.sourceLocation(open, close)
+            };
+          }
+          return expressionValue;
+        });
+      }
+    }
+  ])
+};
+const havingClause = {
+  name: "havingClause",
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
+    const having = CONSUME(l.having);
+    const expressions = [];
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
+    AT_LEAST_ONE(() => {
+      expressions.push(SUBRULE(havingCondition));
+    });
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
+    return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having, expressions.at(-1))));
+  },
+  gImpl: ({ PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("HAVING ");
+    });
+    for (const having of ast.having) {
+      SUBRULE(import_expression.expression, having);
+    }
+  }
+};
+const havingCondition = {
+  name: "havingCondition",
+  impl: ({ SUBRULE }) => () => SUBRULE(import_whereClause.constraint)
+};
+const orderClause = {
+  name: "orderClause",
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, CONSUME }) => (C) => {
+    const order = CONSUME(l.order);
+    CONSUME(l.by);
+    const orderings = [];
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
+    AT_LEAST_ONE(() => {
+      orderings.push(SUBRULE1(orderCondition));
+    });
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
+    return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order, orderings.at(-1))));
+  },
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("ORDER BY ");
+    });
+    for (const ordering of ast.orderDefs) {
+      if (ordering.descending) {
+        F.printFilter(ast, () => PRINT_WORDS("DESC"));
+      } else {
+        F.printFilter(ast, () => PRINT_WORDS("ASC"));
+      }
+      F.printFilter(ast, () => PRINT_WORDS("("));
+      SUBRULE(import_expression.expression, ordering.expression);
+      F.printFilter(ast, () => PRINT_WORDS(")"));
+    }
+  }
+};
+const orderCondition = {
+  name: "orderCondition",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => {
+      const descending = OR2([
+        { ALT: () => {
+          const token = CONSUME(l.orderAsc);
+          return [false, token];
+        } },
+        { ALT: () => {
+          const token = CONSUME(l.orderDesc);
+          return [true, token];
+        } }
+      ]);
+      const expr = SUBRULE(import_expression.brackettedExpression);
+      return ACTION(() => ({
+        expression: expr,
+        descending: descending[0],
+        loc: C.astFactory.sourceLocation(descending[1], expr)
+      }));
+    } },
+    { ALT: () => {
+      const expr = SUBRULE(import_whereClause.constraint);
+      return ACTION(() => ({ expression: expr, descending: false, loc: expr.loc }));
+    } },
+    { ALT: () => {
+      const expr = SUBRULE(import_general.var_);
+      return ACTION(() => ({ expression: expr, descending: false, loc: expr.loc }));
+    } }
+  ])
+};
+const limitOffsetClauses = {
+  name: "limitOffsetClauses",
+  impl: ({ ACTION, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => OR([
+    { ALT: () => {
+      const limit = SUBRULE1(limitClause);
+      const offset = OPTION1(() => SUBRULE1(offsetClause));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit.val, offset?.val, C.astFactory.sourceLocation(limit, ...offset ? [offset] : [])));
+    } },
+    { ALT: () => {
+      const offset = SUBRULE2(offsetClause);
+      const limit = OPTION2(() => SUBRULE2(limitClause));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit?.val, offset.val, C.astFactory.sourceLocation(offset, limit)));
+    } }
+  ]),
+  gImpl: ({ PRINT_WORDS, NEW_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      NEW_LINE();
+      if (ast.limit) {
+        PRINT_WORDS("LIMIT", String(ast.limit));
+      }
+      if (ast.offset) {
+        PRINT_WORDS("OFFSET", String(ast.offset));
+      }
+    });
+  }
+};
+const limitClause = {
+  name: "limitClause",
+  impl: ({ ACTION, CONSUME }) => (C) => {
+    const offset = CONSUME(l.limit);
+    const value = CONSUME(l.terminals.integer);
+    const val = Number.parseInt(value.image, 10);
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset, value)));
+  }
+};
+const offsetClause = {
+  name: "offsetClause",
+  impl: ({ CONSUME, ACTION }) => (C) => {
+    const offset = CONSUME(l.offset);
+    const value = CONSUME(l.terminals.integer);
+    const val = Number.parseInt(value.image, 10);
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset, value)));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  groupClause,
+  groupCondition,
+  havingClause,
+  havingCondition,
+  limitClause,
+  limitOffsetClauses,
+  offsetClause,
+  orderClause,
+  orderCondition,
+  solutionModifier
+});