@traqula/rules-sparql-1-2 0.0.14 → 0.0.16

package/lib/index.cjs

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Factory: () => Factory2,
+  AstFactory: () => AstFactory2,
   completeParseContext: () => completeParseContext,
   findPatternBoundedVars: () => findPatternBoundedVars2,
   gram: () => grammar_exports2,
@@ -80,357 +80,8 @@ __export(grammar_exports2, {
   versionSpecifier: () => versionSpecifier
 });
 
-// ../rules-sparql-1-1/lib/grammar/index.js
-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,
-  datasetClauseStar: () => datasetClauseStar,
-  datasetClauseUsing: () => datasetClauseUsing,
-  datasetClauseUsingStar: () => datasetClauseUsingStar,
-  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,
-  generatePattern: () => generatePattern,
-  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,
-  iriFull: () => iriFull,
-  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,
-  pathChainHelper: () => pathChainHelper,
-  pathElt: () => pathElt,
-  pathEltOrInverse: () => pathEltOrInverse,
-  pathGenerator: () => pathGenerator,
-  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,
-  queryOrUpdate: () => queryOrUpdate,
-  queryUnit: () => queryUnit,
-  rdfLiteral: () => rdfLiteral,
-  regexExpression: () => regexExpression,
-  relationalExpression: () => relationalExpression,
-  selectClause: () => selectClause,
-  selectQuery: () => selectQuery,
-  serviceGraphPattern: () => serviceGraphPattern,
-  solutionModifier: () => solutionModifier,
-  sourceSelector: () => sourceSelector,
-  strReplaceExpression: () => strReplaceExpression,
-  string: () => string,
-  stringEscapedLexical: () => stringEscapedLexical,
-  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,
-  usingClauseStar: () => usingClauseStar,
-  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.js
-var lexer_exports = {};
-__export(lexer_exports, {
-  a: () => a,
-  add: () => add,
-  allBaseTokens: () => allBaseTokens,
-  as: () => as,
-  ask: () => ask,
-  baseDecl: () => baseDecl,
-  bind: () => bind,
-  builtIn: () => BuiltInCalls_exports,
-  by: () => by,
-  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,
-  groupByGroup: () => groupByGroup,
-  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,
-  sparql11LexerBuilder: () => sparql11LexerBuilder,
-  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/BuiltInCalls.js
-var BuiltInCalls_exports = {};
-__export(BuiltInCalls_exports, {
-  BuiltInCalls: () => BuiltInCalls,
-  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
-});
-
-// ../core/lib/CoreFactory.js
-var CoreFactory = class {
+// ../core/lib/AstCoreFactory.js
+var AstCoreFactory = class {
   wrap(val, loc) {
     return { val, loc };
   }
@@ -9767,6 +9418,15 @@ applyMixins(Parser, [
   PerformanceTracer
 ]);
 
+// ../core/lib/utils.js
+function unCapitalize(str2) {
+  return str2.charAt(0).toLowerCase() + str2.slice(1);
+}
+function createToken2(config) {
+  return createToken(config);
+}
+var traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
+
 // ../core/lib/lexer-builder/LexerBuilder.js
 var LexerBuilder = class _LexerBuilder {
   tokens;
@@ -9864,127 +9524,466 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../core/lib/utils.js
-function unCapitalize(str2) {
-  return str2.charAt(0).toLowerCase() + str2.slice(1);
-}
-function createToken2(config) {
-  return createToken(config);
-}
+// ../core/lib/Transformers.js
+var TransformerType = class {
+  safeObjectVisit(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectVisit(x, mapper));
+      }
+      return mapper(value);
+    }
+    return value;
+  }
+  transformNode(curObject, nodeCallBacks) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type) {
+      continueCheck = nodeCallBacks[casted.type]?.continue;
+      transformation = nodeCallBacks[casted.type]?.transform;
+    }
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
+    }
+    if (!shouldContinue) {
+      return curObject;
+    }
+    const copy3 = { ...curObject };
+    for (const [key, value] of Object.entries(copy3)) {
+      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
+    }
+    if (transformation) {
+      return transformation(copy3);
+    }
+    return copy3;
+  }
+  visitNode(curObject, nodeCallBacks) {
+    let callback;
+    const casted = curObject;
+    if (casted.type) {
+      callback = nodeCallBacks[casted.type];
+    }
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject);
+    }
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
+      }
+    }
+  }
+};
+var TransformerSubType = class extends TransformerType {
+  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
+  //   for (const value of Object.values(curObject)) {
+  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
+  //   }
+  // }
+  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        continueCheck = specific[casted.subType]?.continue;
+        transformation = specific[casted.subType]?.transform;
+      }
+    }
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
+    }
+    if (!shouldContinue) {
+      return curObject;
+    }
+    const copy3 = { ...curObject };
+    for (const [key, value] of Object.entries(copy3)) {
+      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+    }
+    if (transformation) {
+      return transformation(copy3);
+    }
+    return copy3;
+  }
+  /**
+   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+   */
+  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let callback;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        callback = specific[casted.subType];
+      }
+    }
+    if (!callback && casted.type) {
+      callback = nodeCallBacks[curObject.type];
+    }
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject) ?? true;
+    }
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+      }
+    }
+  }
+};
+
+// ../rules-sparql-1-1/lib/grammar/index.js
+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,
+  datasetClauseStar: () => datasetClauseStar,
+  datasetClauseUsing: () => datasetClauseUsing,
+  datasetClauseUsingStar: () => datasetClauseUsingStar,
+  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,
+  generatePattern: () => generatePattern,
+  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,
+  iriFull: () => iriFull,
+  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,
+  pathChainHelper: () => pathChainHelper,
+  pathElt: () => pathElt,
+  pathEltOrInverse: () => pathEltOrInverse,
+  pathGenerator: () => pathGenerator,
+  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,
+  queryOrUpdate: () => queryOrUpdate,
+  queryUnit: () => queryUnit,
+  rdfLiteral: () => rdfLiteral,
+  regexExpression: () => regexExpression,
+  relationalExpression: () => relationalExpression,
+  selectClause: () => selectClause,
+  selectQuery: () => selectQuery,
+  serviceGraphPattern: () => serviceGraphPattern,
+  solutionModifier: () => solutionModifier,
+  sourceSelector: () => sourceSelector,
+  strReplaceExpression: () => strReplaceExpression,
+  string: () => string,
+  stringEscapedLexical: () => stringEscapedLexical,
+  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,
+  usingClauseStar: () => usingClauseStar,
+  valueLogical: () => valueLogical,
+  valuesClause: () => valuesClause,
+  varOrIri: () => varOrIri,
+  varOrTerm: () => varOrTerm,
+  var_: () => var_,
+  verb: () => verb,
+  verbA: () => verbA,
+  verbPath: () => verbPath,
+  verbSimple: () => verbSimple,
+  whereClause: () => whereClause
+});
 
-// ../core/lib/Transformers.js
-var TransformerType = class {
-  safeObjectVisit(value, mapper) {
-    if (value && typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map((x) => this.safeObjectVisit(x, mapper));
-      }
-      return mapper(value);
-    }
-    return value;
-  }
-  transformNode(curObject, nodeCallBacks) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type) {
-      continueCheck = nodeCallBacks[casted.type]?.continue;
-      transformation = nodeCallBacks[casted.type]?.transform;
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy3 = { ...curObject };
-    for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy3);
-    }
-    return copy3;
-  }
-  visitNode(curObject, nodeCallBacks) {
-    let callback;
-    const casted = curObject;
-    if (casted.type) {
-      callback = nodeCallBacks[casted.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject);
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
-      }
-    }
-  }
-};
-var TransformerSubType = class extends TransformerType {
-  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
-  //   for (const value of Object.values(curObject)) {
-  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
-  //   }
-  // }
-  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        continueCheck = specific[casted.subType]?.continue;
-        transformation = specific[casted.subType]?.transform;
-      }
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy3 = { ...curObject };
-    for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy3);
-    }
-    return copy3;
-  }
-  /**
-   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
-   */
-  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let callback;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        callback = specific[casted.subType];
-      }
-    }
-    if (!callback && casted.type) {
-      callback = nodeCallBacks[curObject.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject) ?? true;
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
-      }
-    }
-  }
-};
+// ../rules-sparql-1-1/lib/lexer/index.js
+var lexer_exports = {};
+__export(lexer_exports, {
+  a: () => a,
+  add: () => add,
+  allBaseTokens: () => allBaseTokens,
+  as: () => as,
+  ask: () => ask,
+  baseDecl: () => baseDecl,
+  bind: () => bind,
+  builtIn: () => BuiltInCalls_exports,
+  by: () => by,
+  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,
+  groupByGroup: () => groupByGroup,
+  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,
+  sparql11LexerBuilder: () => sparql11LexerBuilder,
+  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/BuiltInCalls.js
+var BuiltInCalls_exports = {};
+__export(BuiltInCalls_exports, {
+  BuiltInCalls: () => BuiltInCalls,
+  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 BuiltInCalls;
 (function(BuiltInCalls2) {
   BuiltInCalls2["Str"] = "builtInStr";
@@ -11031,8 +11030,8 @@ function UpdateOperationFactoryMixin(Base) {
   };
 }
 
-// ../rules-sparql-1-1/lib/factory.js
-var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
+// ../rules-sparql-1-1/lib/astFactory.js
+var AstFactory = class extends asArg(AstCoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
   alwaysSparql11(obj) {
     return true;
   }
@@ -11133,7 +11132,7 @@ var TransformerSparql11 = class extends TransformerSubType {
 };
 
 // ../rules-sparql-1-1/lib/validation/validators.js
-var F = new Factory();
+var F = new AstFactory();
 var transformer = new TransformerSparql11();
 function getAggregatesOfExpression(expression2) {
   if (F.isExpressionAggregate(expression2)) {
@@ -11353,22 +11352,22 @@ var rdfLiteral = {
     return OPTION(() => OR([
       { ALT: () => {
         const lang2 = CONSUME(terminals_exports.langTag);
-        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
+        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
       } },
       { ALT: () => {
         CONSUME(symbols_exports.hathat);
         const iriVal = SUBRULE1(iri2);
-        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
+        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   },
-  gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
+  gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
     if (ast.langOrIri) {
       if (typeof ast.langOrIri === "string") {
-        factory.printFilter(ast, () => PRINT("@", ast.langOrIri));
+        astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
       } else {
-        factory.printFilter(ast, () => PRINT("^^"));
+        astFactory.printFilter(ast, () => PRINT("^^"));
         SUBRULE(iri2, ast.langOrIri);
       }
     }
@@ -11390,7 +11389,7 @@ var numericLiteralUnsigned = {
       { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralPositive = {
@@ -11401,7 +11400,7 @@ var numericLiteralPositive = {
       { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralNegative = {
@@ -11412,7 +11411,7 @@ var numericLiteralNegative = {
       { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var booleanLiteral = {
@@ -11422,7 +11421,7 @@ var booleanLiteral = {
       { ALT: () => CONSUME(true_) },
       { ALT: () => CONSUME(false_) }
     ]);
-    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(token), token.image.toLowerCase(), C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
+    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
   }
 };
 var string = {
@@ -11447,7 +11446,7 @@ var string = {
       } }
     ]);
     return ACTION(() => {
-      const F3 = C.factory;
+      const F3 = C.astFactory;
       const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
         switch (char) {
           case "t":
@@ -11474,16 +11473,16 @@ var iri2 = {
     { ALT: () => SUBRULE(iriFull) },
     { ALT: () => SUBRULE(prefixedName) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
 };
 var iriFull = {
   name: "iriFull",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const iriToken = CONSUME(terminals_exports.iriRef);
-    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
+    return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
   },
-  gImpl: ({ PRINT }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT("<", ast.value, ">"));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT("<", ast.value, ">"));
   }
 };
 var prefixedName = {
@@ -11493,16 +11492,16 @@ var prefixedName = {
       const longName = CONSUME(terminals_exports.pNameLn);
       return ACTION(() => {
         const [prefix, localName] = longName.image.split(":");
-        return C.factory.namedNode(C.factory.sourceLocation(longName), localName, prefix);
+        return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
       });
     } },
     { ALT: () => {
       const shortName = CONSUME(terminals_exports.pNameNs);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
     } }
   ]),
-  gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11512,11 +11511,11 @@ var blankNode = {
     const result = OR([
       { ALT: () => {
         const labelToken = CONSUME(terminals_exports.blankNodeLabel);
-        return ACTION(() => C.factory.blankNode(labelToken.image.slice(2), C.factory.sourceLocation(labelToken)));
+        return ACTION(() => C.astFactory.blankNode(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
       } },
       { ALT: () => {
         const anonToken = CONSUME(terminals_exports.anon);
-        return ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocation(anonToken)));
+        return ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocation(anonToken)));
       } }
     ]);
     ACTION(() => {
@@ -11526,15 +11525,15 @@ var blankNode = {
     });
     return result;
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
   }
 };
 var verbA = {
   name: "VerbA",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const token = CONSUME(a);
-    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE, void 0));
+    return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
   }
 };
 
@@ -11551,7 +11550,7 @@ var prologue = {
     ]));
     return result;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
         SUBRULE(baseDecl2, context);
@@ -11566,11 +11565,12 @@ var baseDecl2 = {
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const base = CONSUME(baseDecl);
     const val = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
+    return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("BASE"));
     SUBRULE(iri2, ast.value);
+    F3.printFilter(ast, () => PRINT_WORD("\n"));
   }
 };
 var prefixDecl2 = {
@@ -11579,13 +11579,14 @@ var prefixDecl2 = {
     const prefix = CONSUME(prefixDecl);
     const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
     const value = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
+    return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
   },
-  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORDS("PREFIX", `${ast.key}:`);
     });
     SUBRULE(iri2, ast.value);
+    F3.printFilter(ast, () => PRINT_WORDS("\n"));
   }
 };
 var verb = {
@@ -11601,7 +11602,7 @@ var varOrTerm = {
     { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
     { ALT: () => SUBRULE(graphTerm) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermVariable(ast)) {
       return SUBRULE(var_, ast);
     }
@@ -11622,9 +11623,9 @@ var var_ = {
       { ALT: () => CONSUME(terminals_exports.var1) },
       { ALT: () => CONSUME(terminals_exports.var2) }
     ]);
-    return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
+    return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
   }
 };
@@ -11638,10 +11639,10 @@ var graphTerm = {
     { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
     { ALT: () => {
       const tokenNil = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
     } }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else if (F3.isTermLiteral(ast)) {
@@ -11661,14 +11662,14 @@ function datasetClauseUsing(name, token) {
       return OR([
         { ALT: () => {
           const iri3 = SUBRULE(defaultGraphClause);
-          return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
+          return ACTION(() => C.astFactory.wrap({ clauseType: "default", value: iri3 }, C.astFactory.sourceLocation(start, iri3)));
         } },
         { ALT: () => {
           const namedClause = SUBRULE(namedGraphClause);
-          return ACTION(() => C.factory.wrap({
+          return ACTION(() => C.astFactory.wrap({
             clauseType: "named",
             value: namedClause.val
-          }, C.factory.sourceLocation(start, namedClause)));
+          }, C.astFactory.sourceLocation(start, namedClause)));
         } }
       ]);
     }
@@ -11689,9 +11690,9 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
         const clause = SUBRULE(subRule);
         clauses.push(clause);
       });
-      return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
+      return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       for (const clause of ast.clauses) {
         F3.printFilter(ast, () => PRINT_WORD(fromUsing));
         if (clause.clauseType === "named") {
@@ -11709,7 +11710,7 @@ var namedGraphClause = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const named2 = CONSUME(graph_exports.named);
     const iri3 = SUBRULE(sourceSelector);
-    return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
+    return ACTION(() => C.astFactory.wrap(iri3, C.astFactory.sourceLocation(named2, iri3)));
   }
 };
 var sourceSelector = {
@@ -11726,7 +11727,7 @@ function funcExpr1(func) {
       CONSUME(symbols_exports.LParen);
       const arg = SUBRULE(expression);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11740,7 +11741,7 @@ function funcExpr2(func) {
       CONSUME(symbols_exports.comma);
       const arg2 = SUBRULE2(expression);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11756,7 +11757,7 @@ function funcExpr3(func) {
       CONSUME2(symbols_exports.comma);
       const arg3 = SUBRULE3(expression);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11768,7 +11769,7 @@ function funcVar1(func) {
       CONSUME(symbols_exports.LParen);
       const arg = SUBRULE(var_);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11782,11 +11783,11 @@ function funcExprOrNil1(func) {
           CONSUME(symbols_exports.LParen);
           const arg = SUBRULE(expression);
           const close = CONSUME(symbols_exports.RParen);
-          return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
+          return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
         } },
         { ALT: () => {
           const nil2 = CONSUME(terminals_exports.nil);
-          return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
+          return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
         } }
       ]);
     }
@@ -11798,7 +11799,7 @@ function funcNil1(func) {
     impl: ({ ACTION, CONSUME }) => (C) => {
       const operator = CONSUME(func);
       const nil2 = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
     }
   };
 }
@@ -11808,7 +11809,7 @@ function funcExprList1(func) {
     impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
       const operator = CONSUME(func);
       const args = SUBRULE(expressionList);
-      return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, args.val, C.astFactory.sourceLocation(operator, args)));
     }
   };
 }
@@ -11826,7 +11827,7 @@ function funcExpr2or3(func) {
         return SUBRULE3(expression);
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11846,7 +11847,7 @@ function funcExpr3or4(func) {
         return SUBRULE4(expression);
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -11856,7 +11857,7 @@ function funcGroupGraphPattern(func) {
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       const operator = CONSUME(func);
       const group = SUBRULE(groupGraphPattern);
-      return ACTION(() => C.factory.expressionPatternOperation(operator.image, group, C.factory.sourceLocation(operator, group)));
+      return ACTION(() => C.astFactory.expressionPatternOperation(operator.image, group, C.astFactory.sourceLocation(operator, group)));
     }
   };
 }
@@ -11869,7 +11870,7 @@ function baseAggregateFunc(func) {
       const distinct2 = OPTION(() => CONSUME(distinct));
       const expr1 = SUBRULE(expression);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.factory.sourceLocation(operator, close)));
+      return ACTION(() => C.astFactory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.astFactory.sourceLocation(operator, close)));
     }
   };
 }
@@ -12009,17 +12010,17 @@ var aggregateCount = {
     const expressionVal = OR([
       { ALT: () => {
         const starToken = CONSUME(symbols_exports.star);
-        return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
+        return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
       } },
       { ALT: () => SUBRULE(expression) }
     ]);
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      const F3 = C.factory;
-      if (C.factory.isWildcard(expressionVal)) {
-        return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      const F3 = C.astFactory;
+      if (C.astFactory.isWildcard(expressionVal)) {
+        return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
       }
-      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12043,7 +12044,7 @@ var aggregateGroup_concat = {
     });
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      const F3 = C.factory;
+      const F3 = C.astFactory;
       return F3.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F3.sourceLocation(operatorToken, closeToken));
     });
   }
@@ -12073,7 +12074,7 @@ var aggregate = {
     });
     return result;
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD(ast.aggregation.toUpperCase(), "(");
       if (ast.distinct) {
@@ -12100,7 +12101,7 @@ var path = {
 };
 var pathGenerator = {
   name: "path",
-  gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F3 }, braces = true) => {
+  gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F3 }, braces = true) => {
     if (F3.isTerm(ast) && F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -12149,7 +12150,7 @@ function pathChainHelper(name, SEP, subType, subRule) {
         tailEnd = SUBRULE2(subRule);
         tail.push(tailEnd);
       });
-      return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
+      return ACTION(() => tail.length === 0 ? head2 : C.astFactory.path(subType, [head2, ...tail], C.astFactory.sourceLocation(head2, tailEnd)));
     }
   };
 }
@@ -12160,7 +12161,7 @@ var pathEltOrInverse = {
     { ALT: () => {
       const hat2 = CONSUME(symbols_exports.hat);
       const item = SUBRULE2(pathElt);
-      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
+      return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
     } }
   ])
 };
@@ -12171,7 +12172,7 @@ var pathElt = {
   impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
     const item = SUBRULE(pathPrimary);
     const modification = OPTION(() => SUBRULE(pathMod));
-    return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
+    return ACTION(() => modification === void 0 ? item : C.astFactory.path(modification.image, [item], C.astFactory.sourceLocation(item, modification)));
   }
 };
 var pathMod = {
@@ -12203,7 +12204,7 @@ var pathNegatedPropertySet = {
     return OR([
       { ALT: () => {
         const noAlternative = SUBRULE1(pathOneInPropertySet);
-        return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
+        return ACTION(() => C.astFactory.path("!", [noAlternative], C.astFactory.sourceLocation(exclamation2, noAlternative)));
       } },
       { ALT: () => {
         const open = CONSUME(symbols_exports.LParen);
@@ -12216,7 +12217,7 @@ var pathNegatedPropertySet = {
         });
         const close = CONSUME(symbols_exports.RParen);
         return ACTION(() => {
-          const F3 = C.factory;
+          const F3 = C.astFactory;
           if (tail.length === 0) {
             return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
           }
@@ -12237,7 +12238,7 @@ var pathOneInPropertySet = {
         { ALT: () => SUBRULE2(iri2) },
         { ALT: () => SUBRULE2(verbA) }
       ]);
-      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
+      return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
     } }
   ])
 };
@@ -12262,33 +12263,35 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
         });
       }
     });
-    return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
+    return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
   };
 }
 var triplesBlock = {
   name: "triplesBlock",
   impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F3.isTripleCollection(triple)) {
           SUBRULE(graphNodePath, triple);
-          F3.printFilter(triple, () => PRINT_WORD("."));
+          F3.printFilter(triple, () => PRINT_WORD(".\n"));
         } else {
           SUBRULE(graphNodePath, triple.subject);
+          F3.printFilter(triple, () => PRINT_WORD(""));
           if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
             SUBRULE(varOrTerm, triple.predicate);
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
           if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD("."));
+            F3.printFilter(ast, () => PRINT_WORD(".\n"));
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";"));
+            F3.printFilter(ast, () => PRINT_WORD(";\n"));
           }
         }
       });
@@ -12301,24 +12304,24 @@ function triplesSameSubjectImpl(name, allowPaths) {
     impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
       { ALT: () => {
         const subject = SUBRULE(varOrTerm);
-        const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.factory.dematerialized(subject)));
+        const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
         return ACTION(() => {
           if (res.length > 0) {
             res[0].subject = subject;
-            res[0].loc = C.factory.sourceLocation(subject, res[0]);
+            res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
           }
           return res;
         });
       } },
       { ALT: () => {
         const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
-        const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.factory.graphNodeIdentifier(subjectNode)));
+        const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
         return ACTION(() => {
           if (restNode.length === 0) {
             return [subjectNode];
           }
           restNode[0].subject = subjectNode;
-          restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
+          restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
           return restNode;
         });
       } }
@@ -12402,7 +12405,7 @@ function objectImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
       const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
-      return ACTION(() => C.factory.triple(subject, predicate, node));
+      return ACTION(() => C.astFactory.triple(subject, predicate, node));
     }
   };
 }
@@ -12419,7 +12422,7 @@ function collectionImpl(name, allowPaths) {
       });
       const endToken = CONSUME(symbols_exports.RParen);
       return ACTION(() => {
-        const F3 = C.factory;
+        const F3 = C.astFactory;
         const triples = [];
         const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
         const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12443,7 +12446,7 @@ function collectionImpl(name, allowPaths) {
         return F3.tripleCollectionList(listHead, triples, F3.sourceLocation(startToken, endToken));
       });
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => PRINT_WORD("("));
       for (const [idx, triple] of ast.triples.entries()) {
         if (idx % 2 === 0) {
@@ -12474,13 +12477,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       const startToken = CONSUME(symbols_exports.LSquare);
-      const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
+      const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
       const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
       const endToken = CONSUME(symbols_exports.RSquare);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
     },
-    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT("["));
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
+      const { astFactory: F3, indentInc } = c;
+      F3.printFilter(ast, () => {
+        c[traqulaIndentation] += indentInc;
+        PRINT("[\n");
+      });
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
           if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
@@ -12488,11 +12495,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
-          F3.printFilter(ast, () => PRINT_WORD(";"));
+          F3.printFilter(ast, () => PRINT_WORD(";\n"));
         });
       }
-      F3.printFilter(ast, () => PRINT("]"));
+      F3.printFilter(ast, () => {
+        c[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("]");
+      });
     }
   };
 }
@@ -12509,7 +12520,7 @@ function graphNodeImpl(name, allowPaths) {
         ALT: () => SUBRULE(triplesNodeRule)
       }
     ]),
-    gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
       if (F3.isTerm(ast)) {
         SUBRULE(varOrTerm, ast);
       } else {
@@ -12527,9 +12538,9 @@ var whereClause = {
   impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
     const where2 = OPTION(() => CONSUME(where));
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
+    return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("WHERE"));
     SUBRULE(groupGraphPattern, ast.val);
   }
@@ -12543,19 +12554,26 @@ var groupGraphPattern = {
       { ALT: () => SUBRULE(groupGraphPatternSub) }
     ]);
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("{"));
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     for (const pattern of ast.patterns) {
       SUBRULE(generatePattern, pattern);
     }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var generatePattern = {
   name: "generatePattern",
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (ast.type === "query") {
       SUBRULE(query, F3.querySelect({
         context: [],
@@ -12644,9 +12662,9 @@ var optionalGraphPattern = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const optional2 = CONSUME(optional);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
+    return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
   }
@@ -12657,9 +12675,9 @@ var graphGraphPattern = {
     const graph2 = CONSUME(graph_exports.graph);
     const name = SUBRULE(varOrIri);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
+    return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.name);
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
@@ -12675,9 +12693,9 @@ var serviceGraphPattern = {
     }) ?? false;
     const name = SUBRULE1(varOrIri);
     const group = SUBRULE1(groupGraphPattern);
-    return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
+    return ACTION(() => C.astFactory.patternService(name, group.patterns, silent2, C.astFactory.sourceLocation(service2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("SERVICE");
       if (ast.silent) {
@@ -12697,14 +12715,14 @@ var bind2 = {
     CONSUME(as);
     const variable = SUBRULE(var_);
     const close = CONSUME(symbols_exports.RParen);
-    return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
+    return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("BIND", "("));
     SUBRULE(expression, ast.expression);
     F3.printFilter(ast, () => PRINT_WORD("AS"));
     SUBRULE(var_, ast.variable);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
+    F3.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var inlineData = {
@@ -12712,16 +12730,19 @@ var inlineData = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const values3 = CONSUME(values2);
     const datablock = SUBRULE(dataBlock);
-    return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
+    return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     const variables = Object.keys(ast.values.at(0) ?? {});
     F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
       PRINT_WORD("VALUES", "(");
       for (const variable of variables) {
         PRINT_WORD(`?${variable}`);
       }
-      PRINT_WORD(")", "{");
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD(")", "{\n");
     });
     for (const mapping of ast.values) {
       F3.printFilter(ast, () => PRINT_WORD("("));
@@ -12732,9 +12753,12 @@ var inlineData = {
           SUBRULE(graphNodePath, mapping[variable]);
         }
       }
-      F3.printFilter(ast, () => PRINT_WORD(")"));
+      F3.printFilter(ast, () => PRINT_WORD(")\n"));
     }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var dataBlock = {
@@ -12757,7 +12781,7 @@ var inlineDataOneVar = {
       });
     });
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
+    return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(varVal, close)));
   }
 };
 var inlineDataFull = {
@@ -12774,7 +12798,7 @@ var inlineDataFull = {
           res.push({});
         });
         const close = CONSUME1(symbols_exports.RCurly);
-        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
+        return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(nil2, close)));
       } },
       { ALT: () => {
         const open = CONSUME1(symbols_exports.LParen);
@@ -12806,7 +12830,7 @@ var inlineDataFull = {
           });
         });
         const close = CONSUME2(symbols_exports.RCurly);
-        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
+        return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(open, close)));
       } }
     ]);
   }
@@ -12829,9 +12853,9 @@ var minusGraphPattern = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const minus2 = CONSUME(minus);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
+    return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("MINUS"));
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
   }
@@ -12847,9 +12871,9 @@ var groupOrUnionGraphPattern = {
       const group2 = SUBRULE2(groupGraphPattern);
       groups.push(group2);
     });
-    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
+    return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isPatternUnion(ast)) {
       const [head2, ...tail] = ast.patterns;
       SUBRULE(groupGraphPattern, head2);
@@ -12867,12 +12891,12 @@ var filter3 = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const filterToken = CONSUME(filter2);
     const expression2 = SUBRULE(constraint);
-    return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
+    return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
     SUBRULE(expression, ast.expression);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
+    F3.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var constraint = {
@@ -12888,7 +12912,7 @@ var functionCall = {
   impl: ({ ACTION, SUBRULE }) => (C) => {
     const func = SUBRULE(iri2);
     const args = SUBRULE(argList);
-    return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
+    return ACTION(() => C.astFactory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.astFactory.sourceLocation(func, args)));
   }
 };
 
@@ -12898,7 +12922,7 @@ var argList = {
   impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
     { ALT: () => {
       const nil2 = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.wrap({ args: [], distinct: false }, C.factory.sourceLocation(nil2)));
+      return ACTION(() => C.astFactory.wrap({ args: [], distinct: false }, C.astFactory.sourceLocation(nil2)));
     } },
     { ALT: () => {
       const args = [];
@@ -12915,10 +12939,10 @@ var argList = {
         }
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.wrap({ args, distinct: distinct2 }, C.factory.sourceLocation(open, close)));
+      return ACTION(() => C.astFactory.wrap({ args, distinct: distinct2 }, C.astFactory.sourceLocation(open, close)));
     } }
   ]),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("(");
       if (ast.val.distinct) {
@@ -12941,7 +12965,7 @@ var expressionList = {
   impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => (C) => OR([
     { ALT: () => {
       const nil2 = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.wrap([], C.factory.sourceLocation(nil2)));
+      return ACTION(() => C.astFactory.wrap([], C.astFactory.sourceLocation(nil2)));
     } },
     { ALT: () => {
       const open = CONSUME(symbols_exports.LParen);
@@ -12953,7 +12977,7 @@ var expressionList = {
         args.push(expr);
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.wrap(args, C.factory.sourceLocation(open, close)));
+      return ACTION(() => C.astFactory.wrap(args, C.astFactory.sourceLocation(open, close)));
     } }
   ])
 };
@@ -12962,7 +12986,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
 var expression = {
   name: "expression",
   impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isTerm(ast)) {
       SUBRULE(varOrTerm, ast);
     } else if (F3.isExpressionOperator(ast)) {
@@ -13027,7 +13051,7 @@ var conditionalOrExpression = {
   impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
     CONSUME(symbols_exports.logicOr);
     const args = SUBRULE2(conditionalAndExpression);
-    return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
+    return (left) => ACTION(() => C.astFactory.expressionOperation("||", [left, args], C.astFactory.sourceLocation(left, args)));
   }, ACTION, MANY)
 };
 var conditionalAndExpression = {
@@ -13035,7 +13059,7 @@ var conditionalAndExpression = {
   impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
     CONSUME(symbols_exports.logicAnd);
     const arg = SUBRULE2(valueLogical);
-    return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
+    return (left) => ACTION(() => C.astFactory.expressionOperation("&&", [left, arg], C.astFactory.sourceLocation(left, arg)));
   }, ACTION, MANY)
 };
 var valueLogical = {
@@ -13057,7 +13081,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
         ]);
         const expr = SUBRULE2(numericExpression);
-        return ACTION(() => C.factory.expressionOperation(operator.image, [args1, expr], C.factory.sourceLocation(args1, expr)));
+        return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, expr], C.astFactory.sourceLocation(args1, expr)));
       } },
       { ALT: () => {
         const operator = OR3([
@@ -13065,7 +13089,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(notIn) }
         ]);
         const args = SUBRULE1(expressionList);
-        return ACTION(() => C.factory.expressionOperation(operator.image, [args1, ...args.val], C.factory.sourceLocation(args1, args)));
+        return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, ...args.val], C.astFactory.sourceLocation(args1, args)));
       } }
     ]));
     return expression2 ?? args1;
@@ -13084,7 +13108,7 @@ var additiveExpression = {
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
       const arg = SUBRULE2(multiplicativeExpression);
-      return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
+      return ACTION(() => (left) => C.astFactory.expressionOperation(operator.image, [left, arg], C.astFactory.sourceLocation(left, arg)));
     } },
     { ALT: () => {
       const { operator, startInt } = OR3([
@@ -13115,9 +13139,9 @@ var additiveExpression = {
           { ALT: () => CONSUME(symbols_exports.slash) }
         ]);
         const innerExpr = SUBRULE1(unaryExpression);
-        return ACTION(() => (leftInner) => C.factory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.factory.sourceLocation(leftInner, innerExpr)));
+        return ACTION(() => (leftInner) => C.astFactory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.astFactory.sourceLocation(leftInner, innerExpr)));
       }, ACTION, MANY2);
-      return (left) => C.factory.expressionOperation(operator, [left, multiplicativeExpr], C.factory.sourceLocation(left, multiplicativeExpr));
+      return (left) => C.astFactory.expressionOperation(operator, [left, multiplicativeExpr], C.astFactory.sourceLocation(left, multiplicativeExpr));
     } }
   ]), ACTION, MANY1)
 };
@@ -13134,7 +13158,7 @@ var multiplicativeExpression = {
       subType: "operation",
       operator: operator.image,
       args: [left, expr],
-      loc: C.factory.sourceLocation(left, expr)
+      loc: C.astFactory.sourceLocation(left, expr)
     });
   }, ACTION, MANY)
 };
@@ -13149,7 +13173,7 @@ var unaryExpression = {
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression);
-      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
     } }
   ])
 };
@@ -13172,7 +13196,7 @@ var brackettedExpression = {
     const expr = SUBRULE(expression);
     const close = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      expr.loc = C.factory.sourceLocation(open, close);
+      expr.loc = C.astFactory.sourceLocation(open, close);
       return expr;
     });
   }
@@ -13194,13 +13218,13 @@ var iriOrFunction = {
           function: iriVal,
           args: args.val.args,
           distinct: distinct2,
-          loc: C.factory.sourceLocation(iriVal, args)
+          loc: C.astFactory.sourceLocation(iriVal, args)
         };
       });
     });
     return functionCall2 ?? iriVal;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -13253,11 +13277,14 @@ var groupClause = {
       type: "solutionModifier",
       subType: "group",
       groupings,
-      loc: C.factory.sourceLocation(start, groupings.at(-1))
+      loc: C.astFactory.sourceLocation(start, groupings.at(-1))
     }));
   },
-  gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
+  gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("GROUP", "BY");
+    });
     for (const grouping of ast.groupings) {
       if (F3.isExpression(grouping)) {
         SUBRULE(expression, grouping);
@@ -13291,7 +13318,7 @@ var groupCondition = {
             return {
               variable,
               value: expressionValue,
-              loc: C.factory.sourceLocation(open, close)
+              loc: C.astFactory.sourceLocation(open, close)
             };
           }
           return expressionValue;
@@ -13310,10 +13337,13 @@ var havingClause = {
       expressions.push(SUBRULE(havingCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
+    return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
   },
-  gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("HAVING"));
+  gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORD("HAVING");
+    });
     for (const having2 of ast.having) {
       SUBRULE(expression, having2);
     }
@@ -13334,10 +13364,13 @@ var orderClause = {
       orderings.push(SUBRULE1(orderCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
+    return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order2, orderings.at(-1))));
   },
-  gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("ORDER", "BY");
+    });
     for (const ordering of ast.orderDefs) {
       if (ordering.descending) {
         F3.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13368,7 +13401,7 @@ var orderCondition = {
       return ACTION(() => ({
         expression: expr,
         descending: descending[0],
-        loc: C.factory.sourceLocation(descending[1], expr)
+        loc: C.astFactory.sourceLocation(descending[1], expr)
       }));
     } },
     { ALT: () => {
@@ -13387,16 +13420,17 @@ var limitOffsetClauses = {
     { ALT: () => {
       const limit2 = SUBRULE1(limitClause);
       const offset2 = OPTION1(() => SUBRULE1(offsetClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.astFactory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
     } },
     { ALT: () => {
       const offset2 = SUBRULE2(offsetClause);
       const limit2 = OPTION2(() => SUBRULE2(limitClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
     } }
   ]),
-  gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
       if (ast.limit) {
         PRINT_WORDS("LIMIT", String(ast.limit));
       }
@@ -13412,7 +13446,7 @@ var limitClause = {
     const offset2 = CONSUME(limit);
     const value = CONSUME(terminals_exports.integer);
     const val = Number.parseInt(value.image, 10);
-    return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
   }
 };
 var offsetClause = {
@@ -13421,7 +13455,7 @@ var offsetClause = {
     const offset2 = CONSUME(offset);
     const value = CONSUME(terminals_exports.integer);
     const val = Number.parseInt(value.image, 10);
-    return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
   }
 };
 
@@ -13446,10 +13480,10 @@ var query = {
       ...subType,
       type: "query",
       ...values3 && { values: values3 },
-      loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
+      loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
     }));
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     SUBRULE(prologue, ast.context);
     if (F3.isQuerySelect(ast)) {
       SUBRULE(selectQuery, ast);
@@ -13479,13 +13513,13 @@ var selectQuery = {
         solutionModifiers: modifiers,
         datasets: from2,
         ...selectVal.val,
-        loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+        loc: C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
       };
       queryIsGood(ret);
       return ret;
     });
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     SUBRULE(selectClause, F3.wrap({
       variables: ast.variables,
       distinct: ast.distinct,
@@ -13503,14 +13537,14 @@ var subSelect = {
     const where2 = SUBRULE(whereClause);
     const modifiers = SUBRULE(solutionModifier);
     const values3 = SUBRULE(valuesClause);
-    return ACTION(() => C.factory.querySelect({
+    return ACTION(() => C.astFactory.querySelect({
       where: where2.val,
-      datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
+      datasets: C.astFactory.datasetClauses([], C.astFactory.sourceLocation()),
       context: [],
       solutionModifiers: modifiers,
       ...selectVal.val,
       ...values3 && { values: values3 }
-    }, C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
+    }, C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
   }
 };
 var selectClause = {
@@ -13541,7 +13575,7 @@ var selectClause = {
         const star2 = CONSUME(symbols_exports.star);
         return ACTION(() => {
           last2 = star2;
-          return { variables: [C.factory.wildcard(C.factory.sourceLocation(star2))], ...distRed };
+          return { variables: [C.astFactory.wildcard(C.astFactory.sourceLocation(star2))], ...distRed };
         });
       } },
       { ALT: () => {
@@ -13571,7 +13605,7 @@ var selectClause = {
                 throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
               }
               usedVars.push(variable);
-              variables.push(C.factory.patternBind(expr, variable, C.factory.sourceLocation(open, last2)));
+              variables.push(C.astFactory.patternBind(expr, variable, C.astFactory.sourceLocation(open, last2)));
             });
           } }
         ]));
@@ -13579,9 +13613,9 @@ var selectClause = {
       } }
     ]);
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select2, last2)));
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("SELECT");
       if (ast.val.distinct) {
@@ -13621,7 +13655,7 @@ var constructQuery = {
           datasets: from2,
           where: where2.val,
           solutionModifiers: modifiers,
-          loc: C.factory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+          loc: C.astFactory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
         }));
       } },
       { ALT: () => {
@@ -13633,19 +13667,26 @@ var constructQuery = {
           subType: "construct",
           template: template.val,
           datasets: from2,
-          where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
+          where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
           solutionModifiers: modifiers,
-          loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+          loc: C.astFactory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
         }));
       } }
     ]);
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
     if (!F3.isSourceLocationNoMaterialize(ast.where.loc)) {
-      F3.printFilter(ast, () => PRINT_WORD("{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("{\n");
+      });
       SUBRULE(triplesBlock, ast.template);
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(datasetClauseStar, ast.datasets);
     if (F3.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13670,7 +13711,7 @@ var describeQuery = {
       } },
       { ALT: () => {
         const star2 = CONSUME(symbols_exports.star);
-        return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star2)))];
+        return [ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(star2)))];
       } }
     ]);
     const from2 = SUBRULE1(datasetClauseStar);
@@ -13682,10 +13723,10 @@ var describeQuery = {
       datasets: from2,
       ...where2 && { where: where2.val },
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+      loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
     if (F3.isWildcard(ast.variables[0])) {
       F3.printFilter(ast, () => PRINT_WORD("*"));
@@ -13713,10 +13754,10 @@ var askQuery = {
       datasets: from2,
       where: where2.val,
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+      loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("ASK"));
     SUBRULE(datasetClauseStar, ast.datasets);
     SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
@@ -13733,7 +13774,7 @@ var constructTemplate = {
     const open = CONSUME(symbols_exports.LCurly);
     const triples = OPTION(() => SUBRULE1(constructTriples));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.wrap(triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocation()), C.astFactory.sourceLocation(open, close)));
   }
 };
 var constructTriples = {
@@ -13770,13 +13811,13 @@ var update = {
       const update2 = {
         type: "update",
         updates,
-        loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
+        loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
       };
       updateNoReuseBlankNodeLabels(update2);
       return update2;
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     const [head2, ...tail] = ast.updates;
     if (head2) {
       SUBRULE(prologue, head2.context);
@@ -13856,9 +13897,9 @@ var load2 = {
       CONSUME(loadInto);
       return SUBRULE1(graphRef);
     });
-    return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
+    return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("LOAD");
       if (ast.silent) {
@@ -13879,9 +13920,9 @@ function clearOrDrop(operation) {
       const opToken = CONSUME(operation);
       const silent2 = OPTION(() => CONSUME(silent));
       const destination = SUBRULE1(graphRefAll);
-      return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
+      return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -13900,9 +13941,9 @@ var create2 = {
     const createToken3 = CONSUME(create);
     const silent2 = OPTION(() => CONSUME(silent));
     const destination = SUBRULE1(graphRef);
-    return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
+    return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("CREATE");
       if (ast.silent) {
@@ -13921,9 +13962,9 @@ function copyMoveAddOperation(operation) {
       const source = SUBRULE1(graphOrDefault);
       CONSUME(to);
       const destination = SUBRULE2(graphOrDefault);
-      return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
+      return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -13945,7 +13986,7 @@ var quadPattern = {
     const open = CONSUME(symbols_exports.LCurly);
     const val = SUBRULE1(quads);
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
   }
 };
 var quadData = {
@@ -13956,7 +13997,7 @@ var quadData = {
     const val = SUBRULE1(quads);
     ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
   }
 };
 function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
@@ -13973,12 +14014,26 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
       if (name !== "insertData") {
         ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
       }
-      return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
+      return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+      const { astFactory: F3, indentInc } = C;
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        if (subType === "insertdata") {
+          PRINT_WORD("INSERT DATA");
+        } else if (subType === "deletedata") {
+          PRINT_WORD("DELETE DATA");
+        } else if (subType === "deletewhere") {
+          PRINT_WORD("DELETE WHERE");
+        }
+        PRINT_WORD("{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.data, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
   };
 }
@@ -14007,22 +14062,35 @@ var modify = {
     const using = SUBRULE1(usingClauseStar);
     CONSUME(where);
     const where2 = SUBRULE1(groupGraphPattern);
-    return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
+    return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     if (ast.graph) {
       F3.printFilter(ast, () => PRINT_WORD("WITH"));
       SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
-      F3.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("DELETE", "{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.delete, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     if (ast.insert.length > 0) {
-      F3.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("INSERT", "{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.insert, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(usingClauseStar, ast.from);
     F3.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -14036,7 +14104,7 @@ var deleteClause2 = {
     const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
     const del = SUBRULE(quadPattern);
     ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
-    return ACTION(() => C.factory.wrap(del.val, C.factory.sourceLocation(delToken, del)));
+    return ACTION(() => C.astFactory.wrap(del.val, C.astFactory.sourceLocation(delToken, del)));
   }
 };
 var insertClause2 = {
@@ -14044,7 +14112,7 @@ var insertClause2 = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const insertToken = CONSUME(insertClause);
     const insert = SUBRULE(quadPattern);
-    return ACTION(() => C.factory.wrap(insert.val, C.factory.sourceLocation(insertToken, insert)));
+    return ACTION(() => C.astFactory.wrap(insert.val, C.astFactory.sourceLocation(insertToken, insert)));
   }
 };
 var graphOrDefault = {
@@ -14052,12 +14120,12 @@ var graphOrDefault = {
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => OR([
     { ALT: () => {
       const def = CONSUME(graph_exports.default_);
-      return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
+      return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
     } },
     { ALT: () => {
       const graph2 = OPTION(() => CONSUME(graph_exports.graph));
       const name = SUBRULE1(iri2);
-      return ACTION(() => C.factory.graphRefSpecific(name, C.factory.sourceLocation(graph2, name)));
+      return ACTION(() => C.astFactory.graphRefSpecific(name, C.astFactory.sourceLocation(graph2, name)));
     } }
   ])
 };
@@ -14066,9 +14134,9 @@ var graphRef = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const graph2 = CONSUME(graph_exports.graph);
     const val = SUBRULE(iri2);
-    return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
+    return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph2, val)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(iri2, ast.graph);
   }
@@ -14079,18 +14147,18 @@ var graphRefAll = {
     { ALT: () => SUBRULE(graphRef) },
     { ALT: () => {
       const def = CONSUME(graph_exports.default_);
-      return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
+      return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
     } },
     { ALT: () => {
       const named2 = CONSUME(graph_exports.named);
-      return ACTION(() => C.factory.graphRefNamed(C.factory.sourceLocation(named2)));
+      return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named2)));
     } },
     { ALT: () => {
       const graphAll2 = CONSUME(graph_exports.graphAll);
-      return ACTION(() => C.factory.graphRefAll(C.factory.sourceLocation(graphAll2)));
+      return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll2)));
     } }
   ]),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isGraphRefSpecific(ast)) {
       SUBRULE(graphRef, ast);
     } else if (F3.isGraphRefDefault(ast)) {
@@ -14127,9 +14195,9 @@ var quads = {
         ACTION(() => quads2.push(triples));
       });
     });
-    return ACTION(() => C.factory.wrap(quads2, C.factory.sourceLocation(quads2.at(0), last2)));
+    return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last2)));
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const quad of ast.val) {
       if (F3.isPattern(quad)) {
         SUBRULE(triplesBlock, quad);
@@ -14147,14 +14215,21 @@ var quadsNotTriples = {
     CONSUME(symbols_exports.LCurly);
     const triples = OPTION(() => SUBRULE1(triplesTemplate));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
+    return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.graph);
-    F3.printFilter(ast, () => PRINT_WORD("{"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     SUBRULE(triplesBlock, ast.triples);
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 
@@ -14177,7 +14252,7 @@ var queryOrUpdate = {
           ...subType,
           type: "query",
           ...values3 && { values: values3 },
-          loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
+          loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
         }));
       } },
       { ALT: () => {
@@ -14201,7 +14276,7 @@ var queryOrUpdate = {
           const update2 = {
             type: "update",
             updates,
-            loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
+            loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
           };
           updateNoReuseBlankNodeLabels(update2);
           return update2;
@@ -14209,7 +14284,7 @@ var queryOrUpdate = {
       } }
     ]);
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isQuery(ast)) {
       SUBRULE(query, ast);
     } else {
@@ -14273,8 +14348,78 @@ var LANG_DIR = createToken2({
 });
 var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(lexer_exports.symbols.logicAnd, tilde, annotationOpen, annotationClose, tripleTermOpen, tripleTermClose, reificationOpen, reificationClose, version).addBefore(lexer_exports.builtIn.langmatches, buildInLangDir, buildInStrLangDir, buildInHasLangDir, buildInHasLang, buildInIsTRIPLE, buildInTRIPLE, buildInSUBJECT, buildInPREDICATE, buildInOBJECT).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
 
+// lib/AstFactory.js
+var AstFactory2 = class extends AstFactory {
+  termTriple(subject, predicate, object3, loc) {
+    return {
+      type: "term",
+      subType: "triple",
+      subject,
+      predicate,
+      object: object3,
+      loc
+    };
+  }
+  isTermTriple(obj) {
+    return this.isOfSubType(obj, "term", "triple");
+  }
+  tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
+    return {
+      type: "tripleCollection",
+      subType: "reifiedTriple",
+      triples: [this.triple(subject, predicate, object3)],
+      identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
+      loc
+    };
+  }
+  isTripleCollectionReifiedTriple(obj) {
+    return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
+  }
+  tripleCollectionBlankNodeProperties(identifier, triples, loc) {
+    return {
+      type: "tripleCollection",
+      subType: "blankNodeProperties",
+      triples,
+      identifier,
+      loc
+    };
+  }
+  /**
+   * Overwritten triple constructor to always contain an empty annotations list
+   */
+  triple = (subject, predicate, object3, loc) => ({
+    type: "triple",
+    subject,
+    predicate,
+    object: object3,
+    annotations: [],
+    loc: loc ?? this.sourceLocation(subject, predicate, object3)
+  });
+  annotatedTriple(subject, predicate, object3, annotations, loc) {
+    return {
+      type: "triple",
+      subject,
+      predicate,
+      object: object3,
+      annotations: annotations ?? [],
+      loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
+    };
+  }
+  contextDefinitionVersion(version2, loc) {
+    return {
+      type: "contextDef",
+      subType: "version",
+      version: version2,
+      loc
+    };
+  }
+  isContextDefinitionVersion(obj) {
+    return this.isOfSubType(obj, "contextDef", "version");
+  }
+};
+
 // lib/validators.js
-var F2 = new Factory();
+var F2 = new AstFactory2();
 function isLangDir(dir) {
   return dir === "ltr" || dir === "rtl";
 }
@@ -14318,6 +14463,11 @@ function findPatternBoundedVars2(iter, boundedVars) {
     if (F2.isTermVariable(iter)) {
       boundedVars.add(iter.value);
     }
+    if (F2.isTermTriple(iter)) {
+      findPatternBoundedVars2(iter.subject, boundedVars);
+      findPatternBoundedVars2(iter.predicate, boundedVars);
+      findPatternBoundedVars2(iter.object, boundedVars);
+    }
   } else if (F2.isTriple(iter)) {
     findPatternBoundedVars2(iter.subject, boundedVars);
     findPatternBoundedVars2(iter.predicate, boundedVars);
@@ -14362,11 +14512,11 @@ var versionDecl = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const versionToken = CONSUME(version);
     const identifier = SUBRULE(versionSpecifier);
-    return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
+    return ACTION(() => C.astFactory.contextDefinitionVersion(identifier.val, C.astFactory.sourceLocation(versionToken, identifier)));
   },
-  gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`);
+      PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`, "\n");
     });
   }
 };
@@ -14377,7 +14527,7 @@ var versionSpecifier = {
       { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral1) },
       { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral2) }
     ]);
-    return ACTION(() => C.factory.wrap(token.image.slice(1, -1), C.factory.sourceLocation(token)));
+    return ACTION(() => C.astFactory.wrap(token.image.slice(1, -1), C.astFactory.sourceLocation(token)));
   }
 };
 var prologue2 = {
@@ -14393,7 +14543,7 @@ var prologue2 = {
     ]));
     return result;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
         SUBRULE(grammar_exports.baseDecl, context);
@@ -14410,7 +14560,7 @@ function reifiedTripleBlockImpl(name, allowPath) {
     name,
     impl: ({ ACTION, SUBRULE }) => (C) => {
       const triple = SUBRULE(reifiedTriple);
-      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.factory.dematerialized(triple.identifier)));
+      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.astFactory.dematerialized(triple.identifier)));
       return ACTION(() => [triple, ...properties]);
     }
   };
@@ -14433,7 +14583,7 @@ var reifier = {
       if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.wrap(reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()), C.factory.sourceLocation(tildeToken, reifier2));
+      return C.astFactory.wrap(reifier2 ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
     });
   }
 };
@@ -14463,7 +14613,7 @@ function objectImpl2(name, allowPaths) {
       const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2);
       const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
       return ACTION(() => {
-        const F3 = C.factory;
+        const F3 = C.astFactory;
         if (F3.isPathPure(predicate) && annotationVal.length > 0) {
           throw new Error("Note 17 violation");
         }
@@ -14492,7 +14642,7 @@ function annotationImpl(name, allowPaths) {
               if (!currentReifier && !C.parseMode.has("canCreateBlankNodes")) {
                 throw new Error("Cannot create blanknodes in current parse mode");
               }
-              currentReifier = currentReifier ?? C.factory.blankNode(void 0, C.factory.sourceLocation());
+              currentReifier = currentReifier ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation());
             });
             const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
             ACTION(() => {
@@ -14504,7 +14654,7 @@ function annotationImpl(name, allowPaths) {
       });
       return annotations;
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       for (const annotation2 of ast) {
         if (F3.isTripleCollectionBlankNodeProperties(annotation2)) {
           SUBRULE(annotationBlockPath, annotation2);
@@ -14525,11 +14675,18 @@ function annotationBlockImpl(name, allowPaths) {
       const open = CONSUME(annotationOpen);
       const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, arg);
       const close = CONSUME(annotationClose);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(arg, res, C.astFactory.sourceLocation(open, close)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD("{|"));
-      for (const triple of ast.triples) {
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, C) => {
+      const { astFactory: F3, indentInc } = C;
+      F3.printFilter(ast, () => {
+        PRINT_WORD("{|");
+        if (ast.triples.length > 1) {
+          C[traqulaIndentation] += indentInc;
+          PRINT_WORD("\n");
+        }
+      });
+      function printTriple(triple) {
         HANDLE_LOC(triple, () => {
           if (F3.isTerm(triple.predicate)) {
             SUBRULE(graphNodePath2, triple.predicate);
@@ -14537,10 +14694,21 @@ function annotationBlockImpl(name, allowPaths) {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           }
           SUBRULE(graphNodePath2, triple.object);
-          F3.printFilter(ast, () => PRINT_WORD(";"));
         });
       }
-      F3.printFilter(ast, () => PRINT_WORD("|}"));
+      const [head2, ...tail] = ast.triples;
+      printTriple(head2);
+      for (const triple of tail) {
+        F3.printFilter(ast, () => PRINT_WORD(";\n"));
+        printTriple(triple);
+      }
+      F3.printFilter(ast, () => {
+        if (ast.triples.length > 1) {
+          PRINT_ON_EMPTY("|}\n");
+        } else {
+          PRINT_WORD("|}");
+        }
+      });
     }
   };
 }
@@ -14560,7 +14728,7 @@ var graphNodePath2 = {
     { ALT: () => $.SUBRULE(reifiedTriple) }
   ]),
   gImpl: ($) => (ast, C) => {
-    if (C.factory.isTripleCollectionReifiedTriple(ast)) {
+    if (C.astFactory.isTripleCollectionReifiedTriple(ast)) {
       $.SUBRULE(reifiedTriple, ast);
     } else {
       grammar_exports.graphNodePath.gImpl($)(ast, C);
@@ -14578,7 +14746,7 @@ var varOrTerm2 = {
     { ALT: () => SUBRULE(grammar_exports.blankNode) },
     { ALT: () => {
       const token = CONSUME(lexer_exports.terminals.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.NIL));
     } },
     { ALT: () => SUBRULE(tripleTerm) }
   ])
@@ -14597,10 +14765,10 @@ var reifiedTriple = {
       if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
+      return C.astFactory.tripleCollectionReifiedTriple(C.astFactory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<"));
     const triple = ast.triples[0];
     SUBRULE(graphNodePath2, triple.subject);
@@ -14639,9 +14807,9 @@ var tripleTerm = {
     const predicate = SUBRULE(grammar_exports.verb);
     const object3 = SUBRULE(tripleTermObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<("));
     SUBRULE(graphNodePath2, ast.subject);
     SUBRULE(graphNodePath2, ast.predicate);
@@ -14674,12 +14842,12 @@ var tripleTermData = {
       { ALT: () => SUBRULE(grammar_exports.iri) },
       { ALT: () => {
         const token = CONSUME(lexer_exports.a);
-        return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
+        return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE));
       } }
     ]);
     const object3 = SUBRULE(tripleTermDataObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   }
 };
 var tripleTermDataSubject = {
@@ -14711,7 +14879,7 @@ var exprTripleTerm = {
     const predicate = SUBRULE(grammar_exports.verb);
     const object3 = SUBRULE(exprTripleTermObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   }
 };
 var exprTripleTermSubject = {
@@ -14761,7 +14929,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR);
         return ACTION(() => {
-          const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
+          const literal = C.astFactory.literalTerm(C.astFactory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
           langTagHasCorrectRange(literal);
           return literal;
         });
@@ -14769,7 +14937,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
         const iriVal = SUBRULE(grammar_exports.iri);
-        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
+        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   }
@@ -14781,7 +14949,7 @@ var unaryExpression2 = {
     { ALT: () => {
       const operator = CONSUME(lexer_exports.symbols.exclamation);
       const expr = SUBRULE1(unaryExpression2);
-      return ACTION(() => C.factory.expressionOperation("!", [expr], C.factory.sourceLocation(operator, expr)));
+      return ACTION(() => C.astFactory.expressionOperation("!", [expr], C.astFactory.sourceLocation(operator, expr)));
     } },
     { ALT: () => {
       const operator = OR2([
@@ -14789,34 +14957,36 @@ var unaryExpression2 = {
         { ALT: () => CONSUME(lexer_exports.symbols.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression2);
-      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
     } }
   ])
 };
 var generateTriplesBlock = {
   name: "triplesBlock",
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F3.isTripleCollection(triple)) {
           SUBRULE(graphNodePath2, triple);
-          F3.printFilter(triple, () => PRINT_WORD("."));
+          F3.printFilter(triple, () => PRINT_WORD(".\n"));
         } else {
           SUBRULE(graphNodePath2, triple.subject);
+          F3.printFilter(ast, () => PRINT_WORD(""));
           if (F3.isPathPure(triple.predicate)) {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           } else {
             SUBRULE(graphNodePath2, triple.predicate);
           }
+          F3.printFilter(ast, () => PRINT_WORD(""));
           SUBRULE(graphNodePath2, triple.object);
           SUBRULE(annotationPath, triple.annotations ?? []);
           if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD("."));
+            F3.printFilter(ast, () => PRINT_WORD(".\n"));
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";"));
+            F3.printFilter(ast, () => PRINT_WORD(";\n"));
           }
         }
       });
@@ -14826,7 +14996,7 @@ var generateTriplesBlock = {
 var generateGraphTerm = {
   name: "graphTerm",
   gImpl: ($) => (ast, C) => {
-    if (C.factory.isTermTriple(ast)) {
+    if (C.astFactory.isTermTriple(ast)) {
       $.SUBRULE(tripleTerm, ast);
     } else {
       grammar_exports.graphTerm.gImpl($)(ast, C);
@@ -14834,86 +15004,18 @@ var generateGraphTerm = {
   }
 };
 
-// lib/Factory.js
-var Factory2 = class extends Factory {
-  termTriple(subject, predicate, object3, loc) {
-    return {
-      type: "term",
-      subType: "triple",
-      subject,
-      predicate,
-      object: object3,
-      loc
-    };
-  }
-  isTermTriple(obj) {
-    return this.isOfSubType(obj, "term", "triple");
-  }
-  tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
-    return {
-      type: "tripleCollection",
-      subType: "reifiedTriple",
-      triples: [this.triple(subject, predicate, object3)],
-      identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
-      loc
-    };
-  }
-  isTripleCollectionReifiedTriple(obj) {
-    return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
-  }
-  tripleCollectionBlankNodeProperties(identifier, triples, loc) {
-    return {
-      type: "tripleCollection",
-      subType: "blankNodeProperties",
-      triples,
-      identifier,
-      loc
-    };
-  }
-  /**
-   * Overwritten triple constructor to always contain an empty annotations list
-   */
-  triple = (subject, predicate, object3, loc) => ({
-    type: "triple",
-    subject,
-    predicate,
-    object: object3,
-    annotations: [],
-    loc: loc ?? this.sourceLocation(subject, predicate, object3)
-  });
-  annotatedTriple(subject, predicate, object3, annotations, loc) {
-    return {
-      type: "triple",
-      subject,
-      predicate,
-      object: object3,
-      annotations: annotations ?? [],
-      loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
-    };
-  }
-  contextDefinitionVersion(version2, loc) {
-    return {
-      type: "contextDef",
-      subType: "version",
-      version: version2,
-      loc
-    };
-  }
-  isContextDefinitionVersion(obj) {
-    return this.isOfSubType(obj, "contextDef", "version");
-  }
-};
-
 // lib/parserUtils.js
 function completeParseContext(context) {
   return {
-    factory: context.factory ?? new Factory2(),
+    astFactory: context.astFactory ?? new AstFactory2(),
     baseIRI: context.baseIRI,
     prefixes: { ...context.prefixes },
     origSource: context.origSource ?? "",
     offset: context.offset,
     parseMode: context.parseMode ? new Set(context.parseMode) : /* @__PURE__ */ new Set(["canParseVars", "canCreateBlankNodes"]),
-    skipValidation: context.skipValidation ?? false
+    skipValidation: context.skipValidation ?? false,
+    indentInc: context.indentInc ?? 2,
+    [traqulaIndentation]: context[traqulaIndentation] ?? 0
   };
 }
 /*! Bundled license information: