@traqula/rules-sparql-1-1 0.0.15 → 0.0.17

package/lib/index.cjs

@@ -20,10 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AstFactory: () => AstFactory,
+  AstTransformer: () => AstTransformer,
   CommonIRIs: () => CommonIRIs,
-  Factory: () => Factory,
   MinimalSparqlParser: () => MinimalSparqlParser,
-  TransformerSparql11: () => TransformerSparql11,
   baseAggregateFunc: () => baseAggregateFunc,
   checkNote13: () => checkNote13,
   completeParseContext: () => completeParseContext,
@@ -395,8 +395,8 @@ __export(BuiltInCalls_exports, {
   year: () => year
 });
 
-// ../core/lib/CoreFactory.js
-var CoreFactory = class {
+// ../core/lib/AstCoreFactory.js
+var AstCoreFactory = class {
   wrap(val, loc) {
     return { val, loc };
   }
@@ -9733,6 +9733,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;
@@ -9830,16 +9839,13 @@ 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 {
+  clone(obj) {
+    const newObj = Object.create(Object.getPrototypeOf(obj));
+    Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
+    return newObj;
+  }
   safeObjectVisit(value, mapper) {
     if (value && typeof value === "object") {
       if (Array.isArray(value)) {
@@ -9849,104 +9855,213 @@ var TransformerType = class {
     }
     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;
+  /**
+   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
+   * @param startObject object to start iterating from
+   * @param mapper mapper to transform the various objects - argument is a copy of the original
+   * @param preVisitor callback that is evaluated before iterating deeper.
+   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
+   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
+   *    - Default false
+   */
+  transformObject(startObject, mapper, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const copy3 = this.clone(curObject);
+      const context = preVisitor(copy3);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const [key, value] of Object.entries(copy3)) {
+          if (didShortCut) {
+            return copy3;
+          }
+          copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
+      }
+      return mapper(copy3);
+    };
+    return recurse(startObject);
   }
-  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));
+  /**
+   * Visitor that visits all objects. Visits deeper objects first.
+   */
+  visitObject(startObject, visitor, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const context = preVisitor(curObject);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const value of Object.values(curObject)) {
+          if (didShortCut) {
+            return;
+          }
+          this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
       }
-    }
+      visitor(curObject);
+    };
+    recurse(startObject);
+  }
+  transformNode(startObject, nodeCallBacks) {
+    const transformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.transform;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return curObject;
+    };
+    const preTransformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    return this.transformObject(startObject, transformWrapper, preTransformWrapper);
+  }
+  visitNode(startObject, nodeCallBacks) {
+    const visitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.visitor;
+        if (ogFunc) {
+          ogFunc(casted);
+        }
+      }
+    };
+    const preVisitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseNodes(currentNode, traverse) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      const traverser = traverse[curNode.type];
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 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;
+  transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const transformWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.transform;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.transform;
+        }
+      }
+      return ogTransform ? ogTransform(casted) : curObject;
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
   /**
    * 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];
+  visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const visitWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.visitor;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.visitor;
+        }
       }
-    }
-    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));
+      if (ogTransform) {
+        ogTransform(casted);
       }
-    }
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      let traverser;
+      const subObj = traverseSubNode[curNode.type];
+      if (subObj) {
+        traverser = subObj[curNode.subType];
+      }
+      if (!traverser) {
+        traverser = traverseNode[curNode.type];
+      }
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 
@@ -10997,8 +11112,8 @@ function UpdateOperationFactoryMixin(Base) {
   };
 }
 
-// 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() {
+// 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;
   }
@@ -11113,12 +11228,12 @@ var CommonIRIs;
   CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
   CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
 })(CommonIRIs || (CommonIRIs = {}));
-var TransformerSparql11 = class extends TransformerSubType {
+var AstTransformer = class extends TransformerSubType {
 };
 
 // lib/validation/validators.js
-var F = new Factory();
-var transformer = new TransformerSparql11();
+var F = new AstFactory();
+var transformer = new AstTransformer();
 function getAggregatesOfExpression(expression2) {
   if (F.isExpressionAggregate(expression2)) {
     return [expression2];
@@ -11197,77 +11312,69 @@ function queryIsGood(query2) {
     }
   }
 }
+function notUndefined(some2) {
+  return some2 !== void 0;
+}
 function findPatternBoundedVars(iter, boundedVars) {
-  if (F.isQuery(iter) || F.isUpdate(iter)) {
-    if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
-      if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
-        findPatternBoundedVars(iter.where, boundedVars);
-      } else {
-        for (const v of iter.variables) {
-          findPatternBoundedVars(v, boundedVars);
-        }
-      }
-      if (iter.solutionModifiers.group) {
-        const grouping = iter.solutionModifiers.group;
-        for (const g of grouping.groupings) {
-          if ("variable" in g) {
-            findPatternBoundedVars(g.variable, boundedVars);
-          }
-        }
-      }
-      if (iter.values?.values && iter.values.values.length > 0) {
-        const values3 = iter.values.values;
-        for (const v of Object.keys(values3[0])) {
+  transformer.traverseSubNodes(iter, {
+    query: (op) => ({ next: [
+      op.solutionModifiers.group
+    ].filter(notUndefined) }),
+    triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
+    path: (op) => ({ next: op.items }),
+    tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
+  }, {
+    query: {
+      select: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) }),
+      describe: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) })
+    },
+    solutionModifier: {
+      group: (op) => ({
+        next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
+      }),
+      having: (op) => ({ next: op.having }),
+      order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
+    },
+    pattern: {
+      values: (op) => {
+        for (const v of Object.keys(op.values.at(0) ?? {})) {
           boundedVars.add(v);
         }
+        return {};
+      },
+      bgp: (op) => ({ next: op.triples }),
+      group: (op) => ({ next: op.patterns }),
+      union: (op) => ({ next: op.patterns }),
+      optional: (op) => ({ next: op.patterns }),
+      service: (op) => ({ next: [op.name, ...op.patterns] }),
+      bind: (op) => ({ next: [op.variable] }),
+      graph: (op) => ({ next: [op.name, ...op.patterns] }),
+      minus: (op) => ({ next: op.patterns.slice(0, 1) })
+    },
+    term: {
+      variable: (op) => {
+        boundedVars.add(op.value);
+        return {};
       }
     }
-  } else if (F.isTerm(iter)) {
-    if (F.isTermVariable(iter)) {
-      boundedVars.add(iter.value);
-    }
-  } else if (F.isTriple(iter)) {
-    findPatternBoundedVars(iter.subject, boundedVars);
-    findPatternBoundedVars(iter.predicate, boundedVars);
-    findPatternBoundedVars(iter.object, boundedVars);
-  } else if (F.isPath(iter)) {
-    if (!F.isTerm(iter)) {
-      for (const item of iter.items) {
-        findPatternBoundedVars(item, boundedVars);
-      }
-    }
-  } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
-    for (const triple of iter.triples) {
-      findPatternBoundedVars(triple, boundedVars);
-    }
-  } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
-    for (const pattern of iter.patterns) {
-      findPatternBoundedVars(pattern, boundedVars);
-    }
-    if (F.isPatternService(iter)) {
-      findPatternBoundedVars(iter.name, boundedVars);
-    }
-  } else if (F.isPatternBind(iter)) {
-    findPatternBoundedVars(iter.variable, boundedVars);
-  } else if (F.isPatternValues(iter)) {
-    for (const variable of Object.keys(iter.values.at(0) ?? {})) {
-      boundedVars.add(variable);
-    }
-  } else if (F.isPatternGraph(iter)) {
-    findPatternBoundedVars(iter.name, boundedVars);
-    for (const pattern of iter.patterns) {
-      findPatternBoundedVars(pattern, boundedVars);
-    }
-  }
+  });
 }
 function checkNote13(patterns) {
   for (const [index, pattern] of patterns.entries()) {
     if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
       const bgp = patterns[index - 1];
       const variables = [];
-      transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
+      transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
         variables.push(var_2);
-      } } });
+      } } } });
       if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
         throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
       }
@@ -11293,12 +11400,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
     const operation = update2.operation;
     if (operation.subType === "insertdata") {
       const blankNodesHere = /* @__PURE__ */ new Set();
-      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
+      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
         blankNodesHere.add(blankNode2.label);
         if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
           throw new Error("Detected reuse blank node across different INSERT DATA clauses");
         }
-      } } });
+      } } } });
       for (const blankNode2 of blankNodesHere) {
         blankLabelsUsedInInsertData.add(blankNode2);
       }
@@ -11337,22 +11444,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);
       }
     }
@@ -11374,7 +11481,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 = {
@@ -11385,7 +11492,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 = {
@@ -11396,7 +11503,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 = {
@@ -11406,7 +11513,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 = {
@@ -11431,7 +11538,7 @@ var string = {
       } }
     ]);
     return ACTION(() => {
-      const F2 = C.factory;
+      const F2 = C.astFactory;
       const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
         switch (char) {
           case "t":
@@ -11458,16 +11565,16 @@ var iri2 = {
     { ALT: () => SUBRULE(iriFull) },
     { ALT: () => SUBRULE(prefixedName) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => F2.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => F2.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: F2 }) => {
+    F2.printFilter(ast, () => PRINT("<", ast.value, ">"));
   }
 };
 var prefixedName = {
@@ -11477,16 +11584,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: F2 }) => {
+    F2.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11496,11 +11603,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(() => {
@@ -11510,15 +11617,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));
   }
 };
 
@@ -11535,7 +11642,7 @@ var prologue = {
     ]));
     return result;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     for (const context of ast) {
       if (F2.isContextDefinitionBase(context)) {
         SUBRULE(baseDecl2, context);
@@ -11550,11 +11657,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("BASE"));
     SUBRULE(iri2, ast.value);
+    F2.printFilter(ast, () => PRINT_WORD("\n"));
   }
 };
 var prefixDecl2 = {
@@ -11563,13 +11671,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORDS("PREFIX", `${ast.key}:`);
     });
     SUBRULE(iri2, ast.value);
+    F2.printFilter(ast, () => PRINT_WORDS("\n"));
   }
 };
 var verb = {
@@ -11585,7 +11694,7 @@ var varOrTerm = {
     { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
     { ALT: () => SUBRULE(graphTerm) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     if (F2.isTermVariable(ast)) {
       return SUBRULE(var_, ast);
     }
@@ -11606,9 +11715,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: F2 }) => {
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
   }
 };
@@ -11622,10 +11731,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: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     if (F2.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else if (F2.isTermLiteral(ast)) {
@@ -11645,14 +11754,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)));
         } }
       ]);
     }
@@ -11673,9 +11782,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: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
       for (const clause of ast.clauses) {
         F2.printFilter(ast, () => PRINT_WORD(fromUsing));
         if (clause.clauseType === "named") {
@@ -11693,7 +11802,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 = {
@@ -11710,7 +11819,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)));
     }
   };
 }
@@ -11724,7 +11833,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)));
     }
   };
 }
@@ -11740,7 +11849,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)));
     }
   };
 }
@@ -11752,7 +11861,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)));
     }
   };
 }
@@ -11766,11 +11875,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)));
         } }
       ]);
     }
@@ -11782,7 +11891,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)));
     }
   };
 }
@@ -11792,7 +11901,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)));
     }
   };
 }
@@ -11810,7 +11919,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)));
     }
   };
 }
@@ -11830,7 +11939,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)));
     }
   };
 }
@@ -11840,7 +11949,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)));
     }
   };
 }
@@ -11853,7 +11962,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)));
     }
   };
 }
@@ -11993,17 +12102,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 F2 = C.factory;
-      if (C.factory.isWildcard(expressionVal)) {
-        return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      const F2 = C.astFactory;
+      if (C.astFactory.isWildcard(expressionVal)) {
+        return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
       }
-      return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12027,7 +12136,7 @@ var aggregateGroup_concat = {
     });
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      const F2 = C.factory;
+      const F2 = C.astFactory;
       return F2.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F2.sourceLocation(operatorToken, closeToken));
     });
   }
@@ -12057,7 +12166,7 @@ var aggregate = {
     });
     return result;
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD(ast.aggregation.toUpperCase(), "(");
       if (ast.distinct) {
@@ -12084,7 +12193,7 @@ var path = {
 };
 var pathGenerator = {
   name: "path",
-  gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F2 }, braces = true) => {
+  gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F2 }, braces = true) => {
     if (F2.isTerm(ast) && F2.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -12133,7 +12242,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)));
     }
   };
 }
@@ -12144,7 +12253,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)));
     } }
   ])
 };
@@ -12155,7 +12264,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 = {
@@ -12187,7 +12296,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);
@@ -12200,7 +12309,7 @@ var pathNegatedPropertySet = {
         });
         const close = CONSUME(symbols_exports.RParen);
         return ACTION(() => {
-          const F2 = C.factory;
+          const F2 = C.astFactory;
           if (tail.length === 0) {
             return F2.path("!", [head2], F2.sourceLocation(exclamation2, close));
           }
@@ -12221,7 +12330,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)));
     } }
   ])
 };
@@ -12246,33 +12355,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F2 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F2.isTripleCollection(triple)) {
           SUBRULE(graphNodePath, triple);
-          F2.printFilter(triple, () => PRINT_WORD("."));
+          F2.printFilter(triple, () => PRINT_WORD(".\n"));
         } else {
           SUBRULE(graphNodePath, triple.subject);
+          F2.printFilter(triple, () => PRINT_WORD(""));
           if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
             SUBRULE(varOrTerm, triple.predicate);
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F2.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
           if (nextTriple === void 0 || F2.isTripleCollection(nextTriple) || !F2.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F2.printFilter(ast, () => PRINT_WORD("."));
+            F2.printFilter(ast, () => PRINT_WORD(".\n"));
           } else if (F2.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F2.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F2.printFilter(ast, () => PRINT_WORD(";"));
+            F2.printFilter(ast, () => PRINT_WORD(";\n"));
           }
         }
       });
@@ -12285,24 +12396,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;
         });
       } }
@@ -12386,7 +12497,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));
     }
   };
 }
@@ -12403,7 +12514,7 @@ function collectionImpl(name, allowPaths) {
       });
       const endToken = CONSUME(symbols_exports.RParen);
       return ACTION(() => {
-        const F2 = C.factory;
+        const F2 = C.astFactory;
         const triples = [];
         const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
         const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12427,7 +12538,7 @@ function collectionImpl(name, allowPaths) {
         return F2.tripleCollectionList(listHead, triples, F2.sourceLocation(startToken, endToken));
       });
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
       F2.printFilter(ast, () => PRINT_WORD("("));
       for (const [idx, triple] of ast.triples.entries()) {
         if (idx % 2 === 0) {
@@ -12458,13 +12569,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: F2 }) => {
-      F2.printFilter(ast, () => PRINT("["));
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
+      const { astFactory: F2, indentInc } = c;
+      F2.printFilter(ast, () => {
+        c[traqulaIndentation] += indentInc;
+        PRINT("[\n");
+      });
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
           if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
@@ -12472,11 +12587,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F2.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
-          F2.printFilter(ast, () => PRINT_WORD(";"));
+          F2.printFilter(ast, () => PRINT_WORD(";\n"));
         });
       }
-      F2.printFilter(ast, () => PRINT("]"));
+      F2.printFilter(ast, () => {
+        c[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("]");
+      });
     }
   };
 }
@@ -12493,7 +12612,7 @@ function graphNodeImpl(name, allowPaths) {
         ALT: () => SUBRULE(triplesNodeRule)
       }
     ]),
-    gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+    gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
       if (F2.isTerm(ast)) {
         SUBRULE(varOrTerm, ast);
       } else {
@@ -12511,9 +12630,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("WHERE"));
     SUBRULE(groupGraphPattern, ast.val);
   }
@@ -12527,19 +12646,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("{"));
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F2, indentInc } = C;
+    F2.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     for (const pattern of ast.patterns) {
       SUBRULE(generatePattern, pattern);
     }
-    F2.printFilter(ast, () => PRINT_WORD("}"));
+    F2.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var generatePattern = {
   name: "generatePattern",
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     if (ast.type === "query") {
       SUBRULE(query, F2.querySelect({
         context: [],
@@ -12628,9 +12754,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
     SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
   }
@@ -12641,9 +12767,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.name);
     SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
@@ -12659,9 +12785,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD("SERVICE");
       if (ast.silent) {
@@ -12681,14 +12807,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("BIND", "("));
     SUBRULE(expression, ast.expression);
     F2.printFilter(ast, () => PRINT_WORD("AS"));
     SUBRULE(var_, ast.variable);
-    F2.printFilter(ast, () => PRINT_WORD(")"));
+    F2.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var inlineData = {
@@ -12696,16 +12822,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F2, indentInc } = C;
     const variables = Object.keys(ast.values.at(0) ?? {});
     F2.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) {
       F2.printFilter(ast, () => PRINT_WORD("("));
@@ -12716,9 +12845,12 @@ var inlineData = {
           SUBRULE(graphNodePath, mapping[variable]);
         }
       }
-      F2.printFilter(ast, () => PRINT_WORD(")"));
+      F2.printFilter(ast, () => PRINT_WORD(")\n"));
     }
-    F2.printFilter(ast, () => PRINT_WORD("}"));
+    F2.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var dataBlock = {
@@ -12741,7 +12873,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 = {
@@ -12758,7 +12890,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);
@@ -12790,7 +12922,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)));
       } }
     ]);
   }
@@ -12813,9 +12945,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("MINUS"));
     SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
   }
@@ -12831,9 +12963,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     if (F2.isPatternUnion(ast)) {
       const [head2, ...tail] = ast.patterns;
       SUBRULE(groupGraphPattern, head2);
@@ -12851,12 +12983,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("FILTER ("));
     SUBRULE(expression, ast.expression);
-    F2.printFilter(ast, () => PRINT_WORD(")"));
+    F2.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var constraint = {
@@ -12872,7 +13004,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)));
   }
 };
 
@@ -12882,7 +13014,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 = [];
@@ -12899,10 +13031,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD("(");
       if (ast.val.distinct) {
@@ -12925,7 +13057,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);
@@ -12937,7 +13069,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)));
     } }
   ])
 };
@@ -12946,7 +13078,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
 var expression = {
   name: "expression",
   impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     if (F2.isTerm(ast)) {
       SUBRULE(varOrTerm, ast);
     } else if (F2.isExpressionOperator(ast)) {
@@ -13011,7 +13143,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 = {
@@ -13019,7 +13151,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 = {
@@ -13041,7 +13173,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([
@@ -13049,7 +13181,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;
@@ -13068,7 +13200,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([
@@ -13099,9 +13231,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)
 };
@@ -13118,7 +13250,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)
 };
@@ -13133,7 +13265,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)));
     } }
   ])
 };
@@ -13156,7 +13288,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;
     });
   }
@@ -13178,13 +13310,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: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     if (F2.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -13237,11 +13369,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
+  gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("GROUP", "BY");
+    });
     for (const grouping of ast.groupings) {
       if (F2.isExpression(grouping)) {
         SUBRULE(expression, grouping);
@@ -13275,7 +13410,7 @@ var groupCondition = {
             return {
               variable,
               value: expressionValue,
-              loc: C.factory.sourceLocation(open, close)
+              loc: C.astFactory.sourceLocation(open, close)
             };
           }
           return expressionValue;
@@ -13294,10 +13429,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("HAVING"));
+  gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORD("HAVING");
+    });
     for (const having2 of ast.having) {
       SUBRULE(expression, having2);
     }
@@ -13318,10 +13456,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("ORDER", "BY");
+    });
     for (const ordering of ast.orderDefs) {
       if (ordering.descending) {
         F2.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13352,7 +13493,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: () => {
@@ -13371,16 +13512,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: F2 }) => {
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
       if (ast.limit) {
         PRINT_WORDS("LIMIT", String(ast.limit));
       }
@@ -13396,7 +13538,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 = {
@@ -13405,7 +13547,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)));
   }
 };
 
@@ -13430,10 +13572,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: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     SUBRULE(prologue, ast.context);
     if (F2.isQuerySelect(ast)) {
       SUBRULE(selectQuery, ast);
@@ -13463,13 +13605,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: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     SUBRULE(selectClause, F2.wrap({
       variables: ast.variables,
       distinct: ast.distinct,
@@ -13487,14 +13629,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 = {
@@ -13525,7 +13667,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: () => {
@@ -13555,7 +13697,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)));
             });
           } }
         ]));
@@ -13563,9 +13705,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD("SELECT");
       if (ast.val.distinct) {
@@ -13605,7 +13747,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: () => {
@@ -13617,19 +13759,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F2, indentInc } = C;
     F2.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
     if (!F2.isSourceLocationNoMaterialize(ast.where.loc)) {
-      F2.printFilter(ast, () => PRINT_WORD("{"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("{\n");
+      });
       SUBRULE(triplesBlock, ast.template);
-      F2.printFilter(ast, () => PRINT_WORD("}"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(datasetClauseStar, ast.datasets);
     if (F2.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13654,7 +13803,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);
@@ -13666,10 +13815,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
     if (F2.isWildcard(ast.variables[0])) {
       F2.printFilter(ast, () => PRINT_WORD("*"));
@@ -13697,10 +13846,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("ASK"));
     SUBRULE(datasetClauseStar, ast.datasets);
     SUBRULE(whereClause, F2.wrap(ast.where, ast.loc));
@@ -13717,7 +13866,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 = {
@@ -13754,13 +13903,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     const [head2, ...tail] = ast.updates;
     if (head2) {
       SUBRULE(prologue, head2.context);
@@ -13840,9 +13989,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD("LOAD");
       if (ast.silent) {
@@ -13863,9 +14012,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: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
       F2.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -13884,9 +14033,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
       PRINT_WORD("CREATE");
       if (ast.silent) {
@@ -13905,9 +14054,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: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
       F2.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -13929,7 +14078,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 = {
@@ -13940,7 +14089,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) {
@@ -13957,12 +14106,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: F2 }) => {
-      F2.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: F2, indentInc } = C;
+      F2.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, F2.wrap(ast.data, ast.loc));
-      F2.printFilter(ast, () => PRINT_WORD("}"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
   };
 }
@@ -13991,22 +14154,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F2, indentInc } = C;
     if (ast.graph) {
       F2.printFilter(ast, () => PRINT_WORD("WITH"));
       SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
-      F2.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("DELETE", "{\n");
+      });
       SUBRULE(quads, F2.wrap(ast.delete, ast.loc));
-      F2.printFilter(ast, () => PRINT_WORD("}"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     if (ast.insert.length > 0) {
-      F2.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("INSERT", "{\n");
+      });
       SUBRULE(quads, F2.wrap(ast.insert, ast.loc));
-      F2.printFilter(ast, () => PRINT_WORD("}"));
+      F2.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(usingClauseStar, ast.from);
     F2.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -14020,7 +14196,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 = {
@@ -14028,7 +14204,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 = {
@@ -14036,12 +14212,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)));
     } }
   ])
 };
@@ -14050,9 +14226,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(iri2, ast.graph);
   }
@@ -14063,18 +14239,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
     if (F2.isGraphRefSpecific(ast)) {
       SUBRULE(graphRef, ast);
     } else if (F2.isGraphRefDefault(ast)) {
@@ -14111,9 +14287,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: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     for (const quad of ast.val) {
       if (F2.isPattern(quad)) {
         SUBRULE(triplesBlock, quad);
@@ -14131,14 +14307,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F2, indentInc } = C;
     F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.graph);
-    F2.printFilter(ast, () => PRINT_WORD("{"));
+    F2.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     SUBRULE(triplesBlock, ast.triples);
-    F2.printFilter(ast, () => PRINT_WORD("}"));
+    F2.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 
@@ -14161,7 +14344,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: () => {
@@ -14185,7 +14368,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;
@@ -14193,7 +14376,7 @@ var queryOrUpdate = {
       } }
     ]);
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
     if (F2.isQuery(ast)) {
       SUBRULE(query, ast);
     } else {
@@ -14205,13 +14388,15 @@ var queryOrUpdate = {
 // lib/MinimalSparqlParser.js
 function completeParseContext(context) {
   return {
-    factory: context.factory ?? new Factory(),
+    astFactory: context.astFactory ?? new AstFactory(),
     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,
+    [traqulaIndentation]: context[traqulaIndentation] ?? 0,
+    indentInc: context.indentInc ?? 2
   };
 }
 var MinimalSparqlParser = class {
@@ -14219,7 +14404,7 @@ var MinimalSparqlParser = class {
   constructor(parser) {
     this.parser = parser;
   }
-  F = new Factory();
+  F = new AstFactory();
   parse(query2, context = {}) {
     return this.parser.queryOrUpdate(query2, completeParseContext(context));
   }