@traqula/generator-sparql-1-2 0.0.15 → 0.0.17

package/lib/index.cjs

@@ -24,8 +24,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../packages/core/lib/CoreFactory.js
-var CoreFactory = class {
+// ../../packages/core/lib/AstCoreFactory.js
+var AstCoreFactory = class {
   wrap(val, loc) {
     return { val, loc };
   }
@@ -151,214 +151,6 @@ var CoreFactory = class {
   }
 };
 
-// ../../packages/core/lib/generator-builder/dynamicGenerator.js
-var DynamicGenerator = class {
-  rules;
-  factory = new CoreFactory();
-  __context = void 0;
-  origSource = "";
-  generatedUntil = 0;
-  expectsSpace;
-  stringBuilder = [];
-  constructor(rules) {
-    this.rules = rules;
-    for (const rule of Object.values(rules)) {
-      this[rule.name] = ((input, context, args) => {
-        this.expectsSpace = false;
-        this.stringBuilder.length = 0;
-        this.origSource = context.origSource;
-        this.generatedUntil = context?.offset ?? 0;
-        this.setContext(context);
-        this.subrule(rule, input, args);
-        this.catchup(this.origSource.length);
-        return this.stringBuilder.join("");
-      });
-    }
-  }
-  setContext(context) {
-    this.__context = context;
-  }
-  getSafeContext() {
-    return this.__context;
-  }
-  subrule = (cstDef, ast, ...arg) => {
-    const def = this.rules[cstDef.name];
-    if (!def) {
-      throw new Error(`Rule ${cstDef.name} not found`);
-    }
-    const generate = () => def.gImpl({
-      SUBRULE: this.subrule,
-      PRINT: this.print,
-      PRINT_SPACE_LEFT: this.printSpaceLeft,
-      PRINT_WORD: this.printWord,
-      PRINT_WORDS: this.printWords,
-      CATCHUP: this.catchup,
-      HANDLE_LOC: this.handleLoc
-    })(ast, this.getSafeContext(), ...arg);
-    if (this.factory.isLocalized(ast)) {
-      this.handleLoc(ast, generate);
-    } else {
-      generate();
-    }
-  };
-  handleLoc = (localized, handle) => {
-    if (this.factory.isSourceLocationNoMaterialize(localized.loc)) {
-      return;
-    }
-    if (this.factory.isSourceLocationStringReplace(localized.loc)) {
-      this.catchup(localized.loc.start);
-      this.print(localized.loc.newSource);
-      this.generatedUntil = localized.loc.end;
-      return;
-    }
-    if (this.factory.isSourceLocationNodeReplace(localized.loc)) {
-      this.catchup(localized.loc.start);
-      this.generatedUntil = localized.loc.end;
-    }
-    if (this.factory.isSourceLocationSource(localized.loc)) {
-      this.catchup(localized.loc.start);
-    }
-    const ret = handle();
-    if (this.factory.isSourceLocationSource(localized.loc)) {
-      this.catchup(localized.loc.end);
-    }
-    return ret;
-  };
-  catchup = (until) => {
-    const start = this.generatedUntil;
-    if (start < until) {
-      this.print(this.origSource.slice(start, until));
-    }
-    this.generatedUntil = Math.max(this.generatedUntil, until);
-  };
-  print = (...args) => {
-    const pureArgs = args.filter((x) => x.length > 0);
-    if (pureArgs.length > 0) {
-      const [head2, ...tail] = pureArgs;
-      if (this.expectsSpace) {
-        this.expectsSpace = false;
-        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
-        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
-          this.stringBuilder.push(" ");
-        }
-      }
-      this.stringBuilder.push(head2);
-      this.stringBuilder.push(...tail);
-    }
-  };
-  printWord = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-    this.expectsSpace = true;
-  };
-  printSpaceLeft = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-  };
-  printWords = (...args) => {
-    for (const arg of args) {
-      this.printWord(arg);
-    }
-  };
-};
-
-// ../../packages/core/lib/generator-builder/generatorBuilder.js
-function listToRuleDefMap(rules) {
-  const newRules = {};
-  for (const rule of rules) {
-    newRules[rule.name] = rule;
-  }
-  return newRules;
-}
-var GeneratorBuilder = class _GeneratorBuilder {
-  static create(start) {
-    if (start instanceof _GeneratorBuilder) {
-      return new _GeneratorBuilder({ ...start.rules });
-    }
-    return new _GeneratorBuilder(listToRuleDefMap(start));
-  }
-  rules;
-  constructor(startRules) {
-    this.rules = startRules;
-  }
-  widenContext() {
-    return this;
-  }
-  typePatch() {
-    return this;
-  }
-  /**
-   * Change the implementation of an existing generator rule.
-   */
-  patchRule(patch) {
-    const self2 = this;
-    self2.rules[patch.name] = patch;
-    return self2;
-  }
-  /**
-   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
-   */
-  addRuleRedundant(rule) {
-    const self2 = this;
-    const rules = self2.rules;
-    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
-      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);
-    }
-    rules[rule.name] = rule;
-    return self2;
-  }
-  /**
-   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
-   */
-  addRule(rule) {
-    return this.addRuleRedundant(rule);
-  }
-  addMany(...rules) {
-    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
-    return this;
-  }
-  /**
-   * Delete a grammar rule by its name.
-   */
-  deleteRule(ruleName) {
-    delete this.rules[ruleName];
-    return this;
-  }
-  /**
-   * Merge this grammar GeneratorBuilder with another.
-   * It is best to merge the bigger grammar with the smaller one.
-   * If the two builders both have a grammar rule with the same name,
-   * no error will be thrown case they map to the same ruledef object.
-   * If they map to a different object, an error will be thrown.
-   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,
-   * this rule implementation will be used.
-   */
-  merge(GeneratorBuilder2, overridingRules) {
-    const otherRules = { ...GeneratorBuilder2.rules };
-    const myRules = this.rules;
-    for (const rule of Object.values(myRules)) {
-      if (otherRules[rule.name] === void 0) {
-        otherRules[rule.name] = rule;
-      } else {
-        const existingRule = otherRules[rule.name];
-        if (existingRule !== rule) {
-          const override = overridingRules.find((x) => x.name === rule.name);
-          if (override) {
-            otherRules[rule.name] = override;
-          } else {
-            throw new Error(`Rule with name "${rule.name}" already exists in the GeneratorBuilder, specify an override to resolve conflict`);
-          }
-        }
-      }
-    }
-    this.rules = otherRules;
-    return this;
-  }
-  build() {
-    return new DynamicGenerator(this.rules);
-  }
-};
-
 // ../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeGlobal_default = freeGlobal;
@@ -9570,28 +9362,284 @@ applyMixins(Parser, [
   PerformanceTracer
 ]);
 
-// ../../packages/core/lib/lexer-builder/LexerBuilder.js
-var LexerBuilder = class _LexerBuilder {
-  tokens;
-  static create(starter) {
-    return new _LexerBuilder(starter);
+// ../../packages/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";
+
+// ../../packages/core/lib/generator-builder/dynamicGenerator.js
+var DynamicGenerator = class {
+  rules;
+  factory = new AstCoreFactory();
+  __context = void 0;
+  origSource = "";
+  generatedUntil = 0;
+  expectsSpace;
+  stringBuilder = [];
+  constructor(rules) {
+    this.rules = rules;
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = ((input, context, args) => {
+        this.expectsSpace = false;
+        this.stringBuilder.length = 0;
+        this.origSource = context.origSource;
+        this.generatedUntil = context?.offset ?? 0;
+        this.setContext(context);
+        this.subrule(rule, input, args);
+        this.catchup(this.origSource.length);
+        return this.stringBuilder.join("");
+      });
+    }
   }
-  constructor(starter) {
-    this.tokens = starter?.tokens ? [...starter.tokens] : [];
+  setContext(context) {
+    this.__context = context;
   }
-  merge(merge, overwrite = []) {
-    const extraTokens = merge.tokens.filter((token) => {
-      const overwriteToken = overwrite.find((t) => t.name === token.name);
-      if (overwriteToken) {
-        return false;
-      }
-      const match = this.tokens.find((t) => t.name === token.name);
-      if (match) {
-        if (match !== token) {
-          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);
-        }
-        return false;
-      }
+  getSafeContext() {
+    return this.__context;
+  }
+  subrule = (cstDef, ast, ...arg) => {
+    const def = this.rules[cstDef.name];
+    if (!def) {
+      throw new Error(`Rule ${cstDef.name} not found`);
+    }
+    const generate = () => def.gImpl({
+      SUBRULE: this.subrule,
+      PRINT: this.print,
+      PRINT_SPACE_LEFT: this.printSpaceLeft,
+      PRINT_WORD: this.printWord,
+      PRINT_WORDS: this.printWords,
+      PRINT_ON_EMPTY: this.printOnEmpty,
+      CATCHUP: this.catchup,
+      HANDLE_LOC: this.handleLoc
+    })(ast, this.getSafeContext(), ...arg);
+    if (this.factory.isLocalized(ast)) {
+      this.handleLoc(ast, generate);
+    } else {
+      generate();
+    }
+  };
+  handleLoc = (localized, handle) => {
+    if (this.factory.isSourceLocationNoMaterialize(localized.loc)) {
+      return;
+    }
+    if (this.factory.isSourceLocationStringReplace(localized.loc)) {
+      this.catchup(localized.loc.start);
+      this.print(localized.loc.newSource);
+      this.generatedUntil = localized.loc.end;
+      return;
+    }
+    if (this.factory.isSourceLocationNodeReplace(localized.loc)) {
+      this.catchup(localized.loc.start);
+      this.generatedUntil = localized.loc.end;
+    }
+    if (this.factory.isSourceLocationSource(localized.loc)) {
+      this.catchup(localized.loc.start);
+    }
+    const ret = handle();
+    if (this.factory.isSourceLocationSource(localized.loc)) {
+      this.catchup(localized.loc.end);
+    }
+    return ret;
+  };
+  catchup = (until) => {
+    const start = this.generatedUntil;
+    if (start < until) {
+      this.print(this.origSource.slice(start, until));
+    }
+    this.generatedUntil = Math.max(this.generatedUntil, until);
+  };
+  print = (...args) => {
+    const pureArgs = args.filter((x) => x.length > 0);
+    if (pureArgs.length > 0) {
+      const head2 = pureArgs[0];
+      if (this.expectsSpace) {
+        this.expectsSpace = false;
+        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
+        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
+          this.stringBuilder.push(" ");
+        }
+      }
+      const context = this.getSafeContext();
+      if (context[traqulaIndentation] && typeof context[traqulaIndentation] === "number") {
+        const indent = context[traqulaIndentation];
+        for (const str2 of pureArgs) {
+          const [noNl, ...postNl] = str2.split("\n");
+          this.stringBuilder.push(noNl);
+          for (const subStr of postNl.map((line) => line.trimStart())) {
+            this.stringBuilder.push("\n", " ".repeat(indent));
+            if (subStr.length > 0) {
+              this.stringBuilder.push(subStr);
+            }
+          }
+        }
+      } else {
+        this.stringBuilder.push(...pureArgs);
+      }
+    }
+  };
+  printWord = (...args) => {
+    this.expectsSpace = true;
+    this.print(...args);
+    this.expectsSpace = true;
+  };
+  printSpaceLeft = (...args) => {
+    this.expectsSpace = true;
+    this.print(...args);
+  };
+  printWords = (...args) => {
+    for (const arg of args) {
+      this.printWord(arg);
+    }
+  };
+  printOnEmpty = (...args) => {
+    let counter = this.stringBuilder.length - 1;
+    let onEmpty = true;
+    const isEmptyTest = /^[ \t\n]*$/u;
+    while (counter >= 0 && onEmpty) {
+      const cur = this.stringBuilder[counter];
+      const indexOfNl = cur.lastIndexOf("\n");
+      if (indexOfNl >= 0) {
+        onEmpty = isEmptyTest.test(cur.slice(indexOfNl));
+        if (onEmpty) {
+          const newVal = cur.slice(0, indexOfNl);
+          if (newVal) {
+            this.stringBuilder[counter] = cur.slice(0, indexOfNl);
+          } else {
+            this.stringBuilder.splice(counter, 1);
+          }
+        }
+        break;
+      }
+      onEmpty = isEmptyTest.test(cur);
+      counter--;
+    }
+    this.print("\n", ...args);
+  };
+};
+
+// ../../packages/core/lib/generator-builder/generatorBuilder.js
+function listToRuleDefMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
+}
+var GeneratorBuilder = class _GeneratorBuilder {
+  static create(start) {
+    if (start instanceof _GeneratorBuilder) {
+      return new _GeneratorBuilder({ ...start.rules });
+    }
+    return new _GeneratorBuilder(listToRuleDefMap(start));
+  }
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
+  /**
+   * Change the implementation of an existing generator rule.
+   */
+  patchRule(patch) {
+    const self2 = this;
+    self2.rules[patch.name] = patch;
+    return self2;
+  }
+  /**
+   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self2 = this;
+    const rules = self2.rules;
+    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
+      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);
+    }
+    rules[rule.name] = rule;
+    return self2;
+  }
+  /**
+   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
+   */
+  addRule(rule) {
+    return this.addRuleRedundant(rule);
+  }
+  addMany(...rules) {
+    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+    return this;
+  }
+  /**
+   * Delete a grammar rule by its name.
+   */
+  deleteRule(ruleName) {
+    delete this.rules[ruleName];
+    return this;
+  }
+  /**
+   * Merge this grammar GeneratorBuilder with another.
+   * It is best to merge the bigger grammar with the smaller one.
+   * If the two builders both have a grammar rule with the same name,
+   * no error will be thrown case they map to the same ruledef object.
+   * If they map to a different object, an error will be thrown.
+   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,
+   * this rule implementation will be used.
+   */
+  merge(GeneratorBuilder2, overridingRules) {
+    const otherRules = { ...GeneratorBuilder2.rules };
+    const myRules = this.rules;
+    for (const rule of Object.values(myRules)) {
+      if (otherRules[rule.name] === void 0) {
+        otherRules[rule.name] = rule;
+      } else {
+        const existingRule = otherRules[rule.name];
+        if (existingRule !== rule) {
+          const override = overridingRules.find((x) => x.name === rule.name);
+          if (override) {
+            otherRules[rule.name] = override;
+          } else {
+            throw new Error(`Rule with name "${rule.name}" already exists in the GeneratorBuilder, specify an override to resolve conflict`);
+          }
+        }
+      }
+    }
+    this.rules = otherRules;
+    return this;
+  }
+  build() {
+    return new DynamicGenerator(this.rules);
+  }
+};
+
+// ../../packages/core/lib/lexer-builder/LexerBuilder.js
+var LexerBuilder = class _LexerBuilder {
+  tokens;
+  static create(starter) {
+    return new _LexerBuilder(starter);
+  }
+  constructor(starter) {
+    this.tokens = starter?.tokens ? [...starter.tokens] : [];
+  }
+  merge(merge, overwrite = []) {
+    const extraTokens = merge.tokens.filter((token) => {
+      const overwriteToken = overwrite.find((t) => t.name === token.name);
+      if (overwriteToken) {
+        return false;
+      }
+      const match = this.tokens.find((t) => t.name === token.name);
+      if (match) {
+        if (match !== token) {
+          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);
+        }
+        return false;
+      }
       return true;
     });
     this.tokens.push(...extraTokens);
@@ -9667,16 +9715,13 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../../packages/core/lib/utils.js
-function unCapitalize(str2) {
-  return str2.charAt(0).toLowerCase() + str2.slice(1);
-}
-function createToken2(config) {
-  return createToken(config);
-}
-
 // ../../packages/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)) {
@@ -9686,104 +9731,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);
   }
 };
 
@@ -11181,8 +11335,8 @@ function UpdateOperationFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factory.js
-var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
+// ../../packages/rules-sparql-1-1/lib/astFactory.js
+var AstFactory = class extends asArg(AstCoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
   alwaysSparql11(obj) {
     return true;
   }
@@ -11279,12 +11433,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 {
 };
 
 // ../../packages/rules-sparql-1-1/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];
@@ -11363,77 +11517,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})`);
       }
@@ -11459,12 +11605,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);
       }
@@ -11503,22 +11649,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);
       }
     }
@@ -11540,7 +11686,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 = {
@@ -11551,7 +11697,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 = {
@@ -11562,7 +11708,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 = {
@@ -11572,7 +11718,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 = {
@@ -11597,7 +11743,7 @@ var string = {
       } }
     ]);
     return ACTION(() => {
-      const F3 = C.factory;
+      const F3 = C.astFactory;
       const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
         switch (char) {
           case "t":
@@ -11624,16 +11770,16 @@ var iri2 = {
     { ALT: () => SUBRULE(iriFull) },
     { ALT: () => SUBRULE(prefixedName) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
 };
 var iriFull = {
   name: "iriFull",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const iriToken = CONSUME(terminals_exports.iriRef);
-    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
+    return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
   },
-  gImpl: ({ PRINT }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT("<", ast.value, ">"));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT("<", ast.value, ">"));
   }
 };
 var prefixedName = {
@@ -11643,16 +11789,16 @@ var prefixedName = {
       const longName = CONSUME(terminals_exports.pNameLn);
       return ACTION(() => {
         const [prefix, localName] = longName.image.split(":");
-        return C.factory.namedNode(C.factory.sourceLocation(longName), localName, prefix);
+        return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
       });
     } },
     { ALT: () => {
       const shortName = CONSUME(terminals_exports.pNameNs);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
     } }
   ]),
-  gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
-    factory.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11662,11 +11808,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(() => {
@@ -11676,15 +11822,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));
   }
 };
 
@@ -11701,7 +11847,7 @@ var prologue = {
     ]));
     return result;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
         SUBRULE(baseDecl2, context);
@@ -11716,11 +11862,12 @@ var baseDecl2 = {
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const base = CONSUME(baseDecl);
     const val = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
+    return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("BASE"));
     SUBRULE(iri2, ast.value);
+    F3.printFilter(ast, () => PRINT_WORD("\n"));
   }
 };
 var prefixDecl2 = {
@@ -11729,13 +11876,14 @@ var prefixDecl2 = {
     const prefix = CONSUME(prefixDecl);
     const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
     const value = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
+    return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
   },
-  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORDS("PREFIX", `${ast.key}:`);
     });
     SUBRULE(iri2, ast.value);
+    F3.printFilter(ast, () => PRINT_WORDS("\n"));
   }
 };
 var verb = {
@@ -11751,7 +11899,7 @@ var varOrTerm = {
     { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
     { ALT: () => SUBRULE(graphTerm) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermVariable(ast)) {
       return SUBRULE(var_, ast);
     }
@@ -11772,9 +11920,9 @@ var var_ = {
       { ALT: () => CONSUME(terminals_exports.var1) },
       { ALT: () => CONSUME(terminals_exports.var2) }
     ]);
-    return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
+    return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
   }
 };
@@ -11788,10 +11936,10 @@ var graphTerm = {
     { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
     { ALT: () => {
       const tokenNil = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
     } }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else if (F3.isTermLiteral(ast)) {
@@ -11811,14 +11959,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)));
         } }
       ]);
     }
@@ -11839,9 +11987,9 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
         const clause = SUBRULE(subRule);
         clauses.push(clause);
       });
-      return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
+      return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       for (const clause of ast.clauses) {
         F3.printFilter(ast, () => PRINT_WORD(fromUsing));
         if (clause.clauseType === "named") {
@@ -11859,7 +12007,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 = {
@@ -11876,7 +12024,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)));
     }
   };
 }
@@ -11890,7 +12038,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)));
     }
   };
 }
@@ -11906,7 +12054,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)));
     }
   };
 }
@@ -11918,7 +12066,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)));
     }
   };
 }
@@ -11932,11 +12080,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)));
         } }
       ]);
     }
@@ -11948,7 +12096,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)));
     }
   };
 }
@@ -11958,7 +12106,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)));
     }
   };
 }
@@ -11976,7 +12124,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)));
     }
   };
 }
@@ -11996,7 +12144,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)));
     }
   };
 }
@@ -12006,7 +12154,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)));
     }
   };
 }
@@ -12019,7 +12167,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)));
     }
   };
 }
@@ -12159,17 +12307,17 @@ var aggregateCount = {
     const expressionVal = OR([
       { ALT: () => {
         const starToken = CONSUME(symbols_exports.star);
-        return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
+        return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
       } },
       { ALT: () => SUBRULE(expression) }
     ]);
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      const F3 = C.factory;
-      if (C.factory.isWildcard(expressionVal)) {
-        return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      const F3 = C.astFactory;
+      if (C.astFactory.isWildcard(expressionVal)) {
+        return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
       }
-      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12193,7 +12341,7 @@ var aggregateGroup_concat = {
     });
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
-      const F3 = C.factory;
+      const F3 = C.astFactory;
       return F3.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F3.sourceLocation(operatorToken, closeToken));
     });
   }
@@ -12223,7 +12371,7 @@ var aggregate = {
     });
     return result;
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD(ast.aggregation.toUpperCase(), "(");
       if (ast.distinct) {
@@ -12250,7 +12398,7 @@ var path = {
 };
 var pathGenerator = {
   name: "path",
-  gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F3 }, braces = true) => {
+  gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F3 }, braces = true) => {
     if (F3.isTerm(ast) && F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -12299,7 +12447,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)));
     }
   };
 }
@@ -12310,7 +12458,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)));
     } }
   ])
 };
@@ -12321,7 +12469,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 = {
@@ -12353,7 +12501,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);
@@ -12366,7 +12514,7 @@ var pathNegatedPropertySet = {
         });
         const close = CONSUME(symbols_exports.RParen);
         return ACTION(() => {
-          const F3 = C.factory;
+          const F3 = C.astFactory;
           if (tail.length === 0) {
             return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
           }
@@ -12387,7 +12535,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)));
     } }
   ])
 };
@@ -12412,33 +12560,35 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
         });
       }
     });
-    return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
+    return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
   };
 }
 var triplesBlock = {
   name: "triplesBlock",
   impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F3.isTripleCollection(triple)) {
           SUBRULE(graphNodePath, triple);
-          F3.printFilter(triple, () => PRINT_WORD("."));
+          F3.printFilter(triple, () => PRINT_WORD(".\n"));
         } else {
           SUBRULE(graphNodePath, triple.subject);
+          F3.printFilter(triple, () => PRINT_WORD(""));
           if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
             SUBRULE(varOrTerm, triple.predicate);
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
           if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD("."));
+            F3.printFilter(ast, () => PRINT_WORD(".\n"));
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";"));
+            F3.printFilter(ast, () => PRINT_WORD(";\n"));
           }
         }
       });
@@ -12451,24 +12601,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;
         });
       } }
@@ -12552,7 +12702,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));
     }
   };
 }
@@ -12569,7 +12719,7 @@ function collectionImpl(name, allowPaths) {
       });
       const endToken = CONSUME(symbols_exports.RParen);
       return ACTION(() => {
-        const F3 = C.factory;
+        const F3 = C.astFactory;
         const triples = [];
         const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
         const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12593,7 +12743,7 @@ function collectionImpl(name, allowPaths) {
         return F3.tripleCollectionList(listHead, triples, F3.sourceLocation(startToken, endToken));
       });
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => PRINT_WORD("("));
       for (const [idx, triple] of ast.triples.entries()) {
         if (idx % 2 === 0) {
@@ -12624,13 +12774,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       const startToken = CONSUME(symbols_exports.LSquare);
-      const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
+      const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
       const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
       const endToken = CONSUME(symbols_exports.RSquare);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
     },
-    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT("["));
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
+      const { astFactory: F3, indentInc } = c;
+      F3.printFilter(ast, () => {
+        c[traqulaIndentation] += indentInc;
+        PRINT("[\n");
+      });
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
           if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
@@ -12638,11 +12792,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
           } else {
             SUBRULE(pathGenerator, triple.predicate, void 0);
           }
+          F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
-          F3.printFilter(ast, () => PRINT_WORD(";"));
+          F3.printFilter(ast, () => PRINT_WORD(";\n"));
         });
       }
-      F3.printFilter(ast, () => PRINT("]"));
+      F3.printFilter(ast, () => {
+        c[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("]");
+      });
     }
   };
 }
@@ -12659,7 +12817,7 @@ function graphNodeImpl(name, allowPaths) {
         ALT: () => SUBRULE(triplesNodeRule)
       }
     ]),
-    gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
       if (F3.isTerm(ast)) {
         SUBRULE(varOrTerm, ast);
       } else {
@@ -12677,9 +12835,9 @@ var whereClause = {
   impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
     const where2 = OPTION(() => CONSUME(where));
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
+    return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("WHERE"));
     SUBRULE(groupGraphPattern, ast.val);
   }
@@ -12693,19 +12851,26 @@ var groupGraphPattern = {
       { ALT: () => SUBRULE(groupGraphPatternSub) }
     ]);
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("{"));
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     for (const pattern of ast.patterns) {
       SUBRULE(generatePattern, pattern);
     }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var generatePattern = {
   name: "generatePattern",
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (ast.type === "query") {
       SUBRULE(query, F3.querySelect({
         context: [],
@@ -12794,9 +12959,9 @@ var optionalGraphPattern = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const optional2 = CONSUME(optional);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
+    return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
   }
@@ -12807,9 +12972,9 @@ var graphGraphPattern = {
     const graph2 = CONSUME(graph_exports.graph);
     const name = SUBRULE(varOrIri);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
+    return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.name);
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
@@ -12825,9 +12990,9 @@ var serviceGraphPattern = {
     }) ?? false;
     const name = SUBRULE1(varOrIri);
     const group = SUBRULE1(groupGraphPattern);
-    return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
+    return ACTION(() => C.astFactory.patternService(name, group.patterns, silent2, C.astFactory.sourceLocation(service2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("SERVICE");
       if (ast.silent) {
@@ -12847,14 +13012,14 @@ var bind2 = {
     CONSUME(as);
     const variable = SUBRULE(var_);
     const close = CONSUME(symbols_exports.RParen);
-    return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
+    return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("BIND", "("));
     SUBRULE(expression, ast.expression);
     F3.printFilter(ast, () => PRINT_WORD("AS"));
     SUBRULE(var_, ast.variable);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
+    F3.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var inlineData = {
@@ -12862,16 +13027,19 @@ var inlineData = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const values3 = CONSUME(values2);
     const datablock = SUBRULE(dataBlock);
-    return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
+    return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     const variables = Object.keys(ast.values.at(0) ?? {});
     F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
       PRINT_WORD("VALUES", "(");
       for (const variable of variables) {
         PRINT_WORD(`?${variable}`);
       }
-      PRINT_WORD(")", "{");
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD(")", "{\n");
     });
     for (const mapping of ast.values) {
       F3.printFilter(ast, () => PRINT_WORD("("));
@@ -12882,9 +13050,12 @@ var inlineData = {
           SUBRULE(graphNodePath, mapping[variable]);
         }
       }
-      F3.printFilter(ast, () => PRINT_WORD(")"));
+      F3.printFilter(ast, () => PRINT_WORD(")\n"));
     }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 var dataBlock = {
@@ -12907,7 +13078,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 = {
@@ -12924,7 +13095,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);
@@ -12956,7 +13127,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)));
       } }
     ]);
   }
@@ -12979,9 +13150,9 @@ var minusGraphPattern = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const minus2 = CONSUME(minus);
     const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
+    return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus2, group)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("MINUS"));
     SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
   }
@@ -12997,9 +13168,9 @@ var groupOrUnionGraphPattern = {
       const group2 = SUBRULE2(groupGraphPattern);
       groups.push(group2);
     });
-    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
+    return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isPatternUnion(ast)) {
       const [head2, ...tail] = ast.patterns;
       SUBRULE(groupGraphPattern, head2);
@@ -13017,12 +13188,12 @@ var filter3 = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const filterToken = CONSUME(filter2);
     const expression2 = SUBRULE(constraint);
-    return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
+    return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
     SUBRULE(expression, ast.expression);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
+    F3.printFilter(ast, () => PRINT_WORD(")\n"));
   }
 };
 var constraint = {
@@ -13038,7 +13209,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)));
   }
 };
 
@@ -13048,7 +13219,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 = [];
@@ -13065,10 +13236,10 @@ var argList = {
         }
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.wrap({ args, distinct: distinct2 }, C.factory.sourceLocation(open, close)));
+      return ACTION(() => C.astFactory.wrap({ args, distinct: distinct2 }, C.astFactory.sourceLocation(open, close)));
     } }
   ]),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("(");
       if (ast.val.distinct) {
@@ -13091,7 +13262,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);
@@ -13103,7 +13274,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)));
     } }
   ])
 };
@@ -13112,7 +13283,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
 var expression = {
   name: "expression",
   impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isTerm(ast)) {
       SUBRULE(varOrTerm, ast);
     } else if (F3.isExpressionOperator(ast)) {
@@ -13177,7 +13348,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 = {
@@ -13185,7 +13356,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 = {
@@ -13207,7 +13378,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([
@@ -13215,7 +13386,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;
@@ -13234,7 +13405,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([
@@ -13265,9 +13436,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)
 };
@@ -13284,7 +13455,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)
 };
@@ -13299,7 +13470,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)));
     } }
   ])
 };
@@ -13322,7 +13493,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;
     });
   }
@@ -13344,13 +13515,13 @@ var iriOrFunction = {
           function: iriVal,
           args: args.val.args,
           distinct: distinct2,
-          loc: C.factory.sourceLocation(iriVal, args)
+          loc: C.astFactory.sourceLocation(iriVal, args)
         };
       });
     });
     return functionCall2 ?? iriVal;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isTermNamed(ast)) {
       SUBRULE(iri2, ast);
     } else {
@@ -13403,11 +13574,14 @@ var groupClause = {
       type: "solutionModifier",
       subType: "group",
       groupings,
-      loc: C.factory.sourceLocation(start, groupings.at(-1))
+      loc: C.astFactory.sourceLocation(start, groupings.at(-1))
     }));
   },
-  gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
+  gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("GROUP", "BY");
+    });
     for (const grouping of ast.groupings) {
       if (F3.isExpression(grouping)) {
         SUBRULE(expression, grouping);
@@ -13441,7 +13615,7 @@ var groupCondition = {
             return {
               variable,
               value: expressionValue,
-              loc: C.factory.sourceLocation(open, close)
+              loc: C.astFactory.sourceLocation(open, close)
             };
           }
           return expressionValue;
@@ -13460,10 +13634,13 @@ var havingClause = {
       expressions.push(SUBRULE(havingCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
+    return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
   },
-  gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("HAVING"));
+  gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORD("HAVING");
+    });
     for (const having2 of ast.having) {
       SUBRULE(expression, having2);
     }
@@ -13484,10 +13661,13 @@ var orderClause = {
       orderings.push(SUBRULE1(orderCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
+    return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order2, orderings.at(-1))));
   },
-  gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
+      PRINT_WORDS("ORDER", "BY");
+    });
     for (const ordering of ast.orderDefs) {
       if (ordering.descending) {
         F3.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13518,7 +13698,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: () => {
@@ -13537,16 +13717,17 @@ var limitOffsetClauses = {
     { ALT: () => {
       const limit2 = SUBRULE1(limitClause);
       const offset2 = OPTION1(() => SUBRULE1(offsetClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.astFactory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
     } },
     { ALT: () => {
       const offset2 = SUBRULE2(offsetClause);
       const limit2 = OPTION2(() => SUBRULE2(limitClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
+      return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
     } }
   ]),
-  gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("");
       if (ast.limit) {
         PRINT_WORDS("LIMIT", String(ast.limit));
       }
@@ -13562,7 +13743,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 = {
@@ -13571,7 +13752,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)));
   }
 };
 
@@ -13596,10 +13777,10 @@ var query = {
       ...subType,
       type: "query",
       ...values3 && { values: values3 },
-      loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
+      loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
     }));
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     SUBRULE(prologue, ast.context);
     if (F3.isQuerySelect(ast)) {
       SUBRULE(selectQuery, ast);
@@ -13629,13 +13810,13 @@ var selectQuery = {
         solutionModifiers: modifiers,
         datasets: from2,
         ...selectVal.val,
-        loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+        loc: C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
       };
       queryIsGood(ret);
       return ret;
     });
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     SUBRULE(selectClause, F3.wrap({
       variables: ast.variables,
       distinct: ast.distinct,
@@ -13653,14 +13834,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 = {
@@ -13691,7 +13872,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: () => {
@@ -13721,7 +13902,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)));
             });
           } }
         ]));
@@ -13729,9 +13910,9 @@ var selectClause = {
       } }
     ]);
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
-    return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select2, last2)));
+    return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("SELECT");
       if (ast.val.distinct) {
@@ -13771,7 +13952,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: () => {
@@ -13783,19 +13964,26 @@ var constructQuery = {
           subType: "construct",
           template: template.val,
           datasets: from2,
-          where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
+          where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
           solutionModifiers: modifiers,
-          loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+          loc: C.astFactory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
         }));
       } }
     ]);
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
     if (!F3.isSourceLocationNoMaterialize(ast.where.loc)) {
-      F3.printFilter(ast, () => PRINT_WORD("{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("{\n");
+      });
       SUBRULE(triplesBlock, ast.template);
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(datasetClauseStar, ast.datasets);
     if (F3.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13820,7 +14008,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);
@@ -13832,10 +14020,10 @@ var describeQuery = {
       datasets: from2,
       ...where2 && { where: where2.val },
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+      loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
     if (F3.isWildcard(ast.variables[0])) {
       F3.printFilter(ast, () => PRINT_WORD("*"));
@@ -13863,10 +14051,10 @@ var askQuery = {
       datasets: from2,
       where: where2.val,
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
+      loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("ASK"));
     SUBRULE(datasetClauseStar, ast.datasets);
     SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
@@ -13883,7 +14071,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 = {
@@ -13920,13 +14108,13 @@ var update = {
       const update2 = {
         type: "update",
         updates,
-        loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
+        loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
       };
       updateNoReuseBlankNodeLabels(update2);
       return update2;
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     const [head2, ...tail] = ast.updates;
     if (head2) {
       SUBRULE(prologue, head2.context);
@@ -14006,9 +14194,9 @@ var load2 = {
       CONSUME(loadInto);
       return SUBRULE1(graphRef);
     });
-    return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
+    return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("LOAD");
       if (ast.silent) {
@@ -14029,9 +14217,9 @@ function clearOrDrop(operation) {
       const opToken = CONSUME(operation);
       const silent2 = OPTION(() => CONSUME(silent));
       const destination = SUBRULE1(graphRefAll);
-      return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
+      return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -14050,9 +14238,9 @@ var create2 = {
     const createToken3 = CONSUME(create);
     const silent2 = OPTION(() => CONSUME(silent));
     const destination = SUBRULE1(graphRef);
-    return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
+    return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORD("CREATE");
       if (ast.silent) {
@@ -14071,9 +14259,9 @@ function copyMoveAddOperation(operation) {
       const source = SUBRULE1(graphOrDefault);
       CONSUME(to);
       const destination = SUBRULE2(graphOrDefault);
-      return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
+      return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
         PRINT_WORD(operation.name.toUpperCase());
         if (ast.silent) {
@@ -14095,7 +14283,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 = {
@@ -14106,7 +14294,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) {
@@ -14123,12 +14311,26 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
       if (name !== "insertData") {
         ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
       }
-      return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
+      return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+      const { astFactory: F3, indentInc } = C;
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        if (subType === "insertdata") {
+          PRINT_WORD("INSERT DATA");
+        } else if (subType === "deletedata") {
+          PRINT_WORD("DELETE DATA");
+        } else if (subType === "deletewhere") {
+          PRINT_WORD("DELETE WHERE");
+        }
+        PRINT_WORD("{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.data, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
   };
 }
@@ -14157,22 +14359,35 @@ var modify = {
     const using = SUBRULE1(usingClauseStar);
     CONSUME(where);
     const where2 = SUBRULE1(groupGraphPattern);
-    return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
+    return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     if (ast.graph) {
       F3.printFilter(ast, () => PRINT_WORD("WITH"));
       SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
-      F3.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("DELETE", "{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.delete, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     if (ast.insert.length > 0) {
-      F3.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("INSERT", "{\n");
+      });
       SUBRULE(quads, F3.wrap(ast.insert, ast.loc));
-      F3.printFilter(ast, () => PRINT_WORD("}"));
+      F3.printFilter(ast, () => {
+        C[traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}\n");
+      });
     }
     SUBRULE(usingClauseStar, ast.from);
     F3.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -14186,7 +14401,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 = {
@@ -14194,7 +14409,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 = {
@@ -14202,12 +14417,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)));
     } }
   ])
 };
@@ -14216,9 +14431,9 @@ var graphRef = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const graph2 = CONSUME(graph_exports.graph);
     const val = SUBRULE(iri2);
-    return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
+    return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph2, val)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(iri2, ast.graph);
   }
@@ -14229,18 +14444,18 @@ var graphRefAll = {
     { ALT: () => SUBRULE(graphRef) },
     { ALT: () => {
       const def = CONSUME(graph_exports.default_);
-      return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
+      return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
     } },
     { ALT: () => {
       const named2 = CONSUME(graph_exports.named);
-      return ACTION(() => C.factory.graphRefNamed(C.factory.sourceLocation(named2)));
+      return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named2)));
     } },
     { ALT: () => {
       const graphAll2 = CONSUME(graph_exports.graphAll);
-      return ACTION(() => C.factory.graphRefAll(C.factory.sourceLocation(graphAll2)));
+      return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll2)));
     } }
   ]),
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     if (F3.isGraphRefSpecific(ast)) {
       SUBRULE(graphRef, ast);
     } else if (F3.isGraphRefDefault(ast)) {
@@ -14277,9 +14492,9 @@ var quads = {
         ACTION(() => quads2.push(triples));
       });
     });
-    return ACTION(() => C.factory.wrap(quads2, C.factory.sourceLocation(quads2.at(0), last2)));
+    return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last2)));
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const quad of ast.val) {
       if (F3.isPattern(quad)) {
         SUBRULE(triplesBlock, quad);
@@ -14297,14 +14512,21 @@ var quadsNotTriples = {
     CONSUME(symbols_exports.LCurly);
     const triples = OPTION(() => SUBRULE1(triplesTemplate));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
+    return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.graph);
-    F3.printFilter(ast, () => PRINT_WORD("{"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] += indentInc;
+      PRINT_WORD("{\n");
+    });
     SUBRULE(triplesBlock, ast.triples);
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    F3.printFilter(ast, () => {
+      C[traqulaIndentation] -= indentInc;
+      PRINT_ON_EMPTY("}\n");
+    });
   }
 };
 
@@ -14327,7 +14549,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: () => {
@@ -14351,7 +14573,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;
@@ -14359,7 +14581,7 @@ var queryOrUpdate = {
       } }
     ]);
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     if (F3.isQuery(ast)) {
       SUBRULE(query, ast);
     } else {
@@ -14463,8 +14685,78 @@ var LANG_DIR = createToken2({
 });
 var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(lexer_exports.symbols.logicAnd, tilde, annotationOpen, annotationClose, tripleTermOpen, tripleTermClose, reificationOpen, reificationClose, version).addBefore(lexer_exports.builtIn.langmatches, buildInLangDir, buildInStrLangDir, buildInHasLangDir, buildInHasLang, buildInIsTRIPLE, buildInTRIPLE, buildInSUBJECT, buildInPREDICATE, buildInOBJECT).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
 
+// ../../packages/rules-sparql-1-2/lib/AstFactory.js
+var AstFactory2 = class extends AstFactory {
+  termTriple(subject, predicate, object3, loc) {
+    return {
+      type: "term",
+      subType: "triple",
+      subject,
+      predicate,
+      object: object3,
+      loc
+    };
+  }
+  isTermTriple(obj) {
+    return this.isOfSubType(obj, "term", "triple");
+  }
+  tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
+    return {
+      type: "tripleCollection",
+      subType: "reifiedTriple",
+      triples: [this.triple(subject, predicate, object3)],
+      identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
+      loc
+    };
+  }
+  isTripleCollectionReifiedTriple(obj) {
+    return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
+  }
+  tripleCollectionBlankNodeProperties(identifier, triples, loc) {
+    return {
+      type: "tripleCollection",
+      subType: "blankNodeProperties",
+      triples,
+      identifier,
+      loc
+    };
+  }
+  /**
+   * Overwritten triple constructor to always contain an empty annotations list
+   */
+  triple = (subject, predicate, object3, loc) => ({
+    type: "triple",
+    subject,
+    predicate,
+    object: object3,
+    annotations: [],
+    loc: loc ?? this.sourceLocation(subject, predicate, object3)
+  });
+  annotatedTriple(subject, predicate, object3, annotations, loc) {
+    return {
+      type: "triple",
+      subject,
+      predicate,
+      object: object3,
+      annotations: annotations ?? [],
+      loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
+    };
+  }
+  contextDefinitionVersion(version2, loc) {
+    return {
+      type: "contextDef",
+      subType: "version",
+      version: version2,
+      loc
+    };
+  }
+  isContextDefinitionVersion(obj) {
+    return this.isOfSubType(obj, "contextDef", "version");
+  }
+};
+
 // ../../packages/rules-sparql-1-2/lib/validators.js
-var F2 = new Factory();
+var F2 = new AstFactory2();
 function isLangDir(dir) {
   return dir === "ltr" || dir === "rtl";
 }
@@ -14486,11 +14778,11 @@ var versionDecl = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const versionToken = CONSUME(version);
     const identifier = SUBRULE(versionSpecifier);
-    return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
+    return ACTION(() => C.astFactory.contextDefinitionVersion(identifier.val, C.astFactory.sourceLocation(versionToken, identifier)));
   },
-  gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
+  gImpl: ({ PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`);
+      PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`, "\n");
     });
   }
 };
@@ -14501,7 +14793,7 @@ var versionSpecifier = {
       { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral1) },
       { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral2) }
     ]);
-    return ACTION(() => C.factory.wrap(token.image.slice(1, -1), C.factory.sourceLocation(token)));
+    return ACTION(() => C.astFactory.wrap(token.image.slice(1, -1), C.astFactory.sourceLocation(token)));
   }
 };
 var prologue2 = {
@@ -14517,7 +14809,7 @@ var prologue2 = {
     ]));
     return result;
   },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
         SUBRULE(grammar_exports.baseDecl, context);
@@ -14534,7 +14826,7 @@ function reifiedTripleBlockImpl(name, allowPath) {
     name,
     impl: ({ ACTION, SUBRULE }) => (C) => {
       const triple = SUBRULE(reifiedTriple);
-      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.factory.dematerialized(triple.identifier)));
+      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.astFactory.dematerialized(triple.identifier)));
       return ACTION(() => [triple, ...properties]);
     }
   };
@@ -14557,7 +14849,7 @@ var reifier = {
       if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.wrap(reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()), C.factory.sourceLocation(tildeToken, reifier2));
+      return C.astFactory.wrap(reifier2 ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
     });
   }
 };
@@ -14587,7 +14879,7 @@ function objectImpl2(name, allowPaths) {
       const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2);
       const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
       return ACTION(() => {
-        const F3 = C.factory;
+        const F3 = C.astFactory;
         if (F3.isPathPure(predicate) && annotationVal.length > 0) {
           throw new Error("Note 17 violation");
         }
@@ -14616,7 +14908,7 @@ function annotationImpl(name, allowPaths) {
               if (!currentReifier && !C.parseMode.has("canCreateBlankNodes")) {
                 throw new Error("Cannot create blanknodes in current parse mode");
               }
-              currentReifier = currentReifier ?? C.factory.blankNode(void 0, C.factory.sourceLocation());
+              currentReifier = currentReifier ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation());
             });
             const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
             ACTION(() => {
@@ -14628,7 +14920,7 @@ function annotationImpl(name, allowPaths) {
       });
       return annotations;
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
       for (const annotation2 of ast) {
         if (F3.isTripleCollectionBlankNodeProperties(annotation2)) {
           SUBRULE(annotationBlockPath, annotation2);
@@ -14649,11 +14941,18 @@ function annotationBlockImpl(name, allowPaths) {
       const open = CONSUME(annotationOpen);
       const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, arg);
       const close = CONSUME(annotationClose);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(arg, res, C.astFactory.sourceLocation(open, close)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD("{|"));
-      for (const triple of ast.triples) {
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, C) => {
+      const { astFactory: F3, indentInc } = C;
+      F3.printFilter(ast, () => {
+        PRINT_WORD("{|");
+        if (ast.triples.length > 1) {
+          C[traqulaIndentation] += indentInc;
+          PRINT_WORD("\n");
+        }
+      });
+      function printTriple(triple) {
         HANDLE_LOC(triple, () => {
           if (F3.isTerm(triple.predicate)) {
             SUBRULE(graphNodePath2, triple.predicate);
@@ -14661,10 +14960,21 @@ function annotationBlockImpl(name, allowPaths) {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           }
           SUBRULE(graphNodePath2, triple.object);
-          F3.printFilter(ast, () => PRINT_WORD(";"));
         });
       }
-      F3.printFilter(ast, () => PRINT_WORD("|}"));
+      const [head2, ...tail] = ast.triples;
+      printTriple(head2);
+      for (const triple of tail) {
+        F3.printFilter(ast, () => PRINT_WORD(";\n"));
+        printTriple(triple);
+      }
+      F3.printFilter(ast, () => {
+        if (ast.triples.length > 1) {
+          PRINT_ON_EMPTY("|}\n");
+        } else {
+          PRINT_WORD("|}");
+        }
+      });
     }
   };
 }
@@ -14684,7 +14994,7 @@ var graphNodePath2 = {
     { ALT: () => $.SUBRULE(reifiedTriple) }
   ]),
   gImpl: ($) => (ast, C) => {
-    if (C.factory.isTripleCollectionReifiedTriple(ast)) {
+    if (C.astFactory.isTripleCollectionReifiedTriple(ast)) {
       $.SUBRULE(reifiedTriple, ast);
     } else {
       grammar_exports.graphNodePath.gImpl($)(ast, C);
@@ -14702,7 +15012,7 @@ var varOrTerm2 = {
     { ALT: () => SUBRULE(grammar_exports.blankNode) },
     { ALT: () => {
       const token = CONSUME(lexer_exports.terminals.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.NIL));
     } },
     { ALT: () => SUBRULE(tripleTerm) }
   ])
@@ -14721,10 +15031,10 @@ var reifiedTriple = {
       if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
+      return C.astFactory.tripleCollectionReifiedTriple(C.astFactory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<"));
     const triple = ast.triples[0];
     SUBRULE(graphNodePath2, triple.subject);
@@ -14763,9 +15073,9 @@ var tripleTerm = {
     const predicate = SUBRULE(grammar_exports.verb);
     const object3 = SUBRULE(tripleTermObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<("));
     SUBRULE(graphNodePath2, ast.subject);
     SUBRULE(graphNodePath2, ast.predicate);
@@ -14798,12 +15108,12 @@ var tripleTermData = {
       { ALT: () => SUBRULE(grammar_exports.iri) },
       { ALT: () => {
         const token = CONSUME(lexer_exports.a);
-        return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
+        return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE));
       } }
     ]);
     const object3 = SUBRULE(tripleTermDataObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   }
 };
 var tripleTermDataSubject = {
@@ -14835,7 +15145,7 @@ var exprTripleTerm = {
     const predicate = SUBRULE(grammar_exports.verb);
     const object3 = SUBRULE(exprTripleTermObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
+    return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
   }
 };
 var exprTripleTermSubject = {
@@ -14885,7 +15195,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR);
         return ACTION(() => {
-          const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
+          const literal = C.astFactory.literalTerm(C.astFactory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
           langTagHasCorrectRange(literal);
           return literal;
         });
@@ -14893,7 +15203,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
         const iriVal = SUBRULE(grammar_exports.iri);
-        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
+        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   }
@@ -14905,7 +15215,7 @@ var unaryExpression2 = {
     { ALT: () => {
       const operator = CONSUME(lexer_exports.symbols.exclamation);
       const expr = SUBRULE1(unaryExpression2);
-      return ACTION(() => C.factory.expressionOperation("!", [expr], C.factory.sourceLocation(operator, expr)));
+      return ACTION(() => C.astFactory.expressionOperation("!", [expr], C.astFactory.sourceLocation(operator, expr)));
     } },
     { ALT: () => {
       const operator = OR2([
@@ -14913,34 +15223,36 @@ var unaryExpression2 = {
         { ALT: () => CONSUME(lexer_exports.symbols.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression2);
-      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
+      return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
     } }
   ])
 };
 var generateTriplesBlock = {
   name: "triplesBlock",
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F3.isTripleCollection(triple)) {
           SUBRULE(graphNodePath2, triple);
-          F3.printFilter(triple, () => PRINT_WORD("."));
+          F3.printFilter(triple, () => PRINT_WORD(".\n"));
         } else {
           SUBRULE(graphNodePath2, triple.subject);
+          F3.printFilter(ast, () => PRINT_WORD(""));
           if (F3.isPathPure(triple.predicate)) {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           } else {
             SUBRULE(graphNodePath2, triple.predicate);
           }
+          F3.printFilter(ast, () => PRINT_WORD(""));
           SUBRULE(graphNodePath2, triple.object);
           SUBRULE(annotationPath, triple.annotations ?? []);
           if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD("."));
+            F3.printFilter(ast, () => PRINT_WORD(".\n"));
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";"));
+            F3.printFilter(ast, () => PRINT_WORD(";\n"));
           }
         }
       });
@@ -14950,7 +15262,7 @@ var generateTriplesBlock = {
 var generateGraphTerm = {
   name: "graphTerm",
   gImpl: ($) => (ast, C) => {
-    if (C.factory.isTermTriple(ast)) {
+    if (C.astFactory.isTermTriple(ast)) {
       $.SUBRULE(tripleTerm, ast);
     } else {
       grammar_exports.graphTerm.gImpl($)(ast, C);
@@ -14958,86 +15270,18 @@ var generateGraphTerm = {
   }
 };
 
-// ../../packages/rules-sparql-1-2/lib/Factory.js
-var Factory2 = class extends Factory {
-  termTriple(subject, predicate, object3, loc) {
-    return {
-      type: "term",
-      subType: "triple",
-      subject,
-      predicate,
-      object: object3,
-      loc
-    };
-  }
-  isTermTriple(obj) {
-    return this.isOfSubType(obj, "term", "triple");
-  }
-  tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
-    return {
-      type: "tripleCollection",
-      subType: "reifiedTriple",
-      triples: [this.triple(subject, predicate, object3)],
-      identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
-      loc
-    };
-  }
-  isTripleCollectionReifiedTriple(obj) {
-    return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
-  }
-  tripleCollectionBlankNodeProperties(identifier, triples, loc) {
-    return {
-      type: "tripleCollection",
-      subType: "blankNodeProperties",
-      triples,
-      identifier,
-      loc
-    };
-  }
-  /**
-   * Overwritten triple constructor to always contain an empty annotations list
-   */
-  triple = (subject, predicate, object3, loc) => ({
-    type: "triple",
-    subject,
-    predicate,
-    object: object3,
-    annotations: [],
-    loc: loc ?? this.sourceLocation(subject, predicate, object3)
-  });
-  annotatedTriple(subject, predicate, object3, annotations, loc) {
-    return {
-      type: "triple",
-      subject,
-      predicate,
-      object: object3,
-      annotations: annotations ?? [],
-      loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
-    };
-  }
-  contextDefinitionVersion(version2, loc) {
-    return {
-      type: "contextDef",
-      subType: "version",
-      version: version2,
-      loc
-    };
-  }
-  isContextDefinitionVersion(obj) {
-    return this.isOfSubType(obj, "contextDef", "version");
-  }
-};
-
 // ../../packages/rules-sparql-1-2/lib/parserUtils.js
 function completeParseContext2(context) {
   return {
-    factory: context.factory ?? new Factory2(),
+    astFactory: context.astFactory ?? new AstFactory2(),
     baseIRI: context.baseIRI,
     prefixes: { ...context.prefixes },
     origSource: context.origSource ?? "",
     offset: context.offset,
     parseMode: context.parseMode ? new Set(context.parseMode) : /* @__PURE__ */ new Set(["canParseVars", "canCreateBlankNodes"]),
-    skipValidation: context.skipValidation ?? false
+    skipValidation: context.skipValidation ?? false,
+    indentInc: context.indentInc ?? 2,
+    [traqulaIndentation]: context[traqulaIndentation] ?? 0
   };
 }
 
@@ -15045,7 +15289,7 @@ function completeParseContext2(context) {
 var sparql12GeneratorBuilder = GeneratorBuilder.create(sparql11GeneratorBuilder).widenContext().typePatch().addRule(grammar_exports2.tripleTerm).addRule(grammar_exports2.reifiedTriple).patchRule(grammar_exports2.graphNodePath).addRule(grammar_exports2.annotationBlockPath).addRule(grammar_exports2.annotationPath).addRule(grammar_exports2.versionDecl).patchRule(grammar_exports2.prologue).patchRule(grammar_exports2.generateTriplesBlock).patchRule(grammar_exports2.generateGraphTerm);
 var Generator = class {
   generator = sparql12GeneratorBuilder.build();
-  F = new Factory2();
+  F = new AstFactory2();
   generate(ast, context = {}) {
     return this.generator.queryOrUpdate(ast, completeParseContext2(context));
   }