@traqula/rules-sparql-1-2 0.0.1-alpha.148 → 0.0.1-alpha.176

package/lib/index.cjs

@@ -21,7 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   gram: () => grammar_exports2,
-  lex: () => lexer_exports2
+  lex: () => lexer_exports2,
+  types: () => sparql12Types_exports
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -70,53 +71,369 @@ __export(grammar_exports2, {
   varOrTerm: () => varOrTerm2
 });
 
-// lib/lexer.ts
-var lexer_exports2 = {};
-__export(lexer_exports2, {
-  LANG_DIR: () => LANG_DIR,
-  annotationClose: () => annotationClose,
-  annotationOpen: () => annotationOpen,
-  builtinHasLang: () => builtinHasLang,
-  builtinHasLangDir: () => builtinHasLangDir,
-  builtinIsTRIPLE: () => builtinIsTRIPLE,
-  builtinLangDir: () => builtinLangDir,
-  builtinOBJECT: () => builtinOBJECT,
-  builtinPREDICATE: () => builtinPREDICATE,
-  builtinSUBJECT: () => builtinSUBJECT,
-  builtinStrLangDir: () => builtinStrLangDir,
-  builtinTRIPLE: () => builtinTRIPLE,
-  reificationClose: () => reificationClose,
-  reificationOpen: () => reificationOpen,
-  sparql12Tokens: () => sparql12Tokens,
-  tilde: () => tilde,
-  tripleTermClose: () => tripleTermClose,
-  tripleTermOpen: () => tripleTermOpen
+// ../rules-sparql-1-1/lib/grammar/index.ts
+var grammar_exports = {};
+__export(grammar_exports, {
+  add: () => add2,
+  additiveExpression: () => additiveExpression,
+  aggregate: () => aggregate,
+  aggregateAvg: () => aggregateAvg,
+  aggregateCount: () => aggregateCount,
+  aggregateGroup_concat: () => aggregateGroup_concat,
+  aggregateMax: () => aggregateMax,
+  aggregateMin: () => aggregateMin,
+  aggregateSample: () => aggregateSample,
+  aggregateSum: () => aggregateSum,
+  argList: () => argList,
+  askQuery: () => askQuery,
+  baseAggregateFunc: () => baseAggregateFunc,
+  baseDecl: () => baseDecl2,
+  bind: () => bind2,
+  blankNode: () => blankNode,
+  blankNodePropertyList: () => blankNodePropertyList,
+  blankNodePropertyListPath: () => blankNodePropertyListPath,
+  booleanLiteral: () => booleanLiteral,
+  brackettedExpression: () => brackettedExpression,
+  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,
+  canCreateBlankNodes: () => canCreateBlankNodes,
+  clear: () => clear2,
+  collection: () => collection,
+  collectionPath: () => collectionPath,
+  conditionalAndExpression: () => conditionalAndExpression,
+  conditionalOrExpression: () => conditionalOrExpression,
+  constraint: () => constraint,
+  constructQuery: () => constructQuery,
+  constructTemplate: () => constructTemplate,
+  constructTriples: () => constructTriples,
+  copy: () => copy2,
+  create: () => create2,
+  dataBlock: () => dataBlock,
+  dataBlockValue: () => dataBlockValue,
+  datasetClause: () => datasetClause,
+  defaultGraphClause: () => defaultGraphClause,
+  deleteClause: () => deleteClause2,
+  deleteData: () => deleteData,
+  deleteWhere: () => deleteWhere,
+  describeQuery: () => describeQuery,
+  drop: () => drop3,
+  existsFunc: () => existsFunc,
+  expression: () => expression,
+  expressionList: () => expressionList,
+  filter: () => filter3,
+  funcExpr1: () => funcExpr1,
+  funcExpr2: () => funcExpr2,
+  funcExpr2or3: () => funcExpr2or3,
+  funcExpr3: () => funcExpr3,
+  funcExpr3or4: () => funcExpr3or4,
+  funcExprList1: () => funcExprList1,
+  funcExprOrNil1: () => funcExprOrNil1,
+  funcGroupGraphPattern: () => funcGroupGraphPattern,
+  funcNil1: () => funcNil1,
+  funcVar1: () => funcVar1,
+  functionCall: () => functionCall,
+  graphGraphPattern: () => graphGraphPattern,
+  graphNode: () => graphNode,
+  graphNodePath: () => graphNodePath,
+  graphOrDefault: () => graphOrDefault,
+  graphPatternNotTriples: () => graphPatternNotTriples,
+  graphRef: () => graphRef,
+  graphRefAll: () => graphRefAll,
+  graphTerm: () => graphTerm,
+  groupClause: () => groupClause,
+  groupCondition: () => groupCondition,
+  groupGraphPattern: () => groupGraphPattern,
+  groupGraphPatternSub: () => groupGraphPatternSub,
+  groupOrUnionGraphPattern: () => groupOrUnionGraphPattern,
+  havingClause: () => havingClause,
+  havingCondition: () => havingCondition,
+  inlineData: () => inlineData,
+  inlineDataFull: () => inlineDataFull,
+  inlineDataOneVar: () => inlineDataOneVar,
+  insertClause: () => insertClause2,
+  insertData: () => insertData,
+  iri: () => iri2,
+  iriOrFunction: () => iriOrFunction,
+  limitClause: () => limitClause,
+  limitOffsetClauses: () => limitOffsetClauses,
+  load: () => load2,
+  minusGraphPattern: () => minusGraphPattern,
+  modify: () => modify,
+  move: () => move2,
+  multiplicativeExpression: () => multiplicativeExpression,
+  namedGraphClause: () => namedGraphClause,
+  notExistsFunc: () => notExistsFunc,
+  numericExpression: () => numericExpression,
+  numericLiteral: () => numericLiteral,
+  numericLiteralNegative: () => numericLiteralNegative,
+  numericLiteralPositive: () => numericLiteralPositive,
+  numericLiteralUnsigned: () => numericLiteralUnsigned,
+  object: () => object,
+  objectList: () => objectList,
+  objectListPath: () => objectListPath,
+  objectPath: () => objectPath,
+  offsetClause: () => offsetClause,
+  optionalGraphPattern: () => optionalGraphPattern,
+  orderClause: () => orderClause,
+  orderCondition: () => orderCondition,
+  path: () => path,
+  pathAlternative: () => pathAlternative,
+  pathElt: () => pathElt,
+  pathEltOrInverse: () => pathEltOrInverse,
+  pathHelper: () => pathHelper,
+  pathMod: () => pathMod,
+  pathNegatedPropertySet: () => pathNegatedPropertySet,
+  pathOneInPropertySet: () => pathOneInPropertySet,
+  pathPrimary: () => pathPrimary,
+  pathSequence: () => pathSequence,
+  prefixDecl: () => prefixDecl2,
+  prefixedName: () => prefixedName,
+  primaryExpression: () => primaryExpression,
+  prologue: () => prologue,
+  propertyList: () => propertyList,
+  propertyListNotEmpty: () => propertyListNotEmpty,
+  propertyListPath: () => propertyListPath,
+  propertyListPathNotEmpty: () => propertyListPathNotEmpty,
+  quadData: () => quadData,
+  quadPattern: () => quadPattern,
+  quads: () => quads,
+  quadsNotTriples: () => quadsNotTriples,
+  query: () => query,
+  queryUnit: () => queryUnit,
+  rdfLiteral: () => rdfLiteral,
+  regexExpression: () => regexExpression,
+  relationalExpression: () => relationalExpression,
+  selectClause: () => selectClause,
+  selectQuery: () => selectQuery,
+  serviceGraphPattern: () => serviceGraphPattern,
+  solutionModifier: () => solutionModifier,
+  sourceSelector: () => sourceSelector,
+  strReplaceExpression: () => strReplaceExpression,
+  string: () => string,
+  subSelect: () => subSelect,
+  substringExpression: () => substringExpression,
+  triplesBlock: () => triplesBlock,
+  triplesNode: () => triplesNode,
+  triplesNodePath: () => triplesNodePath,
+  triplesSameSubject: () => triplesSameSubject,
+  triplesSameSubjectPath: () => triplesSameSubjectPath,
+  triplesTemplate: () => triplesTemplate,
+  unaryExpression: () => unaryExpression,
+  update: () => update,
+  update1: () => update1,
+  updateUnit: () => updateUnit,
+  usingClause: () => usingClause2,
+  valueLogical: () => valueLogical,
+  valuesClause: () => valuesClause,
+  varOrIri: () => varOrIri,
+  varOrTerm: () => varOrTerm,
+  var_: () => var_,
+  verb: () => verb,
+  verbA: () => verbA,
+  verbPath: () => verbPath,
+  verbSimple: () => verbSimple,
+  whereClause: () => whereClause
 });
 
-// ../../node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// ../../node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// ../../node_modules/lodash-es/_Symbol.js
-var Symbol2 = root_default.Symbol;
-var Symbol_default = Symbol2;
-
-// ../../node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
+// ../rules-sparql-1-1/lib/lexer/index.ts
+var lexer_exports = {};
+__export(lexer_exports, {
+  a: () => a,
+  add: () => add,
+  allBaseTokens: () => allBaseTokens,
+  as: () => as,
+  ask: () => ask,
+  baseDecl: () => baseDecl,
+  bind: () => bind,
+  builtIn: () => BuildinCalls_exports,
+  clear: () => clear,
+  construct: () => construct,
+  copy: () => copy,
+  create: () => create,
+  dataClause: () => dataClause,
+  deleteClause: () => deleteClause,
+  describe: () => describe,
+  distinct: () => distinct,
+  drop: () => drop2,
+  false_: () => false_,
+  filter: () => filter2,
+  from: () => from,
+  graph: () => graph_exports,
+  groupBy: () => groupBy2,
+  having: () => having,
+  in_: () => in_,
+  insertClause: () => insertClause,
+  limit: () => limit,
+  load: () => load,
+  loadInto: () => loadInto,
+  minus: () => minus,
+  modifyWith: () => modifyWith,
+  move: () => move,
+  notIn: () => notIn,
+  offset: () => offset,
+  optional: () => optional,
+  order: () => order,
+  orderAsc: () => orderAsc,
+  orderDesc: () => orderDesc,
+  prefixDecl: () => prefixDecl,
+  reduced: () => reduced,
+  select: () => select,
+  separator: () => separator,
+  service: () => service,
+  silent: () => silent,
+  sparql11Tokens: () => sparql11Tokens,
+  symbols: () => symbols_exports,
+  terminals: () => terminals_exports,
+  to: () => to,
+  true_: () => true_,
+  undef: () => undef,
+  union: () => union,
+  usingClause: () => usingClause,
+  values: () => values2,
+  where: () => where
+});
+
+// ../rules-sparql-1-1/lib/lexer/BuildinCalls.ts
+var BuildinCalls_exports = {};
+__export(BuildinCalls_exports, {
+  BuildInCalls: () => BuildInCalls,
+  abs: () => abs,
+  allBuiltInCalls: () => allBuiltInCalls,
+  avg: () => avg,
+  bnode: () => bnode,
+  bound: () => bound,
+  ceil: () => ceil,
+  coalesce: () => coalesce,
+  concat: () => concat,
+  contains: () => contains,
+  count: () => count,
+  datatype: () => datatype,
+  day: () => day,
+  encode_for_uri: () => encode_for_uri,
+  exists: () => exists,
+  floor: () => floor,
+  groupConcat: () => groupConcat,
+  hours: () => hours,
+  if_: () => if_,
+  iri: () => iri,
+  isblank: () => isblank,
+  isiri: () => isiri,
+  isliteral: () => isliteral,
+  isnumeric: () => isnumeric,
+  isuri: () => isuri,
+  lang: () => lang,
+  langmatches: () => langmatches,
+  lcase: () => lcase,
+  max: () => max,
+  md5: () => md5,
+  min: () => min,
+  minutes: () => minutes,
+  month: () => month,
+  notexists: () => notexists,
+  now: () => now,
+  rand: () => rand,
+  regex: () => regex,
+  replace: () => replace,
+  round: () => round,
+  sameterm: () => sameterm,
+  sample: () => sample,
+  seconds: () => seconds,
+  sha1: () => sha1,
+  sha256: () => sha256,
+  sha384: () => sha384,
+  sha512: () => sha512,
+  str: () => str,
+  strafter: () => strafter,
+  strbefore: () => strbefore,
+  strdt: () => strdt,
+  strends: () => strends,
+  strlang: () => strlang,
+  strlen: () => strlen,
+  strstarts: () => strstarts,
+  struuid: () => struuid,
+  substr: () => substr,
+  sum: () => sum,
+  timezone: () => timezone,
+  tz: () => tz,
+  ucase: () => ucase,
+  uri: () => uri,
+  uuid: () => uuid,
+  year: () => year
+});
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
   }
   var result = nativeObjectToString.call(value);
   if (unmasked) {
@@ -9304,42 +9621,6 @@ applyMixins(Parser, [
   PerformanceTracer
 ]);
 
-// ../core/lib/grammar-helpers/utils.ts
-function unCapitalize(str2) {
-  return str2.charAt(0).toLowerCase() + str2.slice(1);
-}
-function resolveIRI(iri3, base) {
-  if (/^[a-z][\d+.a-z-]*:/iu.test(iri3)) {
-    return iri3;
-  }
-  if (!base) {
-    throw new Error(`Cannot resolve relative IRI ${iri3} because no base IRI was set.`);
-  }
-  switch (iri3[0]) {
-    // An empty relative IRI indicates the base IRI
-    case void 0:
-      return base;
-    // Resolve relative fragment IRIs against the base IRI
-    case "#":
-      return base + iri3;
-    // Resolve relative query string IRIs by replacing the query string
-    case "?":
-      return base.replace(/(?:\?.*)?$/u, iri3);
-    // Resolve root relative IRIs at the root of the base IRI
-    case "/":
-      const baseMatch = base.match(/^(?:[a-z]+:\/*)?[^\/]*/);
-      if (!baseMatch) {
-        throw new Error(`Could not determine relative IRI using base: ${base}`);
-      }
-      const baseRoot = baseMatch[0];
-      return baseRoot + iri3;
-    // Resolve all other IRIs at the base IRI's path
-    default:
-      const basePath = base.replace(/[^\/:]*$/, "");
-      return basePath + iri3;
-  }
-}
-
 // ../core/lib/lexer-builder/LexerBuilder.ts
 var LexerBuilder = class _LexerBuilder {
   static create(starter) {
@@ -9348,9 +9629,6 @@ var LexerBuilder = class _LexerBuilder {
   constructor(starter) {
     this.tokens = starter?.tokens ? [...starter.tokens] : [];
   }
-  get(index) {
-    return this.tokens[index];
-  }
   merge(merge, overwrite = []) {
     const extraTokens = merge.tokens.filter((token) => {
       const overwriteToken = overwrite.find((t) => t.name === token.name);
@@ -9420,372 +9698,30 @@ var LexerBuilder = class _LexerBuilder {
     }
     return this;
   }
-  build() {
-    return this.tokens;
-  }
-};
-
-// ../core/lib/lexer-helper/utils.ts
-function createToken2(config) {
-  return createToken(config);
-}
-
-// ../core/lib/Wildcard.ts
-var Wildcard = class {
-  constructor() {
-    this.value = "*";
-    this.termType = "Wildcard";
-    return WILDCARD ?? this;
-  }
-  equals(other) {
-    return Boolean(other && this.termType === other.termType);
-  }
-  toJSON() {
-    const { value, ...rest } = this;
-    return rest;
-  }
-};
-var WILDCARD;
-WILDCARD = new Wildcard();
-
-// ../rules-sparql-1-1/lib/grammar/index.ts
-var grammar_exports = {};
-__export(grammar_exports, {
-  add: () => add2,
-  additiveExpression: () => additiveExpression,
-  aggregate: () => aggregate,
-  aggregateAvg: () => aggregateAvg,
-  aggregateCount: () => aggregateCount,
-  aggregateGroup_concat: () => aggregateGroup_concat,
-  aggregateMax: () => aggregateMax,
-  aggregateMin: () => aggregateMin,
-  aggregateSample: () => aggregateSample,
-  aggregateSum: () => aggregateSum,
-  argList: () => argList,
-  askQuery: () => askQuery,
-  baseAggregateFunc: () => baseAggregateFunc,
-  baseDecl: () => baseDecl2,
-  bind: () => bind2,
-  blankNode: () => blankNode,
-  blankNodePropertyList: () => blankNodePropertyList,
-  blankNodePropertyListPath: () => blankNodePropertyListPath,
-  booleanLiteral: () => booleanLiteral,
-  brackettedExpression: () => brackettedExpression,
-  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,
-  canCreateBlankNodes: () => canCreateBlankNodes,
-  clear: () => clear2,
-  collection: () => collection,
-  collectionPath: () => collectionPath,
-  conditionalAndExpression: () => conditionalAndExpression,
-  conditionalOrExpression: () => conditionalOrExpression,
-  constraint: () => constraint,
-  constructQuery: () => constructQuery,
-  constructTemplate: () => constructTemplate,
-  constructTriples: () => constructTriples,
-  copy: () => copy2,
-  create: () => create2,
-  dataBlock: () => dataBlock,
-  dataBlockValue: () => dataBlockValue,
-  datasetClause: () => datasetClause,
-  defaultGraphClause: () => defaultGraphClause,
-  deleteClause: () => deleteClause2,
-  deleteData: () => deleteData,
-  deleteWhere: () => deleteWhere,
-  describeQuery: () => describeQuery,
-  drop: () => drop3,
-  existsFunc: () => existsFunc,
-  expression: () => expression,
-  expressionList: () => expressionList,
-  filter: () => filter3,
-  funcExpr1: () => funcExpr1,
-  funcExpr2: () => funcExpr2,
-  funcExpr2or3: () => funcExpr2or3,
-  funcExpr3: () => funcExpr3,
-  funcExpr3or4: () => funcExpr3or4,
-  funcExprList1: () => funcExprList1,
-  funcExprOrNil1: () => funcExprOrNil1,
-  funcGroupGraphPattern: () => funcGroupGraphPattern,
-  funcNil1: () => funcNil1,
-  funcVar1: () => funcVar1,
-  functionCall: () => functionCall,
-  graphGraphPattern: () => graphGraphPattern,
-  graphNode: () => graphNode,
-  graphNodePath: () => graphNodePath,
-  graphOrDefault: () => graphOrDefault,
-  graphPatternNotTriples: () => graphPatternNotTriples,
-  graphRef: () => graphRef,
-  graphRefAll: () => graphRefAll,
-  graphTerm: () => graphTerm,
-  groupClause: () => groupClause,
-  groupCondition: () => groupCondition,
-  groupGraphPattern: () => groupGraphPattern,
-  groupGraphPatternSub: () => groupGraphPatternSub,
-  groupOrUnionGraphPattern: () => groupOrUnionGraphPattern,
-  havingClause: () => havingClause,
-  havingCondition: () => havingCondition,
-  inlineData: () => inlineData,
-  inlineDataFull: () => inlineDataFull,
-  inlineDataOneVar: () => inlineDataOneVar,
-  insertClause: () => insertClause2,
-  insertData: () => insertData,
-  iri: () => iri2,
-  iriOrFunction: () => iriOrFunction,
-  limitClause: () => limitClause,
-  limitOffsetClauses: () => limitOffsetClauses,
-  load: () => load2,
-  minusGraphPattern: () => minusGraphPattern,
-  modify: () => modify,
-  move: () => move2,
-  multiplicativeExpression: () => multiplicativeExpression,
-  namedGraphClause: () => namedGraphClause,
-  notExistsFunc: () => notExistsFunc,
-  numericExpression: () => numericExpression,
-  numericLiteral: () => numericLiteral,
-  numericLiteralNegative: () => numericLiteralNegative,
-  numericLiteralPositive: () => numericLiteralPositive,
-  numericLiteralUnsigned: () => numericLiteralUnsigned,
-  object: () => object,
-  objectList: () => objectList,
-  objectListPath: () => objectListPath,
-  objectPath: () => objectPath,
-  offsetClause: () => offsetClause,
-  optionalGraphPattern: () => optionalGraphPattern,
-  orderClause: () => orderClause,
-  orderCondition: () => orderCondition,
-  path: () => path,
-  pathAlternative: () => pathAlternative,
-  pathElt: () => pathElt,
-  pathEltOrInverse: () => pathEltOrInverse,
-  pathHelper: () => pathHelper,
-  pathMod: () => pathMod,
-  pathNegatedPropertySet: () => pathNegatedPropertySet,
-  pathOneInPropertySet: () => pathOneInPropertySet,
-  pathPrimary: () => pathPrimary,
-  pathSequence: () => pathSequence,
-  prefixDecl: () => prefixDecl2,
-  prefixedName: () => prefixedName,
-  primaryExpression: () => primaryExpression,
-  prologue: () => prologue,
-  propertyList: () => propertyList,
-  propertyListNotEmpty: () => propertyListNotEmpty,
-  propertyListPath: () => propertyListPath,
-  propertyListPathNotEmpty: () => propertyListPathNotEmpty,
-  quadData: () => quadData,
-  quadPattern: () => quadPattern,
-  quads: () => quads,
-  quadsNotTriples: () => quadsNotTriples,
-  query: () => query,
-  queryUnit: () => queryUnit,
-  rdfLiteral: () => rdfLiteral,
-  regexExpression: () => regexExpression,
-  relationalExpression: () => relationalExpression,
-  selectClause: () => selectClause,
-  selectQuery: () => selectQuery,
-  serviceGraphPattern: () => serviceGraphPattern,
-  solutionModifier: () => solutionModifier,
-  sourceSelector: () => sourceSelector,
-  strReplaceExpression: () => strReplaceExpression,
-  string: () => string,
-  subSelect: () => subSelect,
-  substringExpression: () => substringExpression,
-  triplesBlock: () => triplesBlock,
-  triplesNode: () => triplesNode,
-  triplesNodePath: () => triplesNodePath,
-  triplesSameSubject: () => triplesSameSubject,
-  triplesSameSubjectPath: () => triplesSameSubjectPath,
-  triplesTemplate: () => triplesTemplate,
-  unaryExpression: () => unaryExpression,
-  update: () => update,
-  update1: () => update1,
-  updateUnit: () => updateUnit,
-  usingClause: () => usingClause2,
-  valueLogical: () => valueLogical,
-  valuesClause: () => valuesClause,
-  varOrIri: () => varOrIri,
-  varOrTerm: () => varOrTerm,
-  var_: () => var_,
-  verb: () => verb,
-  verbA: () => verbA,
-  verbPath: () => verbPath,
-  verbSimple: () => verbSimple,
-  whereClause: () => whereClause
-});
-
-// ../rules-sparql-1-1/lib/lexer/index.ts
-var lexer_exports = {};
-__export(lexer_exports, {
-  a: () => a,
-  add: () => add,
-  allBaseTokens: () => allBaseTokens,
-  as: () => as,
-  ask: () => ask,
-  baseDecl: () => baseDecl,
-  bind: () => bind,
-  builtIn: () => BuildinCalls_exports,
-  clear: () => clear,
-  construct: () => construct,
-  copy: () => copy,
-  create: () => create,
-  dataClause: () => dataClause,
-  deleteClause: () => deleteClause,
-  describe: () => describe,
-  distinct: () => distinct,
-  drop: () => drop2,
-  false_: () => false_,
-  filter: () => filter2,
-  from: () => from,
-  graph: () => graph_exports,
-  groupBy: () => groupBy2,
-  having: () => having,
-  in_: () => in_,
-  insertClause: () => insertClause,
-  limit: () => limit,
-  load: () => load,
-  loadInto: () => loadInto,
-  minus: () => minus,
-  modifyWith: () => modifyWith,
-  move: () => move,
-  notIn: () => notIn,
-  offset: () => offset,
-  optional: () => optional,
-  order: () => order,
-  orderAsc: () => orderAsc,
-  orderDesc: () => orderDesc,
-  prefixDecl: () => prefixDecl,
-  reduced: () => reduced,
-  select: () => select,
-  separator: () => separator,
-  service: () => service,
-  silent: () => silent,
-  sparql11Tokens: () => sparql11Tokens,
-  symbols: () => symbols_exports,
-  terminals: () => terminals_exports,
-  to: () => to,
-  true_: () => true_,
-  undef: () => undef,
-  union: () => union,
-  usingClause: () => usingClause,
-  values: () => values2,
-  where: () => where
-});
+  build(lexerConfig) {
+    return new Lexer(this.tokens, {
+      positionTracking: "onlyStart",
+      recoveryEnabled: false,
+      // SafeMode: true,
+      // SkipValidations: true,
+      ensureOptimizations: true,
+      ...lexerConfig
+    });
+  }
+  get tokenVocabulary() {
+    return this.tokens;
+  }
+};
+
+// ../core/lib/utils.ts
+function unCapitalize(str2) {
+  return str2.charAt(0).toLowerCase() + str2.slice(1);
+}
+function createToken2(config) {
+  return createToken(config);
+}
 
 // ../rules-sparql-1-1/lib/lexer/BuildinCalls.ts
-var BuildinCalls_exports = {};
-__export(BuildinCalls_exports, {
-  BuildInCalls: () => BuildInCalls,
-  abs: () => abs,
-  allBuiltInCalls: () => allBuiltInCalls,
-  avg: () => avg,
-  bnode: () => bnode,
-  bound: () => bound,
-  ceil: () => ceil,
-  coalesce: () => coalesce,
-  concat: () => concat,
-  contains: () => contains,
-  count: () => count,
-  datatype: () => datatype,
-  day: () => day,
-  encode_for_uri: () => encode_for_uri,
-  exists: () => exists,
-  floor: () => floor,
-  groupConcat: () => groupConcat,
-  hours: () => hours,
-  if_: () => if_,
-  iri: () => iri,
-  isblank: () => isblank,
-  isiri: () => isiri,
-  isliteral: () => isliteral,
-  isnumeric: () => isnumeric,
-  isuri: () => isuri,
-  lang: () => lang,
-  langmatches: () => langmatches,
-  lcase: () => lcase,
-  max: () => max,
-  md5: () => md5,
-  min: () => min,
-  minutes: () => minutes,
-  month: () => month,
-  notexists: () => notexists,
-  now: () => now,
-  rand: () => rand,
-  regex: () => regex,
-  replace: () => replace,
-  round: () => round,
-  sameterm: () => sameterm,
-  sample: () => sample,
-  seconds: () => seconds,
-  sha1: () => sha1,
-  sha256: () => sha256,
-  sha384: () => sha384,
-  sha512: () => sha512,
-  str: () => str,
-  strafter: () => strafter,
-  strbefore: () => strbefore,
-  strdt: () => strdt,
-  strends: () => strends,
-  strlang: () => strlang,
-  strlen: () => strlen,
-  strstarts: () => strstarts,
-  struuid: () => struuid,
-  substr: () => substr,
-  sum: () => sum,
-  timezone: () => timezone,
-  tz: () => tz,
-  ucase: () => ucase,
-  uri: () => uri,
-  uuid: () => uuid,
-  year: () => year
-});
 var BuildInCalls = /* @__PURE__ */ ((BuildInCalls2) => {
   BuildInCalls2["Str"] = "builtInStr";
   BuildInCalls2["Lang"] = "builtInLang";
@@ -10203,25 +10139,25 @@ __export(terminals_exports, {
   ws: () => ws,
   wsPattern: () => wsPattern
 });
-var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
+var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
 var pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
 var varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
-var iriRefPattern = /<([^\\<>"{}|^`\u0000-\u0020])*>/;
+var iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
 var pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
 var pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
 var pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
-var percentPattern = /%[0-9A-Fa-f][0-9A-Fa-f]/;
-var pnLocalEscPattern = /\\[_~.\-!$&'()*+,;=\\/?#@%]/;
+var percentPattern = /%[\dA-Fa-f]{2}/;
+var pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
 var plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
 var pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
 var pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
-var blankNodeLabelPattern = new RegExp(`_:(?:(?:${pnCharsUPattern.source})|[0-9])(?:(?:(?:${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
+var blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
 var var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
 var var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
-var langTagPattern = /@[a-zA-Z]+(-[a-zA-Z0-9]+)*/;
-var integerPattern = /[0-9]+/;
-var decimalPattern2 = /[0-9]+\.[0-9]+/;
-var exponentPattern = /[eE][+-]?[0-9]+/;
+var langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
+var integerPattern = /\d+/;
+var decimalPattern2 = /\d+\.\d+/;
+var exponentPattern = /[Ee][+-]?\d+/;
 var doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
 var interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
 var decimalPositivePattern = new RegExp(`\\+${decimalPattern2.source}`);
@@ -10230,11 +10166,11 @@ var integerNegativePattern = new RegExp(`-${integerPattern.source}`);
 var decimalNegativePattern = new RegExp(`-${decimalPattern2.source}`);
 var doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
 var echarPattern = /\\[\\"'bfnrt]/u;
-var stringLiteral1Pattern = new RegExp(`'(?:([^\\u0027\\u005C\\u000A\r])|(?:${echarPattern.source}))*'`);
-var stringLiteral2Pattern = new RegExp(`"(?:([^\\u0022\\u005C\\u000A\\u000D])|(?:${echarPattern.source}))*"`);
+var stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
+var stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
 var stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
 var stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
-var wsPattern = /[\u0020\u0009\u000D\u000A]/;
+var wsPattern = /[\u0009\u000A\u000D ]/;
 var nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
 var anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
 var iriRef = createToken2({ name: "IriRef", pattern: iriRefPattern });
@@ -10387,6 +10323,59 @@ var allBaseTokens = LexerBuilder.create().add(
 );
 var sparql11Tokens = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a);
 
+// ../rules-sparql-1-1/lib/Wildcard.ts
+var Wildcard = class {
+  constructor() {
+    this.value = "*";
+    this.termType = "Wildcard";
+    return WILDCARD ?? this;
+  }
+  equals(other) {
+    return Boolean(other && this.termType === other.termType);
+  }
+  toJSON() {
+    const { value, ...rest } = this;
+    return rest;
+  }
+};
+var WILDCARD;
+WILDCARD = new Wildcard();
+
+// ../rules-sparql-1-1/lib/grammar-helpers/utils.ts
+function resolveIRI(iri3, base) {
+  if (/^[a-z][\d+.a-z-]*:/iu.test(iri3)) {
+    return iri3;
+  }
+  if (!base) {
+    throw new Error(`Cannot resolve relative IRI ${iri3} because no base IRI was set.`);
+  }
+  switch (iri3[0]) {
+    // An empty relative IRI indicates the base IRI
+    case void 0:
+      return base;
+    // Resolve relative fragment IRIs against the base IRI
+    case "#":
+      return base + iri3;
+    // Resolve relative query string IRIs by replacing the query string
+    case "?":
+      return base.replace(/(?:\?.*)?$/u, iri3);
+    // Resolve root relative IRIs at the root of the base IRI
+    case "/": {
+      const baseMatch = /^(?:[a-z]+:\/*)?[^/]*/u.exec(base);
+      if (!baseMatch) {
+        throw new Error(`Could not determine relative IRI using base: ${base}`);
+      }
+      const baseRoot = baseMatch[0];
+      return baseRoot + iri3;
+    }
+    // Resolve all other IRIs at the base IRI's path
+    default: {
+      const basePath = base.replace(/[^/:]*$/u, "");
+      return basePath + iri3;
+    }
+  }
+}
+
 // ../rules-sparql-1-1/lib/grammar/literals.ts
 var rdfLiteral = {
   name: "rdfLiteral",
@@ -10402,6 +10391,16 @@ var rdfLiteral = {
       }
     ]));
     return ACTION(() => C.dataFactory.literal(value, languageOrDatatype));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const lexical = SUBRULE(string, ast.value, void 0);
+    if (ast.direction) {
+      return `${lexical}@${ast.language}--${ast.direction}`;
+    }
+    if (ast.language) {
+      return `${lexical}@${ast.language}`;
+    }
+    return `${lexical}^^<${ast.datatype.value}>`;
   }
 };
 var numericLiteral = {
@@ -10501,6 +10500,29 @@ var string = {
           return char;
       }
     }));
+  },
+  gImpl: () => (ast) => {
+    const lexical = ast.replaceAll(/["\\\t\n\r\b\f]/gu, (char) => {
+      switch (char) {
+        case "	":
+          return "\\t";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case '"':
+          return '\\"';
+        case "\\":
+          return "\\\\";
+        default:
+          return char;
+      }
+    });
+    return `"${lexical}"`;
   }
 };
 var iri2 = {
@@ -10511,7 +10533,8 @@ var iri2 = {
       return ACTION(() => C.dataFactory.namedNode(resolveIRI(iriVal, C.baseIRI)));
     } },
     { ALT: () => SUBRULE(prefixedName, void 0) }
-  ])
+  ]),
+  gImpl: () => (ast) => `<${ast.value}>`
 };
 var prefixedName = {
   name: "prefixedName",
@@ -10554,7 +10577,8 @@ var blankNode = {
       }
     });
     return result;
-  }
+  },
+  gImpl: () => (ast) => `_:${ast.value}`
 };
 
 // ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
@@ -10566,7 +10590,8 @@ var datasetClause = {
       { ALT: () => ({ value: SUBRULE(defaultGraphClause, void 0), type: "default" }) },
       { ALT: () => ({ value: SUBRULE(namedGraphClause, void 0), type: "named" }) }
     ]);
-  }
+  },
+  gImpl: () => (ast) => `FROM ${ast.type}`
 };
 var defaultGraphClause = {
   name: "defaultGraphClause",
@@ -10579,24 +10604,195 @@ var namedGraphClause = {
     return SUBRULE(sourceSelector, void 0);
   }
 };
-var sourceSelector = {
-  name: "sourceSelector",
-  impl: ({ SUBRULE }) => () => SUBRULE(iri2, void 0)
-};
+var sourceSelector = {
+  name: "sourceSelector",
+  impl: ({ SUBRULE }) => () => SUBRULE(iri2, void 0)
+};
+
+// ../rules-sparql-1-1/lib/grammar/general.ts
+var prologue = {
+  name: "prologue",
+  impl: ({ ACTION, SUBRULE, MANY, OR }) => (C) => {
+    const result = ACTION(() => ({
+      prefixes: {},
+      ...C.baseIRI && { base: C.baseIRI }
+    }));
+    MANY(() => {
+      OR([
+        {
+          ALT: () => {
+            const base = SUBRULE(baseDecl2, void 0);
+            ACTION(() => result.base = base);
+          }
+        },
+        {
+          ALT: () => {
+            const pref = SUBRULE(prefixDecl2, void 0);
+            ACTION(() => {
+              const [name, value] = pref;
+              result.prefixes[name] = value;
+            });
+          }
+        }
+      ]);
+    });
+    return result;
+  },
+  gImpl: () => (ast) => {
+    const rules = [];
+    if (ast.base) {
+      rules.push(`BASE <${ast.base}>`);
+    }
+    for (const [key, value] of Object.entries(ast.prefixes)) {
+      rules.push(`PREFIX ${key}: <${value}>`);
+    }
+    return rules.join("\n");
+  }
+};
+var baseDecl2 = {
+  name: "baseDecl",
+  impl: ({ CONSUME, ACTION }) => (C) => {
+    CONSUME(baseDecl);
+    const base = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
+    return ACTION(() => {
+      C.baseIRI = base;
+      return base;
+    });
+  }
+};
+var prefixDecl2 = {
+  name: "prefixDecl",
+  impl: ({ CONSUME, ACTION }) => (C) => {
+    CONSUME(prefixDecl);
+    const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
+    const value = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
+    return ACTION(() => {
+      const fullIri = resolveIRI(value, C.baseIRI);
+      C.prefixes[name] = fullIri;
+      return [name, fullIri];
+    });
+  }
+};
+var verb = {
+  name: "verb",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(varOrIri, void 0) },
+    {
+      ALT: () => SUBRULE(verbA, void 0)
+    }
+  ])
+};
+var verbA = {
+  name: "VerbA",
+  impl: ({ ACTION, CONSUME }) => (C) => {
+    CONSUME(a);
+    return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
+  }
+};
+var varOrTerm = {
+  name: "varOrTerm",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
+    { ALT: () => SUBRULE(graphTerm, void 0) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.termType === "Variable") {
+      return SUBRULE(var_, ast, void 0);
+    }
+    if (ast.termType === "NamedNode") {
+      return SUBRULE(iri2, ast, void 0);
+    }
+    if (ast.termType === "BlankNode") {
+      return SUBRULE(blankNode, ast, void 0);
+    }
+    return SUBRULE(rdfLiteral, ast, void 0);
+  }
+};
+var varOrIri = {
+  name: "varOrIri",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
+    { ALT: () => SUBRULE(iri2, void 0) }
+  ])
+};
+var var_ = {
+  name: "var",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const varVal = OR([
+      { ALT: () => CONSUME(terminals_exports.var1).image.slice(1) },
+      { ALT: () => CONSUME(terminals_exports.var2).image.slice(1) }
+    ]);
+    ACTION(() => {
+      if (!C.parseMode.has("canParseVars")) {
+        throw new Error("Variables are not allowed here");
+      }
+    });
+    return ACTION(() => C.dataFactory.variable(varVal));
+  },
+  gImpl: () => (ast) => `?${ast.value}`
+};
+var graphTerm = {
+  name: "graphTerm",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
+    { ALT: () => SUBRULE(iri2, void 0) },
+    { ALT: () => SUBRULE(rdfLiteral, void 0) },
+    { ALT: () => SUBRULE(numericLiteral, void 0) },
+    { ALT: () => SUBRULE(booleanLiteral, void 0) },
+    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode, void 0) },
+    {
+      ALT: () => {
+        CONSUME(terminals_exports.nil);
+        return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
+      }
+    }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    switch (ast.termType) {
+      case "BlankNode":
+        return SUBRULE(blankNode, ast, void 0);
+      case "NamedNode":
+        return SUBRULE(iri2, ast, void 0);
+      case "Literal":
+        return SUBRULE(rdfLiteral, ast, void 0);
+    }
+  }
+};
+
+// ../rules-sparql-1-1/lib/utils.ts
+function deGroupSingle(group) {
+  return group.patterns.length === 1 ? group.patterns[0] : group;
+}
+function isVariable(term) {
+  return "termType" in term && term.termType === "Variable";
+}
 
 // ../rules-sparql-1-1/lib/grammar/propertyPaths.ts
 var path = {
   name: "path",
-  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative, void 0),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if ("type" in ast) {
+      if (ast.pathType === "/" || ast.pathType === "|") {
+        return `( ${ast.items.map((item) => SUBRULE(path, item, void 0)).join(ast.pathType)} )`;
+      }
+      if (ast.pathType === "^" || ast.pathType === "!") {
+        return `${ast.pathType}${SUBRULE(path, ast.items[0], void 0)}`;
+      }
+      if (ast.pathType === "*" || ast.pathType === "+" || ast.pathType === "?") {
+        return `( ${SUBRULE(path, ast.items[0], void 0)} )${ast.pathType}`;
+      }
+    }
+    return SUBRULE(iri2, ast, void 0);
+  }
 };
 function pathHelper(name, SEP, pathType, subRule) {
   return {
     name,
-    impl: ({ SUBRULE2, AT_LEAST_ONE_SEP }) => () => {
+    impl: ({ SUBRULE, AT_LEAST_ONE_SEP }) => () => {
       const alternatives = [];
       AT_LEAST_ONE_SEP({
         DEF: () => {
-          alternatives.push(SUBRULE2(subRule, void 0));
+          alternatives.push(SUBRULE(subRule, void 0));
         },
         SEP
       });
@@ -10711,7 +10907,10 @@ var pathNegatedPropertySet = {
           SEP: symbols_exports.pipe
         });
         CONSUME(symbols_exports.RParen);
-        return items.length === 1 ? items : [{
+        if (items.length === 1) {
+          return items;
+        }
+        return [{
           type: "path",
           pathType: "|",
           items
@@ -10743,19 +10942,42 @@ var pathOneInPropertySet = {
 };
 
 // ../rules-sparql-1-1/lib/grammar/tripleBlock.ts
+function triplesDotSeperated(subRule) {
+  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => () => {
+    const triples = [];
+    let parsedDot = true;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(subRule, void 0);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          CONSUME(symbols_exports.dot);
+          parsedDot = true;
+        });
+      }
+    });
+    return triples;
+  };
+}
 var triplesBlock = {
   name: "triplesBlock",
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const triples = SUBRULE(triplesSameSubjectPath, void 0);
-    const pattern = OPTION1(() => {
-      CONSUME(symbols_exports.dot);
-      return OPTION2(() => SUBRULE(triplesBlock, void 0));
-    });
-    return ACTION(() => ({
-      type: "bgp",
-      triples: [...triples, ...pattern?.triples ?? []]
-    }));
-  }
+  impl: (implArgs) => (C) => ({
+    type: "bgp",
+    triples: triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C, void 0)
+  }),
+  gImpl: ({ SUBRULE }) => (ast) => ast.triples.map((triple) => {
+    const { subject, predicate, object: object3 } = triple;
+    return [subject, predicate, object3].map((part) => {
+      if ("type" in part) {
+        return SUBRULE(path, part, void 0);
+      }
+      return SUBRULE(varOrTerm, part, void 0);
+    }).join(" ");
+  }).join(" .\n")
 };
 function triplesSameSubjectImpl(name, allowPaths) {
   return {
@@ -10782,6 +11004,10 @@ function triplesSameSubjectImpl(name, allowPaths) {
 }
 var triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
 var triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
+var triplesTemplate = {
+  name: "triplesTemplate",
+  impl: triplesDotSeperated(triplesSameSubject)
+};
 function propertyListImpl(name, allowPaths) {
   return {
     name,
@@ -10886,12 +11112,10 @@ function blankNodePropertyListImpl(name, allowPaths) {
         { subject: ACTION(() => blankNode2 = C.dataFactory.blankNode()) }
       );
       CONSUME(symbols_exports.RSquare);
-      return ACTION(() => {
-        return {
-          node: blankNode2,
-          triples: propList
-        };
-      });
+      return ACTION(() => ({
+        node: blankNode2,
+        triples: propList
+      }));
     }
   };
 }
@@ -10908,216 +11132,70 @@ function collectionImpl(name, allowPaths) {
       });
       CONSUME(symbols_exports.RParen);
       return ACTION(() => {
-        const triples = [];
-        const appendTriples = [];
-        const listHead = C.dataFactory.blankNode();
-        let iterHead = listHead;
-        const predFirst = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */);
-        const predRest = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */);
-        for (const [index, term] of terms.entries()) {
-          const headTriple = {
-            subject: iterHead,
-            predicate: predFirst,
-            object: term.node
-          };
-          triples.push(headTriple);
-          appendTriples.push(...term.triples);
-          if (index === terms.length - 1) {
-            const nilTriple = {
-              subject: iterHead,
-              predicate: predRest,
-              object: C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */)
-            };
-            triples.push(nilTriple);
-          } else {
-            const tail = C.dataFactory.blankNode();
-            const linkTriple = {
-              subject: iterHead,
-              predicate: predRest,
-              object: tail
-            };
-            triples.push(linkTriple);
-            iterHead = tail;
-          }
-        }
-        return {
-          node: listHead,
-          triples: [...triples, ...appendTriples]
-        };
-      });
-    }
-  };
-}
-var collection = collectionImpl("collection", false);
-var collectionPath = collectionImpl("collectionPath", true);
-function graphNodeImpl(name, allowPaths) {
-  return {
-    name,
-    impl: ({ SUBRULE, OR }) => (C) => OR([
-      {
-        ALT: () => {
-          const val = SUBRULE(varOrTerm, void 0);
-          return {
-            node: val,
-            triples: []
-          };
-        }
-      },
-      {
-        GATE: () => C.parseMode.has("canCreateBlankNodes"),
-        ALT: () => SUBRULE(allowPaths ? triplesNodePath : triplesNode, void 0)
-      }
-    ])
-  };
-}
-var graphNode = graphNodeImpl("graphNode", false);
-var graphNodePath = graphNodeImpl("graphNodePath", true);
-
-// ../rules-sparql-1-1/lib/grammar/general.ts
-var prologue = {
-  name: "prologue",
-  impl: ({ ACTION, SUBRULE, MANY, OR }) => (C) => {
-    const result = ACTION(() => ({
-      prefixes: {},
-      ...C.baseIRI && { base: C.baseIRI }
-    }));
-    MANY(() => {
-      OR([
-        {
-          ALT: () => {
-            const base = SUBRULE(baseDecl2, void 0);
-            ACTION(() => result.base = base);
-          }
-        },
-        {
-          ALT: () => {
-            const pref = SUBRULE(prefixDecl2, void 0);
-            ACTION(() => {
-              const [name, value] = pref;
-              result.prefixes[name] = value;
-            });
-          }
-        }
-      ]);
-    });
-    return result;
-  }
-};
-var baseDecl2 = {
-  name: "baseDecl",
-  impl: ({ CONSUME, ACTION }) => (C) => {
-    CONSUME(baseDecl);
-    const base = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
-    return ACTION(() => {
-      C.baseIRI = base;
-      return base;
-    });
-  }
-};
-var prefixDecl2 = {
-  name: "prefixDecl",
-  impl: ({ CONSUME, ACTION }) => (C) => {
-    CONSUME(prefixDecl);
-    const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
-    const value = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
-    return ACTION(() => {
-      const fullIri = resolveIRI(value, C.baseIRI);
-      C.prefixes[name] = fullIri;
-      return [name, fullIri];
-    });
-  }
-};
-var triplesTemplate = {
-  name: "triplesTemplate",
-  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => () => {
-    const triples = [];
-    let parsedDot = true;
-    AT_LEAST_ONE({
-      GATE: () => parsedDot,
-      DEF: () => {
-        parsedDot = false;
-        const template = SUBRULE(triplesSameSubject, void 0);
-        ACTION(() => {
-          triples.push(...template);
-        });
-        OPTION(() => {
-          CONSUME(symbols_exports.dot);
-          parsedDot = true;
-        });
-      }
-    });
-    return triples;
-  }
-};
-var verb = {
-  name: "verb",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(varOrIri, void 0) },
-    {
-      ALT: () => SUBRULE(verbA, void 0)
-    }
-  ])
-};
-var verbA = {
-  name: "VerbA",
-  impl: ({ ACTION, CONSUME }) => (C) => {
-    CONSUME(a);
-    return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
-  }
-};
-var varOrTerm = {
-  name: "varOrTerm",
-  impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
-    { ALT: () => SUBRULE(graphTerm, void 0) }
-  ])
-};
-var varOrIri = {
-  name: "varOrIri",
-  impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
-    { ALT: () => SUBRULE(iri2, void 0) }
-  ])
-};
-var var_ = {
-  name: "var",
-  impl: ({ ACTION, CONSUME, OR }) => (C) => {
-    const varVal = OR([
-      { ALT: () => CONSUME(terminals_exports.var1).image.slice(1) },
-      { ALT: () => CONSUME(terminals_exports.var2).image.slice(1) }
-    ]);
-    ACTION(() => {
-      if (!C.parseMode.has("canParseVars")) {
-        throw new Error("Variables are not allowed here");
-      }
-    });
-    return ACTION(() => C.dataFactory.variable(varVal));
-  }
-};
-var graphTerm = {
-  name: "graphTerm",
-  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
-    { ALT: () => SUBRULE(iri2, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral, void 0) },
-    { ALT: () => SUBRULE(numericLiteral, void 0) },
-    { ALT: () => SUBRULE(booleanLiteral, void 0) },
-    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode, void 0) },
-    {
-      ALT: () => {
-        CONSUME(terminals_exports.nil);
-        return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
-      }
+        const triples = [];
+        const appendTriples = [];
+        const listHead = C.dataFactory.blankNode();
+        let iterHead = listHead;
+        const predFirst = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */);
+        const predRest = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */);
+        for (const [index, term] of terms.entries()) {
+          const headTriple = {
+            subject: iterHead,
+            predicate: predFirst,
+            object: term.node
+          };
+          triples.push(headTriple);
+          appendTriples.push(...term.triples);
+          if (index === terms.length - 1) {
+            const nilTriple = {
+              subject: iterHead,
+              predicate: predRest,
+              object: C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */)
+            };
+            triples.push(nilTriple);
+          } else {
+            const tail = C.dataFactory.blankNode();
+            const linkTriple = {
+              subject: iterHead,
+              predicate: predRest,
+              object: tail
+            };
+            triples.push(linkTriple);
+            iterHead = tail;
+          }
+        }
+        return {
+          node: listHead,
+          triples: [...triples, ...appendTriples]
+        };
+      });
     }
-  ])
-};
-
-// ../rules-sparql-1-1/lib/utils.ts
-function deGroupSingle(group) {
-  return group.patterns.length === 1 ? group.patterns[0] : group;
+  };
 }
-function isVariable(term) {
-  return "termType" in term && term.termType === "Variable";
+var collection = collectionImpl("collection", false);
+var collectionPath = collectionImpl("collectionPath", true);
+function graphNodeImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ SUBRULE, OR }) => (C) => OR([
+      {
+        ALT: () => {
+          const val = SUBRULE(varOrTerm, void 0);
+          return {
+            node: val,
+            triples: []
+          };
+        }
+      },
+      {
+        GATE: () => C.parseMode.has("canCreateBlankNodes"),
+        ALT: () => SUBRULE(allowPaths ? triplesNodePath : triplesNode, void 0)
+      }
+    ])
+  };
 }
+var graphNode = graphNodeImpl("graphNode", false);
+var graphNodePath = graphNodeImpl("graphNodePath", true);
 
 // ../rules-sparql-1-1/lib/grammar/whereClause.ts
 var whereClause = {
@@ -11143,6 +11221,21 @@ var groupGraphPattern = {
       type: "group",
       patterns
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const patterns = ast.patterns;
+    const builder = ["{\n"];
+    for (const pattern of patterns) {
+      if ("queryType" in pattern) {
+        builder.push(SUBRULE(query, { ...pattern, prefixes: {} }, void 0));
+      } else if (pattern.type === "bgp") {
+        builder.push(SUBRULE(triplesBlock, pattern, void 0));
+      } else {
+        builder.push(SUBRULE(graphPatternNotTriples, pattern, void 0));
+      }
+    }
+    builder.push("\n}");
+    return builder.join(" ");
   }
 };
 function findBoundVarsFromGroupGraphPattern(pattern, boundedVars) {
@@ -11211,7 +11304,28 @@ var graphPatternNotTriples = {
     { ALT: () => SUBRULE(filter3, void 0) },
     { ALT: () => SUBRULE(bind2, void 0) },
     { ALT: () => SUBRULE(inlineData, void 0) }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    switch (ast.type) {
+      case "group":
+      case "union":
+        return SUBRULE(groupOrUnionGraphPattern, ast, void 0);
+      case "optional":
+        return SUBRULE(optionalGraphPattern, ast, void 0);
+      case "minus":
+        return SUBRULE(minusGraphPattern, ast, void 0);
+      case "graph":
+        return SUBRULE(graphGraphPattern, ast, void 0);
+      case "service":
+        return SUBRULE(serviceGraphPattern, ast, void 0);
+      case "filter":
+        return SUBRULE(filter3, ast, void 0);
+      case "bind":
+        return SUBRULE(bind2, ast, void 0);
+      case "values":
+        return SUBRULE(valuesClause, ast.values, void 0);
+    }
+  }
 };
 var optionalGraphPattern = {
   name: "optionalGraphPattern",
@@ -11222,7 +11336,8 @@ var optionalGraphPattern = {
       type: "optional",
       patterns: group.patterns
     }));
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `OPTIONAL ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.patterns }, void 0)}`
 };
 var graphGraphPattern = {
   name: "graphGraphPattern",
@@ -11235,7 +11350,8 @@ var graphGraphPattern = {
       name,
       patterns: group.patterns
     }));
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `GRAPH ${SUBRULE(varOrTerm, ast.name, void 0)} ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.patterns }, void 0)}`
 };
 var serviceGraphPattern = {
   name: "serviceGraphPattern",
@@ -11250,7 +11366,8 @@ var serviceGraphPattern = {
       silent: silent2,
       patterns: group.patterns
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `SERVICE ${ast.silent ? "SILENT " : ""}${SUBRULE(varOrTerm, ast.name, void 0)} ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.patterns }, void 0)}`
 };
 var bind2 = {
   name: "bind",
@@ -11266,7 +11383,8 @@ var bind2 = {
       variable,
       expression: expressionVal
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `BIND ( ${SUBRULE(expression, ast.expression, void 0)} AS ${SUBRULE(var_, ast.variable, void 0)} )`
 };
 var inlineData = {
   name: "inlineData",
@@ -11358,7 +11476,19 @@ var inlineDataFull = {
         return res;
       }
     }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const variables = Object.keys(ast[0]);
+    const variableString = `( ${variables.join(" ")} )`;
+    const values3 = ast.map((mapping) => {
+      const valueString = variables.map((variable) => {
+        const value = mapping[variable];
+        return value ? SUBRULE(dataBlockValue, value, void 0) : "UNDEF";
+      }).join(" ");
+      return `( ${valueString} )`;
+    });
+    return `VALUES ${variableString} { ${values3.join(" ")} }`;
+  }
 };
 var dataBlockValue = {
   name: "dataBlockValue",
@@ -11373,7 +11503,13 @@ var dataBlockValue = {
         return void 0;
       }
     }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast) {
+      return SUBRULE(graphTerm, ast, void 0);
+    }
+    return "UNDEF";
+  }
 };
 var minusGraphPattern = {
   name: "minusGraphPattern",
@@ -11384,7 +11520,8 @@ var minusGraphPattern = {
       type: "minus",
       patterns: group.patterns
     }));
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `MINUS ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.patterns }, void 0)}`
 };
 var groupOrUnionGraphPattern = {
   name: "groupOrUnionGraphPattern",
@@ -11401,6 +11538,15 @@ var groupOrUnionGraphPattern = {
       type: "union",
       patterns: groups.map((group) => deGroupSingle(group))
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.type === "group") {
+      return SUBRULE(groupGraphPattern, ast, void 0);
+    }
+    return ast.patterns.map((pattern) => SUBRULE(groupGraphPattern, {
+      type: "group",
+      patterns: [pattern]
+    }, void 0)).join(" UNION ");
   }
 };
 var filter3 = {
@@ -11412,7 +11558,8 @@ var filter3 = {
       type: "filter",
       expression: expression2
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `FILTER ( ${SUBRULE(expression, ast.expression, void 0)} )`
 };
 var constraint = {
   name: "constraint",
@@ -11857,6 +12004,22 @@ var aggregate = {
       }
     });
     return result;
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = [ast.aggregation, "("];
+    if (ast.distinct) {
+      builder.push("DISTINCT");
+    }
+    if ("termType" in ast.expression && ast.expression.termType === "Wildcard") {
+      builder.push("*");
+    } else {
+      builder.push(SUBRULE(expression, ast.expression, void 0));
+    }
+    if (ast.separator !== void 0 && ast.separator !== " ") {
+      builder.push(";", "SEPARATOR", "=", SUBRULE(string, ast.separator, void 0));
+    }
+    builder.push(")");
+    return builder.join(" ");
   }
 };
 
@@ -11891,7 +12054,16 @@ var argList = {
         };
       }
     }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["("];
+    if (ast.distinct) {
+      builder.push("DISTINCT");
+    }
+    builder.push(SUBRULE(expression, ast.args, void 0).slice(1, -1));
+    builder.push(")");
+    return builder.join(" ");
+  }
 };
 var expressionList = {
   name: "expressionList",
@@ -11920,7 +12092,46 @@ var expressionList = {
 };
 var expression = {
   name: "expression",
-  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression, void 0),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (Array.isArray(ast)) {
+      return `( ${ast.map((arg) => SUBRULE(expression, arg, void 0)).join(", ")} )`;
+    }
+    if ("type" in ast) {
+      if (ast.type === "operation") {
+        if (["||", "&&", "=", "!=", "<", ">", "<=", ">=", "in", "+", "-", "*", "/"].includes(ast.operator)) {
+          const [left, right] = ast.args;
+          return `( ${SUBRULE(expression, left, void 0)} ${ast.operator} ${SUBRULE(expression, right, void 0)} )`;
+        }
+        if (ast.operator === "notin") {
+          const [left, right] = ast.args;
+          return `( ${SUBRULE(expression, left, void 0)} NOT IN ${SUBRULE(expression, right, void 0)} )`;
+        }
+        if (["!", "UPLUS", "UMINUS"].includes(ast.operator)) {
+          const [expr] = ast.args;
+          return `${ast.operator}${SUBRULE(expression, expr, void 0)}`;
+        }
+        if (["in", "notin"].includes(ast.operator)) {
+          const [first2, rest] = ast.args;
+          const operator = ast.operator === "in" ? "IN" : "NOT IN";
+          return `${SUBRULE(expression, first2, void 0)} ${operator} ( ${SUBRULE(expression, rest, void 0)} )`;
+        }
+        if (["exists", "notexists"].includes(ast.operator)) {
+          const patterns = ast.args;
+          const operator = ast.operator === "exists" ? "EXISTS" : "NOT EXISTS";
+          return `${operator} ${SUBRULE(groupGraphPattern, { type: "group", patterns }, void 0)}`;
+        }
+        return `${ast.operator}( ${ast.args.map((arg) => SUBRULE(expression, arg, void 0)).join(", ")} )`;
+      }
+      if (ast.type === "functionCall") {
+        return SUBRULE(iriOrFunction, ast, void 0);
+      }
+      if (ast.type === "aggregate") {
+        return SUBRULE(aggregate, ast, void 0);
+      }
+    }
+    return SUBRULE(varOrTerm, ast, void 0);
+  }
 };
 function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
   let iterExpr = startGenerator();
@@ -12229,6 +12440,12 @@ var iriOrFunction = {
       ...args,
       function: iriVal
     } : iriVal;
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if ("function" in ast) {
+      return `${SUBRULE(iri2, ast.function, void 0)}${SUBRULE(argList, ast, void 0)}`;
+    }
+    return SUBRULE(iri2, ast, void 0);
   }
 };
 
@@ -12246,6 +12463,13 @@ var solutionModifier = {
       ...having2 && { having: having2 },
       ...order2 && { order: order2 }
     }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const group = ast.group ? SUBRULE(groupClause, ast.group, void 0) : "";
+    const having2 = ast.having ? SUBRULE(havingClause, ast.having, void 0) : "";
+    const order2 = ast.order ? SUBRULE(orderClause, ast.order, void 0) : "";
+    const limit2 = SUBRULE(limitOffsetClauses, ast, void 0);
+    return [group, having2, order2, limit2].filter(Boolean).join(" ");
   }
 };
 var groupClause = {
@@ -12257,7 +12481,8 @@ var groupClause = {
       groupings.push(SUBRULE(groupCondition, void 0));
     });
     return groupings;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `GROUP BY ${ast.map((group) => SUBRULE(groupCondition, group, void 0)).join(" ")}`
 };
 var groupCondition = {
   name: "groupCondition",
@@ -12295,7 +12520,13 @@ var groupCondition = {
         expression: expression2
       };
     } }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.variable) {
+      return `(${SUBRULE(expression, ast.expression, void 0)} AS ${SUBRULE(var_, ast.variable, void 0)})`;
+    }
+    return SUBRULE(expression, ast.expression, void 0);
+  }
 };
 var havingClause = {
   name: "havingClause",
@@ -12308,7 +12539,8 @@ var havingClause = {
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return expressions;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `HAVING ${ast.map((having2) => `( ${SUBRULE(expression, having2, void 0)} )`).join(" ")}`
 };
 var havingCondition = {
   name: "havingCondition",
@@ -12325,7 +12557,8 @@ var orderClause = {
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return orderings;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `ORDER BY ${ast.map((order2) => SUBRULE(orderCondition, order2, void 0)).join(" ")}`
 };
 var orderCondition = {
   name: "orderCondition",
@@ -12361,7 +12594,15 @@ var orderCondition = {
         expression: expr
       };
     } }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = [];
+    if (ast.descending) {
+      builder.push("DESC");
+    }
+    builder.push("(", SUBRULE(expression, ast.expression, void 0), ")");
+    return builder.join(" ");
+  }
 };
 var limitOffsetClauses = {
   name: "limitOffsetClauses",
@@ -12386,7 +12627,17 @@ var limitOffsetClauses = {
         };
       }
     }
-  ])
+  ]),
+  gImpl: () => (ast) => {
+    const builder = [];
+    if (ast.limit) {
+      builder.push(`LIMIT ${String(ast.limit)}`);
+    }
+    if (ast.offset) {
+      builder.push(`OFFSET ${String(ast.offset)}`);
+    }
+    return builder.join(" ");
+  }
 };
 var limitClause = {
   name: "limitClause",
@@ -12425,6 +12676,26 @@ var query = {
       type: "query",
       ...values3 && { values: values3 }
     }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const prologueString = SUBRULE(prologue, ast, void 0);
+    let queryString = "";
+    switch (ast.queryType) {
+      case "SELECT":
+        queryString = SUBRULE(selectQuery, ast, void 0);
+        break;
+      case "CONSTRUCT":
+        queryString = SUBRULE(constructQuery, ast, void 0);
+        break;
+      case "DESCRIBE":
+        queryString = SUBRULE(describeQuery, ast, void 0);
+        break;
+      case "ASK":
+        queryString = SUBRULE(askQuery, ast, void 0);
+        break;
+    }
+    const valuesString = ast.values ? SUBRULE(valuesClause, ast.values, void 0) : "";
+    return [prologueString, queryString, valuesString].filter(Boolean).join(" ");
   }
 };
 function extractFromOfDataSetClauses(ACTION, MANY, SUBRULE) {
@@ -12548,6 +12819,14 @@ var selectQuery = {
       where: where2,
       ...modifier
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const selectString = SUBRULE(selectClause, ast, void 0);
+    const fromDefaultString = ast.from?.default.map((clause) => `FROM ${SUBRULE(iri2, clause, void 0)}`).join(" ") ?? "";
+    const fromNamedString = ast.from?.named.map((clause) => `FROM NAMED ${SUBRULE(iri2, clause, void 0)}`).join(" ") ?? "";
+    const whereString = ast.where ? `WHERE ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.where }, void 0)}` : "";
+    const modifierString = SUBRULE(solutionModifier, ast, void 0);
+    return [selectString, fromDefaultString, fromNamedString, whereString, modifierString].filter(Boolean).join(" ");
   }
 };
 var subSelect = {
@@ -12627,6 +12906,26 @@ var selectClause = {
       ...distinctOrReduced,
       variables
     }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["SELECT"];
+    if (ast.distinct) {
+      builder.push("DISTINCT");
+    } else if (ast.reduced) {
+      builder.push("REDUCED");
+    }
+    if (ast.variables.length === 1 && ast.variables[0] instanceof Wildcard) {
+      builder.push("*");
+    } else {
+      for (const variable of ast.variables) {
+        if ("expression" in variable) {
+          builder.push(`( ${SUBRULE(expression, variable.expression, void 0)} AS ${SUBRULE(var_, variable.variable, void 0)} )`);
+        } else {
+          builder.push(SUBRULE(var_, variable, void 0));
+        }
+      }
+    }
+    return builder.join(" ");
   }
 };
 var constructQuery = {
@@ -12671,6 +12970,14 @@ var constructQuery = {
         }
       }
     ]);
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const constructString = SUBRULE(constructTemplate, ast.template, void 0);
+    const fromDefaultString = ast.from?.default.map((clause) => `FROM ${SUBRULE(iri2, clause, void 0)}`).join(" ") ?? "";
+    const fromNamedString = ast.from?.named.map((clause) => `FROM NAMED ${SUBRULE(iri2, clause, void 0)}`).join(" ") ?? "";
+    const whereString = ast.where ? `WHERE ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.where }, void 0)}` : "";
+    const modifierString = SUBRULE(solutionModifier, ast, void 0);
+    return ["CONSTRUCT", constructString, fromDefaultString, fromNamedString, whereString, modifierString].filter(Boolean).join(" ");
   }
 };
 var describeQuery = {
@@ -12700,6 +13007,25 @@ var describeQuery = {
       from: from2,
       where: where2
     }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["DESCRIBE"];
+    for (const variable of ast.variables) {
+      if (variable.termType === "Wildcard") {
+        builder.push("*");
+      } else {
+        builder.push(SUBRULE(varOrTerm, variable, void 0));
+      }
+    }
+    if (ast.from) {
+      builder.push(ast.from.default.map((clause) => `FROM ${SUBRULE(iri2, clause, void 0)}`).join(" "));
+      builder.push(ast.from.named.map((clause) => `FROM NAMED ${SUBRULE(iri2, clause, void 0)}`).join(" "));
+    }
+    if (ast.where) {
+      builder.push(`WHERE ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.where }, void 0)}`);
+    }
+    builder.push(SUBRULE(solutionModifier, ast, void 0));
+    return builder.join(" ");
   }
 };
 var askQuery = {
@@ -12715,6 +13041,18 @@ var askQuery = {
       from: from2,
       where: where2
     }));
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["ASK"];
+    if (ast.from) {
+      builder.push(ast.from.default.map((clause) => `FROM ${SUBRULE(iri2, clause, void 0)}`).join(" "));
+      builder.push(ast.from.named.map((clause) => `FROM NAMED ${SUBRULE(iri2, clause, void 0)}`).join(" "));
+    }
+    if (ast.where) {
+      builder.push(`WHERE ${SUBRULE(groupGraphPattern, { type: "group", patterns: ast.where }, void 0)}`);
+    }
+    builder.push(SUBRULE(solutionModifier, ast, void 0));
+    return builder.join(" ");
   }
 };
 var valuesClause = {
@@ -12722,7 +13060,13 @@ var valuesClause = {
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => OPTION(() => {
     CONSUME(values2);
     return SUBRULE(dataBlock, void 0);
-  })
+  }),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast) {
+      return `${SUBRULE(inlineDataFull, ast, void 0)}`;
+    }
+    return "";
+  }
 };
 var constructTemplate = {
   name: "constructTemplate",
@@ -12731,21 +13075,14 @@ var constructTemplate = {
     const triples = OPTION(() => SUBRULE(constructTriples, void 0));
     CONSUME(symbols_exports.RCurly);
     return triples;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `{
+${ast ? SUBRULE(triplesBlock, { type: "bgp", triples: ast }, void 0) : ""}
+}`
 };
 var constructTriples = {
   name: "constructTriples",
-  impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const triples = [];
-    triples.push(SUBRULE(triplesSameSubject, void 0));
-    OPTION1(() => {
-      CONSUME(symbols_exports.dot);
-      OPTION2(() => {
-        triples.push(SUBRULE(constructTriples, void 0));
-      });
-    });
-    return triples.flat(1);
-  }
+  impl: triplesTemplate.impl
 };
 
 // ../rules-sparql-1-1/lib/grammar/updateUnit/updateUnit.ts
@@ -12759,30 +13096,37 @@ var updateUnit = {
 };
 var update = {
   name: "update",
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const prologueValues = SUBRULE(prologue, void 0);
+  impl: ({ ACTION, SUBRULE, SUBRULE1, SUBRULE2, CONSUME, OPTION1, MANY }) => () => {
+    const prologueValues = SUBRULE1(prologue, void 0);
     const result = {
       type: "update",
       base: prologueValues.base,
       prefixes: prologueValues.prefixes,
       updates: []
     };
-    OPTION1(() => {
-      const updateOperation = SUBRULE(update1, void 0);
-      const recursiveRes = OPTION2(() => {
-        CONSUME(symbols_exports.semi);
-        return SUBRULE(update, void 0);
-      });
-      return ACTION(() => {
+    let parsedSemi = true;
+    MANY({
+      GATE: () => parsedSemi,
+      DEF: () => {
+        const updateOperation = SUBRULE(update1, void 0);
         result.updates.push(updateOperation);
-        if (recursiveRes) {
-          result.updates.push(...recursiveRes.updates);
-          result.base = recursiveRes.base ?? result.base;
-          result.prefixes = recursiveRes.prefixes ? { ...result.prefixes, ...recursiveRes.prefixes } : result.prefixes;
-        }
-      });
+        OPTION1(() => {
+          CONSUME(symbols_exports.semi);
+          parsedSemi = true;
+          SUBRULE2(prologue, void 0);
+          ACTION(() => {
+            result.base = prologueValues.base ?? result.base;
+            result.prefixes = prologueValues.prefixes ? { ...result.prefixes, ...prologueValues.prefixes } : result.prefixes;
+          });
+        });
+      }
     });
     return result;
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const prologueString = SUBRULE(prologue, ast, void 0);
+    const updates = ast.updates.map((update2) => SUBRULE(update1, update2, void 0)).join(" ;\n");
+    return `${prologueString} ${updates}`;
   }
 };
 var update1 = {
@@ -12799,7 +13143,37 @@ var update1 = {
     { ALT: () => SUBRULE(deleteData, void 0) },
     { ALT: () => SUBRULE(deleteWhere, void 0) },
     { ALT: () => SUBRULE(modify, void 0) }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if ("type" in ast) {
+      switch (ast.type) {
+        case "load":
+          return SUBRULE(load2, ast, void 0);
+        case "clear":
+          return SUBRULE(clear2, ast, void 0);
+        case "drop":
+          return SUBRULE(drop3, ast, void 0);
+        case "add":
+          return SUBRULE(add2, ast, void 0);
+        case "move":
+          return SUBRULE(move2, ast, void 0);
+        case "copy":
+          return SUBRULE(copy2, ast, void 0);
+        case "create":
+          return SUBRULE(create2, ast, void 0);
+      }
+    }
+    switch (ast.updateType) {
+      case "insert":
+        return SUBRULE(insertData, ast, void 0);
+      case "delete":
+        return SUBRULE(deleteData, ast, void 0);
+      case "deletewhere":
+        return SUBRULE(deleteWhere, ast, void 0);
+      case "insertdelete":
+        return SUBRULE(modify, ast, void 0);
+    }
+  }
 };
 var load2 = {
   name: "load",
@@ -12817,6 +13191,17 @@ var load2 = {
       source,
       ...destination && { destination }
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["LOAD"];
+    if (ast.silent) {
+      builder.push("SILENT");
+    }
+    builder.push(SUBRULE(iri2, ast.source, void 0));
+    if (ast.destination) {
+      builder.push("INTO", SUBRULE(graphRef, ast.destination, void 0));
+    }
+    return builder.join(" ");
   }
 };
 var clear2 = {
@@ -12830,6 +13215,14 @@ var clear2 = {
       silent: silent2,
       graph: graph2
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["CLEAR"];
+    if (ast.silent) {
+      builder.push("SILENT");
+    }
+    builder.push(SUBRULE(graphRefAll, ast.graph, void 0));
+    return builder.join(" ");
   }
 };
 var drop3 = {
@@ -12843,6 +13236,14 @@ var drop3 = {
       silent: silent2,
       graph: graph2
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["DROP"];
+    if (ast.silent) {
+      builder.push("SILENT");
+    }
+    builder.push(SUBRULE(graphRefAll, ast.graph, void 0));
+    return builder.join(" ");
   }
 };
 var create2 = {
@@ -12859,6 +13260,14 @@ var create2 = {
         name: graph2
       }
     };
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = ["CREATE"];
+    if (ast.silent) {
+      builder.push("SILENT");
+    }
+    builder.push(SUBRULE(graphRef, ast.graph.name, void 0));
+    return builder.join(" ");
   }
 };
 function copyMoveAddOperation(operation) {
@@ -12876,6 +13285,15 @@ function copyMoveAddOperation(operation) {
         source,
         destination
       };
+    },
+    gImpl: ({ SUBRULE }) => (ast) => {
+      const builder = [operation.name.toUpperCase()];
+      if (ast.silent) {
+        builder.push("SILENT");
+      }
+      builder.push(SUBRULE(graphOrDefault, ast.source, void 0));
+      builder.push("TO", SUBRULE(graphOrDefault, ast.destination, void 0));
+      return builder.join(" ");
     }
   };
 }
@@ -12892,7 +13310,8 @@ var insertData = {
       updateType: "insert",
       insert
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `INSERT DATA ${SUBRULE(quadData, ast.insert, void 0)}`
 };
 var deleteData = {
   name: "deleteData",
@@ -12906,7 +13325,8 @@ var deleteData = {
       updateType: "delete",
       delete: del
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `DELETE DATA ${SUBRULE(quadData, ast.delete, void 0)}`
 };
 var deleteWhere = {
   name: "deleteWhere",
@@ -12920,7 +13340,8 @@ var deleteWhere = {
       updateType: "deletewhere",
       delete: del
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `DELETE WHERE ${SUBRULE(quadData, ast.delete, void 0)}`
 };
 var modify = {
   name: "modify",
@@ -12967,6 +13388,24 @@ var modify = {
         where: where2.patterns
       };
     });
+  },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const builder = [];
+    if (ast.graph) {
+      builder.push(`WITH ${SUBRULE(iri2, ast.graph, void 0)}`);
+    }
+    if (ast.delete.length > 0) {
+      builder.push(`DELETE ${SUBRULE(quadData, ast.delete, void 0)}`);
+    }
+    if (ast.insert.length > 0) {
+      builder.push(`INSERT ${SUBRULE(quadData, ast.insert, void 0)}`);
+    }
+    if (ast.using) {
+      builder.push(...ast.using.default.map((val) => `USING ${SUBRULE(iri2, val, void 0)}`));
+      builder.push(...ast.using.named.map((val) => `USING NAMED ${SUBRULE(iri2, val, void 0)}`));
+    }
+    builder.push("WHERE", SUBRULE(groupGraphPattern, { type: "group", patterns: ast.where }, void 0));
+    return builder.join(" ");
   }
 };
 var deleteClause2 = {
@@ -13022,14 +13461,21 @@ var graphOrDefault = {
         };
       }
     }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.default) {
+      return "DEFAULT";
+    }
+    return SUBRULE(iri2, ast.name, void 0);
+  }
 };
 var graphRef = {
   name: "graphRef",
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(graph_exports.graph);
     return SUBRULE(iri2, void 0);
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `GRAPH ${SUBRULE(iri2, ast, void 0)}`
 };
 var graphRefAll = {
   name: "graphRefAll",
@@ -13050,7 +13496,19 @@ var graphRefAll = {
       CONSUME(graph_exports.graphAll);
       return { all: true };
     } }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.all) {
+      return "ALL";
+    }
+    if (ast.default) {
+      return "DEFAULT";
+    }
+    if (ast.named) {
+      return "NAMED";
+    }
+    return SUBRULE(graphRef, ast.name, void 0);
+  }
 };
 var quadPattern = {
   name: "quadPattern",
@@ -13070,7 +13528,8 @@ var quadData = {
     ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
     CONSUME(symbols_exports.RCurly);
     return val;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `{ ${SUBRULE(quads, ast, void 0)} }`
 };
 var quads = {
   name: "quads",
@@ -13095,7 +13554,13 @@ var quads = {
       });
     });
     return quads2;
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => ast.map((quad) => {
+    if (quad.type === "bgp") {
+      return SUBRULE(triplesBlock, quad, void 0);
+    }
+    return SUBRULE(quadsNotTriples, quad, void 0);
+  }).join(" ")
 };
 var quadsNotTriples = {
   name: "quadsNotTriples",
@@ -13110,10 +13575,34 @@ var quadsNotTriples = {
       name,
       triples
     };
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `GRAPH ${SUBRULE(varOrTerm, ast.name, void 0)} {
+${SUBRULE(triplesBlock, { ...ast, type: "bgp" }, void 0)}
+}`
 };
 
 // lib/lexer.ts
+var lexer_exports2 = {};
+__export(lexer_exports2, {
+  LANG_DIR: () => LANG_DIR,
+  annotationClose: () => annotationClose,
+  annotationOpen: () => annotationOpen,
+  builtinHasLang: () => builtinHasLang,
+  builtinHasLangDir: () => builtinHasLangDir,
+  builtinIsTRIPLE: () => builtinIsTRIPLE,
+  builtinLangDir: () => builtinLangDir,
+  builtinOBJECT: () => builtinOBJECT,
+  builtinPREDICATE: () => builtinPREDICATE,
+  builtinSUBJECT: () => builtinSUBJECT,
+  builtinStrLangDir: () => builtinStrLangDir,
+  builtinTRIPLE: () => builtinTRIPLE,
+  reificationClose: () => reificationClose,
+  reificationOpen: () => reificationOpen,
+  sparql12Tokens: () => sparql12Tokens,
+  tilde: () => tilde,
+  tripleTermClose: () => tripleTermClose,
+  tripleTermOpen: () => tripleTermOpen
+});
 var tilde = createToken2({ name: "Tilde", pattern: "~", label: "~" });
 var annotationOpen = createToken2({ name: "AnnotationOpen", pattern: "{|", label: `Annotation Open: {|` });
 var annotationClose = createToken2({ name: "AnnotationClose", pattern: "|}", label: "Annotation Close |}" });
@@ -13140,7 +13629,7 @@ var builtinPREDICATE = createToken2({ name: "BuiltInPredicate", pattern: /predic
 var builtinOBJECT = createToken2({ name: "BuiltInObject", pattern: /object/i, label: "OBJECT" });
 var LANG_DIR = createToken2({
   name: "LANG_DIR",
-  pattern: /@[A-Za-z]+(?:-[\dA-Za-z]+)*(?:--[A-Za-z]+)?/,
+  pattern: /@[a-z]+(?:-[\da-z]+)*(?:--[a-z]+)?/i,
   label: "LANG_DIR"
 });
 var sparql12Tokens = LexerBuilder.create(lexer_exports.sparql11Tokens).addBefore(
@@ -13186,7 +13675,13 @@ var dataBlockValue2 = {
   impl: ($) => (C) => $.OR2([
     { ALT: () => grammar_exports.dataBlockValue.impl($)(C, void 0) },
     { ALT: () => $.SUBRULE(tripleTermData, void 0) }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast) {
+      return SUBRULE(varOrTerm2, ast, void 0);
+    }
+    return "UNDEF";
+  }
 };
 var reifier = {
   name: "reifier",
@@ -13311,7 +13806,10 @@ function annotationBlockImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (_, arg) => {
       CONSUME(annotationOpen);
-      const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, { subject: ACTION(() => arg.subject) });
+      const res = SUBRULE(
+        allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty,
+        { subject: ACTION(() => arg.subject) }
+      );
       CONSUME(annotationClose);
       return res;
     }
@@ -13347,7 +13845,22 @@ var varOrTerm2 = {
       return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
     } },
     { ALT: () => SUBRULE(tripleTerm, void 0) }
-  ])
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    if (ast.termType === "Variable") {
+      return SUBRULE(grammar_exports.var_, ast, void 0);
+    }
+    if (ast.termType === "NamedNode") {
+      return SUBRULE(grammar_exports.iri, ast, void 0);
+    }
+    if (ast.termType === "BlankNode") {
+      return SUBRULE(grammar_exports.blankNode, ast, void 0);
+    }
+    if (ast.termType === "Quad") {
+      return SUBRULE(tripleTerm, ast, void 0);
+    }
+    return SUBRULE(grammar_exports.rdfLiteral, ast, void 0);
+  }
 };
 var reifiedTriple = {
   name: "reifiedTriple",
@@ -13403,7 +13916,8 @@ var tripleTerm = {
     const object3 = SUBRULE(tripleTermObject, void 0);
     CONSUME(tripleTermClose);
     return ACTION(() => C.dataFactory.quad(subject, predicate, object3));
-  }
+  },
+  gImpl: ({ SUBRULE }) => (ast) => `<<( ${SUBRULE(varOrTerm2, ast.subject, void 0)} ${SUBRULE(varOrTerm2, ast.predicate, void 0)} ${SUBRULE(varOrTerm2, ast.object, void 0)}  )>>`
 };
 var tripleTermSubject = {
   name: "tripleTermSubject",
@@ -13548,6 +14062,9 @@ var rdfLiteral2 = {
     return ACTION(() => C.dataFactory.literal(value, langOrDataType));
   }
 };
+
+// lib/sparql12Types.ts
+var sparql12Types_exports = {};
 /*! Bundled license information:
 
 lodash-es/lodash.js: