@traqula/parser-sparql-1-2 0.0.18 → 0.0.20

package/lib/index.cjs

@@ -42,7 +42,7 @@ var AstCoreFactory = class {
     if (filtered.length === 0) {
       return this.gen();
     }
-    const first2 = filtered[0];
+    const first2 = filtered.at(0);
     const last2 = filtered.at(-1);
     return {
       sourceLocationType: "source",
@@ -9603,10 +9603,10 @@ var ParserBuilder = class _ParserBuilder {
    * If a builder is provided, a new copy will be created.
    */
   static create(start) {
-    if (start instanceof _ParserBuilder) {
-      return new _ParserBuilder({ ...start.rules });
+    if (Array.isArray(start)) {
+      return new _ParserBuilder(listToRuleDefMap(start));
     }
-    return new _ParserBuilder(listToRuleDefMap(start));
+    return new _ParserBuilder({ ...start.rules });
   }
   rules;
   constructor(startRules) {
@@ -9655,6 +9655,9 @@ var ParserBuilder = class _ParserBuilder {
     delete this.rules[ruleName];
     return this;
   }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
   /**
    * Merge this grammar builder with another.
    * It is best to merge the bigger grammar with the smaller one.
@@ -9741,21 +9744,31 @@ ${firstError.message}`);
   }
 };
 
-// ../../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;
+// ../../packages/core/lib/TransformerObject.js
+var TransformerObject = class {
+  defaultContext;
+  maxStackSize = 1e6;
+  /**
+   * Creates stateless transformer.
+   * @param defaultContext
+   */
+  constructor(defaultContext = {}) {
+    this.defaultContext = defaultContext;
   }
-  safeObjectVisit(value, mapper) {
-    if (value && typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map((x) => this.safeObjectVisit(x, mapper));
-      }
-      return mapper(value);
+  /**
+   * Function to shallow clone any type.
+   * @param obj
+   * @protected
+   */
+  clone(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
     }
-    return value;
+    const proto = Object.getPrototypeOf(obj);
+    if (proto === Object.prototype || proto === null) {
+      return { ...obj };
+    }
+    return Object.assign(Object.create(proto), obj);
   }
   /**
    * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
@@ -9767,90 +9780,228 @@ var TransformerType = class {
    *    - Default false
    */
   transformObject(startObject, mapper, preVisitor = () => ({})) {
+    const defaults2 = this.defaultContext;
+    const defaultCopyFlag = defaults2.copy ?? true;
+    const defaultContinues = defaults2.continue ?? true;
+    const defaultIgnoreKeys = defaults2.ignoreKeys;
+    const defaultShallowKeys = defaults2.shallowKeys;
+    const defaultDidShortCut = defaults2.shortcut ?? false;
     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;
+    const resultWrap = { res: startObject };
+    const stack = [startObject];
+    const stackParent = [resultWrap];
+    const stackParentKey = ["res"];
+    const handleMapperOnLen = [];
+    const mapperCopyStack = [];
+    const mapperOrigStack = [];
+    const mapperParent = [];
+    const mapperParentKey = [];
+    function handleMapper() {
+      while (stack.length === handleMapperOnLen.at(-1)) {
+        handleMapperOnLen.pop();
+        const copyToMap = mapperCopyStack.pop();
+        const origToMap = mapperOrigStack.pop();
+        const parent = mapperParent.pop();
+        const parentKey = mapperParentKey.pop();
+        parent[parentKey] = mapper(copyToMap, origToMap);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      const curParent = stackParent.pop();
+      const curKey = stackParentKey.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          const newArr = [...curObject];
+          handleMapperOnLen.push(stack.length);
+          mapperCopyStack.push(newArr);
+          mapperOrigStack.push(curObject);
+          mapperParent.push(curParent);
+          mapperParentKey.push(curKey);
+          for (let index = curObject.length - 1; index >= 0; index--) {
+            const val = curObject[index];
+            if (val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParent.push(newArr);
+              stackParentKey.push(index.toString());
+            }
+          }
+          handleMapper();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        const copyFlag = context.copy ?? defaultCopyFlag;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        const shallowKeys = context.shallowKeys ?? defaultShallowKeys;
+        didShortCut = context.shortcut ?? defaultDidShortCut;
+        const copy3 = copyFlag ? this.clone(curObject) : curObject;
+        handleMapperOnLen.push(stack.length);
+        mapperCopyStack.push(copy3);
+        mapperOrigStack.push(curObject);
+        mapperParent.push(curParent);
+        mapperParentKey.push(curKey);
+        if (continues && !didShortCut) {
+          for (const key in copy3) {
+            if (!Object.hasOwn(copy3, key)) {
+              continue;
+            }
+            const val = copy3[key];
+            const onlyShallow = shallowKeys && shallowKeys?.has(key);
+            if (onlyShallow) {
+              copy3[key] = this.clone(val);
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            if (!onlyShallow && val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParentKey.push(key);
+              stackParent.push(copy3);
+            }
           }
-          copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
         }
       }
-      return mapper(copy3);
-    };
-    return recurse(startObject);
+      handleMapper();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleMapper();
+    return resultWrap.res;
   }
   /**
    * Visitor that visits all objects. Visits deeper objects first.
    */
   visitObject(startObject, visitor, preVisitor = () => ({})) {
+    const defaults2 = this.defaultContext;
+    const defaultContinues = defaults2.continue ?? true;
+    const defaultIgnoreKeys = defaults2.ignoreKeys;
+    const defaultShortcut = defaults2.shortcut ?? false;
     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;
+    const stack = [startObject];
+    const handleVisitorOnLen = [];
+    const visitorStack = [];
+    function handleVisitor() {
+      while (stack.length === handleVisitorOnLen.at(-1)) {
+        handleVisitorOnLen.pop();
+        const toVisit = visitorStack.pop();
+        visitor(toVisit);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          for (let i = curObject.length - 1; i >= 0; i--) {
+            stack.push(curObject[i]);
+          }
+          handleVisitor();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        didShortCut = context.shortcut ?? defaultShortcut;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        handleVisitorOnLen.push(stack.length);
+        visitorStack.push(curObject);
+        if (continues && !didShortCut) {
+          for (const key in curObject) {
+            if (!Object.hasOwn(curObject, key)) {
+              continue;
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            const val = curObject[key];
+            if (val && typeof val === "object") {
+              stack.push(val);
+            }
           }
-          this.safeObjectVisit(value, (obj) => recurse(obj));
         }
       }
-      visitor(curObject);
-    };
-    recurse(startObject);
+      handleVisitor();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleVisitor();
+  }
+};
+
+// ../../packages/core/lib/TransformerTyped.js
+var TransformerTyped = class extends TransformerObject {
+  defaultNodePreVisitor;
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext);
+    this.defaultNodePreVisitor = defaultNodePreVisitor;
   }
+  /**
+   * Transform a single node.
+   * The transformation calls the preVisitor from starting from the startObject.
+   * The preVisitor can dictate whether transformation should be stopped.
+   * Note that stopping the transformation also prevets further copying.
+   * The transformer itself transforms object starting with the deepest one that can be visited.
+   * The transformer callback is performed on a copy of the original.
+   * @param startObject
+   * @param nodeCallBacks
+   */
   transformNode(startObject, nodeCallBacks) {
-    const transformWrapper = (curObject) => {
-      const casted = curObject;
+    const transformWrapper = (copy3, orig) => {
+      let ogTransform;
+      const casted = copy3;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.transform;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogTransform = nodeCallBacks[casted.type]?.transform;
       }
-      return curObject;
+      return ogTransform ? ogTransform(casted, orig) : copy3;
     };
-    const preTransformWrapper = (curObject) => {
+    const nodeDefaults = this.defaultNodePreVisitor;
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      let nodeContext = {};
       const casted = curObject;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
       }
-      return {};
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
     };
-    return this.transformObject(startObject, transformWrapper, preTransformWrapper);
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
+  /**
+   * Similar to {@link this.transformNode}, but without copying the startObject.
+   * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
+   * @param startObject
+   * @param nodeCallBacks
+   */
   visitNode(startObject, nodeCallBacks) {
-    const visitWrapper = (curObject) => {
+    const visitorWrapper = (curObject) => {
       const casted = curObject;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.visitor;
-        if (ogFunc) {
-          ogFunc(casted);
+        const ogTransform = nodeCallBacks[casted.type]?.visitor;
+        if (ogTransform) {
+          ogTransform(casted);
         }
       }
     };
+    const nodeDefaults = this.defaultNodePreVisitor;
     const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      let nodeContext = {};
       const casted = curObject;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
       }
-      return {};
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
     };
-    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+    return this.visitObject(startObject, visitorWrapper, preVisitWrapper);
   }
+  /**
+   * Traverses only selected nodes as returned by the function.
+   * @param currentNode
+   * @param traverse
+   */
   traverseNodes(currentNode, traverse) {
     let didShortCut = false;
     const recurse = (curNode) => {
@@ -9871,11 +10022,24 @@ var TransformerType = class {
     recurse(currentNode);
   }
 };
-var TransformerSubType = class extends TransformerType {
+
+// ../../packages/core/lib/TransformerSubTyped.js
+var TransformerSubTyped = class extends TransformerTyped {
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext, defaultNodePreVisitor);
+  }
+  /**
+   * Shares the functionality and first two arguments with {@link this.transformNode}.
+   * The third argument allows you to also transform based on the subType of objects.
+   * Note that when a callback for the subtype is provided, the callback for the general type is **NOT** executed.
+   * @param startObject
+   * @param nodeCallBacks
+   * @param nodeSpecificCallBacks
+   */
   transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
-    const transformWrapper = (curObject) => {
+    const transformWrapper = (copy3, orig) => {
       let ogTransform;
-      const casted = curObject;
+      const casted = copy3;
       if (casted.type && casted.subType) {
         const specific = nodeSpecificCallBacks[casted.type];
         if (specific) {
@@ -9885,7 +10049,7 @@ var TransformerSubType = class extends TransformerType {
           ogTransform = nodeCallBacks[casted.type]?.transform;
         }
       }
-      return ogTransform ? ogTransform(casted) : curObject;
+      return ogTransform ? ogTransform(casted, orig) : copy3;
     };
     const preVisitWrapper = (curObject) => {
       let ogPreVisit;
@@ -9899,12 +10063,13 @@ var TransformerSubType = class extends TransformerType {
           ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
         }
       }
-      return ogPreVisit ? ogPreVisit(casted) : curObject;
+      return ogPreVisit ? ogPreVisit(casted) : {};
     };
     return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
   /**
-   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+   * Similar to {@link this.visitNode} but also allows you to match based on the subtype of objects.
+   * When both nodeCallBack and NodeSpecific callBack are matched, will only visit nodeSpecifCallback
    */
   visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
     const visitWrapper = (curObject) => {
@@ -9935,10 +10100,16 @@ var TransformerSubType = class extends TransformerType {
           ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
         }
       }
-      return ogPreVisit ? ogPreVisit(casted) : curObject;
+      return ogPreVisit ? ogPreVisit(casted) : {};
     };
     this.visitObject(startObject, visitWrapper, preVisitWrapper);
   }
+  /**
+   * Similar to {@link this.traverseNodes} but also allows you to match based on the subtype of objects.
+   * @param currentNode
+   * @param traverseNode
+   * @param traverseSubNode
+   */
   traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
     let didShortCut = false;
     const recurse = (curNode) => {
@@ -11011,8 +11182,8 @@ function PatternFactoryMixin(Base) {
     isPatternOptional(obj) {
       return this.isOfSubType(obj, nodeType5, "optional");
     }
-    patternValues(values3, loc) {
-      return { type: nodeType5, subType: "values", values: values3, loc };
+    patternValues(variables, values3, loc) {
+      return { type: nodeType5, subType: "values", variables, values: values3, loc };
     }
     isPatternValues(obj) {
       return this.isOfSubType(obj, nodeType5, "values");
@@ -11187,7 +11358,7 @@ function TermFactoryMixin(Base) {
     isTerm(x) {
       return this.isOfType(x, "term");
     }
-    blankNode(label, loc) {
+    termBlank(label, loc) {
       const base = {
         type: "term",
         subType: "blankNode",
@@ -11201,7 +11372,7 @@ function TermFactoryMixin(Base) {
     isTermBlank(obj) {
       return this.isOfSubType(obj, nodeType8, "blankNode");
     }
-    literalTerm(loc, value, langOrIri) {
+    termLiteral(loc, value, langOrIri) {
       return {
         type: nodeType8,
         subType: "literal",
@@ -11223,7 +11394,7 @@ function TermFactoryMixin(Base) {
       const casted = obj;
       return this.isTermLiteral(obj) && typeof casted.langOrIri === "object" && casted.langOrIri !== null && this.isTermNamed(casted.langOrIri);
     }
-    variable(value, loc) {
+    termVariable(value, loc) {
       return {
         type: nodeType8,
         subType: "variable",
@@ -11234,7 +11405,7 @@ function TermFactoryMixin(Base) {
     isTermVariable(obj) {
       return this.isOfSubType(obj, nodeType8, "variable");
     }
-    namedNode(loc, value, prefix) {
+    termNamed(loc, value, prefix) {
       const base = {
         type: nodeType8,
         subType: "namedNode",
@@ -11497,7 +11668,7 @@ 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 AstTransformer = class extends TransformerSubType {
+var AstTransformer = class extends TransformerSubTyped {
 };
 
 // ../../packages/rules-sparql-1-1/lib/validation/validators.js
@@ -11713,17 +11884,20 @@ var rdfLiteral = {
     return OPTION(() => OR([
       { ALT: () => {
         const lang2 = CONSUME(terminals_exports.langTag);
-        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
       } },
       { ALT: () => {
         CONSUME(symbols_exports.hathat);
         const iriVal = SUBRULE1(iri2);
-        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   },
-  gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { astFactory }) => {
-    astFactory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
+  gImpl: ({ SUBRULE, PRINT, PRINT_WORD }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => {
+      PRINT_WORD("");
+      PRINT(stringEscapedLexical(ast.value));
+    });
     if (ast.langOrIri) {
       if (typeof ast.langOrIri === "string") {
         astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
@@ -11750,7 +11924,7 @@ var numericLiteralUnsigned = {
       { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralPositive = {
@@ -11761,7 +11935,7 @@ var numericLiteralPositive = {
       { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralNegative = {
@@ -11772,7 +11946,7 @@ var numericLiteralNegative = {
       { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
       { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var booleanLiteral = {
@@ -11782,7 +11956,7 @@ var booleanLiteral = {
       { ALT: () => CONSUME(true_) },
       { ALT: () => CONSUME(false_) }
     ]);
-    return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
   }
 };
 var string = {
@@ -11824,7 +11998,7 @@ var string = {
             return char;
         }
       });
-      return F3.literalTerm(F3.sourceLocation(x[0]), value);
+      return F3.termLiteral(F3.sourceLocation(x[0]), value);
     });
   }
 };
@@ -11840,7 +12014,7 @@ var iriFull = {
   name: "iriFull",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const iriToken = CONSUME(terminals_exports.iriRef);
-    return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
+    return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
   },
   gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT("<", ast.value, ">"));
@@ -11853,16 +12027,16 @@ var prefixedName = {
       const longName = CONSUME(terminals_exports.pNameLn);
       return ACTION(() => {
         const [prefix, localName] = longName.image.split(":");
-        return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
+        return C.astFactory.termNamed(C.astFactory.sourceLocation(longName), localName, prefix);
       });
     } },
     { ALT: () => {
       const shortName = CONSUME(terminals_exports.pNameNs);
-      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
     } }
   ]),
-  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT(ast.prefix, ":", ast.value));
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11872,11 +12046,11 @@ var blankNode = {
     const result = OR([
       { ALT: () => {
         const labelToken = CONSUME(terminals_exports.blankNodeLabel);
-        return ACTION(() => C.astFactory.blankNode(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
+        return ACTION(() => C.astFactory.termBlank(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
       } },
       { ALT: () => {
         const anonToken = CONSUME(terminals_exports.anon);
-        return ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocation(anonToken)));
+        return ACTION(() => C.astFactory.termBlank(void 0, C.astFactory.sourceLocation(anonToken)));
       } }
     ]);
     ACTION(() => {
@@ -11886,15 +12060,15 @@ var blankNode = {
     });
     return result;
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { astFactory }) => {
-    astFactory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
+  gImpl: ({ PRINT }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => PRINT("_:", ast.label.replace(/^e_/u, "")));
   }
 };
 var verbA = {
   name: "VerbA",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const token = CONSUME(a);
-    return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
+    return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
   }
 };
 
@@ -11928,10 +12102,10 @@ var baseDecl2 = {
     const val = SUBRULE(iriFull);
     return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("BASE"));
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_ON_EMPTY("BASE "));
     SUBRULE(iri2, ast.value);
-    F3.printFilter(ast, () => PRINT_WORD("\n"));
+    F3.printFilter(ast, () => NEW_LINE());
   }
 };
 var prefixDecl2 = {
@@ -11942,12 +12116,12 @@ var prefixDecl2 = {
     const value = SUBRULE(iriFull);
     return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
   },
-  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORDS("PREFIX", `${ast.key}:`);
+      PRINT_ON_EMPTY("PREFIX ", `${ast.key}: `);
     });
     SUBRULE(iri2, ast.value);
-    F3.printFilter(ast, () => PRINT_WORDS("\n"));
+    F3.printFilter(ast, () => NEW_LINE());
   }
 };
 var verb = {
@@ -11984,10 +12158,10 @@ var var_ = {
       { ALT: () => CONSUME(terminals_exports.var1) },
       { ALT: () => CONSUME(terminals_exports.var2) }
     ]);
-    return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
+    return ACTION(() => C.astFactory.termVariable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
   },
-  gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT(`?${ast.value}`));
   }
 };
 var graphTerm = {
@@ -12000,7 +12174,7 @@ var graphTerm = {
     { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
     { ALT: () => {
       const tokenNil = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
     } }
   ]),
   gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
@@ -12630,13 +12804,16 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
 var triplesBlock = {
   name: "triplesBlock",
   impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE }) => (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(".\n"));
+          F3.printFilter(triple, () => {
+            PRINT_WORD(".");
+            NEW_LINE();
+          });
         } else {
           SUBRULE(graphNodePath, triple.subject);
           F3.printFilter(triple, () => PRINT_WORD(""));
@@ -12648,11 +12825,17 @@ var triplesBlock = {
           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(".\n"));
+            F3.printFilter(ast, () => {
+              PRINT_WORD(".");
+              NEW_LINE();
+            });
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";\n"));
+            F3.printFilter(ast, () => {
+              PRINT_WORD(";");
+              NEW_LINE();
+            });
           }
         }
       });
@@ -12785,10 +12968,10 @@ function collectionImpl(name, allowPaths) {
       return ACTION(() => {
         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);
-        const predNil = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
-        const listHead = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
+        const predFirst = F3.termNamed(F3.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
+        const predRest = F3.termNamed(F3.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
+        const predNil = F3.termNamed(F3.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
+        const listHead = F3.termBlank(void 0, F3.sourceLocationNoMaterialize());
         let iterHead = listHead;
         for (const [index, term] of terms.entries()) {
           const lastInList = index === terms.length - 1;
@@ -12798,7 +12981,7 @@ function collectionImpl(name, allowPaths) {
             const nilTriple = F3.triple(iterHead, predRest, predNil);
             triples.push(nilTriple);
           } else {
-            const tail = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
+            const tail = F3.termBlank(void 0, F3.sourceLocationNoMaterialize());
             const linkTriple = F3.triple(iterHead, predRest, tail);
             triples.push(linkTriple);
             iterHead = tail;
@@ -12838,16 +13021,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       const startToken = CONSUME(symbols_exports.LSquare);
-      const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
+      const blankNode2 = ACTION(() => C.astFactory.termBlank(void 0, C.astFactory.sourceLocationNoMaterialize()));
       const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
       const endToken = CONSUME(symbols_exports.RSquare);
       return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
     },
-    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY, NEW_LINE }) => (ast, c) => {
       const { astFactory: F3, indentInc } = c;
       F3.printFilter(ast, () => {
         c[traqulaIndentation] += indentInc;
-        PRINT("[\n");
+        PRINT("[");
+        NEW_LINE();
       });
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
@@ -12858,7 +13042,10 @@ function blankNodePropertyListImpl(name, allowPaths) {
           }
           F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
-          F3.printFilter(ast, () => PRINT_WORD(";\n"));
+          F3.printFilter(ast, () => {
+            PRINT_WORD(";");
+            NEW_LINE();
+          });
         });
       }
       F3.printFilter(ast, () => {
@@ -12917,18 +13104,19 @@ var groupGraphPattern = {
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
     const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => {
       C[traqulaIndentation] += indentInc;
-      PRINT_WORD("{\n");
+      PRINT_WORD("{");
+      NEW_LINE();
     });
     for (const pattern of ast.patterns) {
       SUBRULE(generatePattern, pattern);
     }
     F3.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -13078,12 +13266,15 @@ var bind2 = {
     const close = CONSUME(symbols_exports.RParen);
     return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (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(")\n"));
+    F3.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
   }
 };
 var inlineData = {
@@ -13091,34 +13282,46 @@ var inlineData = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const values3 = CONSUME(values2);
     const datablock = SUBRULE(dataBlock);
-    return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
+    return ACTION(() => {
+      datablock.loc = C.astFactory.sourceLocation(values3, datablock);
+      return datablock;
+    });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
     const { astFactory: F3, indentInc } = C;
-    const variables = Object.keys(ast.values.at(0) ?? {});
+    const variables = ast.variables;
+    const singleVar = variables.length === 1;
+    F3.printFilter(ast, () => {
+      PRINT_ON_EMPTY("VALUES", singleVar ? "" : "( ");
+    });
+    for (const variable of variables) {
+      F3.printFilter(ast, () => PRINT_WORD(""));
+      SUBRULE(varOrTerm, variable);
+      F3.printFilter(ast, () => PRINT_WORD(""));
+    }
     F3.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORD("VALUES", "(");
-      for (const variable of variables) {
-        PRINT_WORD(`?${variable}`);
-      }
       C[traqulaIndentation] += indentInc;
-      PRINT_WORD(")", "{\n");
+      PRINT_WORD(singleVar ? "" : ")", "{");
+      NEW_LINE();
     });
     for (const mapping of ast.values) {
-      F3.printFilter(ast, () => PRINT_WORD("("));
+      F3.printFilter(ast, () => !singleVar && PRINT_WORD("("));
       for (const variable of variables) {
-        if (mapping[variable] === void 0) {
+        const var_2 = variable.value;
+        if (mapping[var_2] === void 0) {
           F3.printFilter(ast, () => PRINT_WORD("UNDEF"));
         } else {
-          SUBRULE(graphNodePath, mapping[variable]);
+          SUBRULE(graphNodePath, mapping[var_2]);
         }
       }
-      F3.printFilter(ast, () => PRINT_WORD(")\n"));
+      F3.printFilter(ast, () => {
+        PRINT_WORD(singleVar ? "" : ")");
+        NEW_LINE();
+      });
     }
     F3.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -13142,7 +13345,7 @@ var inlineDataOneVar = {
       });
     });
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(varVal, close)));
+    return ACTION(() => C.astFactory.patternValues([varVal], res, C.astFactory.sourceLocation(varVal, close)));
   }
 };
 var inlineDataFull = {
@@ -13159,7 +13362,7 @@ var inlineDataFull = {
           res.push({});
         });
         const close = CONSUME1(symbols_exports.RCurly);
-        return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(nil2, close)));
+        return ACTION(() => C.astFactory.patternValues(vars, res, C.astFactory.sourceLocation(nil2, close)));
       } },
       { ALT: () => {
         const open = CONSUME1(symbols_exports.LParen);
@@ -13191,7 +13394,7 @@ var inlineDataFull = {
           });
         });
         const close = CONSUME2(symbols_exports.RCurly);
-        return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(open, close)));
+        return ACTION(() => C.astFactory.patternValues(vars, res, C.astFactory.sourceLocation(open, close)));
       } }
     ]);
   }
@@ -13254,10 +13457,13 @@ var filter3 = {
     const expression2 = SUBRULE(constraint);
     return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
     SUBRULE(expression, ast.expression);
-    F3.printFilter(ast, () => PRINT_WORD(")\n"));
+    F3.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
   }
 };
 var constraint = {
@@ -13643,8 +13849,7 @@ var groupClause = {
   },
   gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORDS("GROUP", "BY");
+      PRINT_ON_EMPTY("GROUP BY ");
     });
     for (const grouping of ast.groupings) {
       if (F3.isExpression(grouping)) {
@@ -13700,10 +13905,9 @@ var havingClause = {
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
   },
-  gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORD("HAVING");
+      PRINT_ON_EMPTY("HAVING ");
     });
     for (const having2 of ast.having) {
       SUBRULE(expression, having2);
@@ -13729,8 +13933,7 @@ var orderClause = {
   },
   gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORDS("ORDER", "BY");
+      PRINT_ON_EMPTY("ORDER BY ");
     });
     for (const ordering of ast.orderDefs) {
       if (ordering.descending) {
@@ -13789,9 +13992,9 @@ var limitOffsetClauses = {
       return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
     } }
   ]),
-  gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ PRINT_WORDS, NEW_LINE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
+      NEW_LINE();
       if (ast.limit) {
         PRINT_WORDS("LIMIT", String(ast.limit));
       }
@@ -13976,9 +14179,9 @@ var selectClause = {
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORD("SELECT");
+      PRINT_ON_EMPTY("SELECT ");
       if (ast.val.distinct) {
         PRINT_WORD("DISTINCT");
       } else if (ast.val.reduced) {
@@ -13997,7 +14200,9 @@ var selectClause = {
         SUBRULE(var_, variable.variable);
         F3.printFilter(ast, () => PRINT_WORD(")"));
       }
+      F3.printFilter(ast, () => PRINT_WORD(""));
     }
+    F3.printFilter(ast, () => PRINT_WORD(""));
   }
 };
 var constructQuery = {
@@ -14035,18 +14240,19 @@ var constructQuery = {
       } }
     ]);
   },
-  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, PRINT_ON_OWN_LINE, NEW_LINE }) => (ast, C) => {
     const { astFactory: F3, indentInc } = C;
-    F3.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
+    F3.printFilter(ast, () => PRINT_ON_EMPTY("CONSTRUCT "));
     if (!F3.isSourceLocationNoMaterialize(ast.where.loc)) {
       F3.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("{\n");
+        PRINT_WORD("{");
+        NEW_LINE();
       });
       SUBRULE(triplesBlock, ast.template);
       F3.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_OWN_LINE("}");
       });
     }
     SUBRULE(datasetClauseStar, ast.datasets);
@@ -14087,8 +14293,8 @@ var describeQuery = {
       loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_ON_EMPTY("DESCRIBE "));
     if (F3.isWildcard(ast.variables[0])) {
       F3.printFilter(ast, () => PRINT_WORD("*"));
     } else {
@@ -14118,8 +14324,8 @@ var askQuery = {
       loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("ASK"));
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_ON_EMPTY("ASK "));
     SUBRULE(datasetClauseStar, ast.datasets);
     SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
     SUBRULE(solutionModifier, ast.solutionModifiers);
@@ -14178,7 +14384,7 @@ var update = {
       return update2;
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT, NEW_LINE }) => (ast, { astFactory: F3 }) => {
     const [head2, ...tail] = ast.updates;
     if (head2) {
       SUBRULE(prologue, head2.context);
@@ -14187,7 +14393,10 @@ var update = {
       }
     }
     for (const update2 of tail) {
-      F3.printFilter(ast, () => PRINT_WORD(";\n"));
+      F3.printFilter(ast, () => {
+        PRINT(";");
+        NEW_LINE();
+      });
       SUBRULE(prologue, update2.context);
       if (update2.operation) {
         SUBRULE(update1, update2.operation);
@@ -14260,9 +14469,9 @@ var load2 = {
     });
     return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORD("LOAD");
+      PRINT_ON_EMPTY("LOAD ");
       if (ast.silent) {
         PRINT_WORD("SILENT");
       }
@@ -14283,9 +14492,9 @@ function clearOrDrop(operation) {
       const destination = SUBRULE1(graphRefAll);
       return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
-        PRINT_WORD(operation.name.toUpperCase());
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
         if (ast.silent) {
           PRINT_WORD("SILENT");
         }
@@ -14304,9 +14513,9 @@ var create2 = {
     const destination = SUBRULE1(graphRef);
     return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORD("CREATE");
+      PRINT_ON_EMPTY("CREATE ");
       if (ast.silent) {
         PRINT_WORD("SILENT");
       }
@@ -14325,9 +14534,9 @@ function copyMoveAddOperation(operation) {
       const destination = SUBRULE2(graphOrDefault);
       return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
       F3.printFilter(ast, () => {
-        PRINT_WORD(operation.name.toUpperCase());
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
         if (ast.silent) {
           PRINT_WORD("SILENT");
         }
@@ -14376,23 +14585,24 @@ function insertDeleteDelWhere(name, subType, cons1, dataRule) {
       }
       return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, PRINT_ON_OWN_LINE, NEW_LINE }) => (ast, C) => {
       const { astFactory: F3, indentInc } = C;
       F3.printFilter(ast, () => {
-        C[traqulaIndentation] += indentInc;
         if (subType === "insertdata") {
-          PRINT_WORD("INSERT DATA");
+          PRINT_ON_EMPTY("INSERT DATA ");
         } else if (subType === "deletedata") {
-          PRINT_WORD("DELETE DATA");
+          PRINT_ON_EMPTY("DELETE DATA ");
         } else if (subType === "deletewhere") {
-          PRINT_WORD("DELETE WHERE");
+          PRINT_ON_EMPTY("DELETE WHERE ");
         }
-        PRINT_WORD("{\n");
+        C[traqulaIndentation] += indentInc;
+        PRINT_WORD("{");
+        NEW_LINE();
       });
       SUBRULE(quads, F3.wrap(ast.data, ast.loc));
       F3.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_OWN_LINE("}");
       });
     }
   };
@@ -14424,36 +14634,40 @@ var modify = {
     const where2 = SUBRULE1(groupGraphPattern);
     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, PRINT_ON_EMPTY }) => (ast, C) => {
+  gImpl: ({ SUBRULE, PRINT_WORDS, PRINT_ON_EMPTY, NEW_LINE }) => (ast, C) => {
     const { astFactory: F3, indentInc } = C;
     if (ast.graph) {
-      F3.printFilter(ast, () => PRINT_WORD("WITH"));
+      F3.printFilter(ast, () => PRINT_WORDS("WITH"));
       SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
       F3.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("DELETE", "{\n");
+        PRINT_WORDS("DELETE", "{");
+        NEW_LINE();
       });
       SUBRULE(quads, F3.wrap(ast.delete, ast.loc));
       F3.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_EMPTY("}");
+        NEW_LINE();
       });
     }
     if (ast.insert.length > 0) {
       F3.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("INSERT", "{\n");
+        PRINT_WORDS("INSERT", "{");
+        NEW_LINE();
       });
       SUBRULE(quads, F3.wrap(ast.insert, ast.loc));
       F3.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_EMPTY("} ");
+        NEW_LINE();
       });
     }
     SUBRULE(usingClauseStar, ast.from);
-    F3.printFilter(ast, () => PRINT_WORD("WHERE"));
+    F3.printFilter(ast, () => PRINT_WORDS("WHERE"));
     SUBRULE(groupGraphPattern, ast.where);
   }
 };
@@ -14577,18 +14791,19 @@ var quadsNotTriples = {
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
     const { astFactory: F3, indentInc } = C;
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.graph);
     F3.printFilter(ast, () => {
       C[traqulaIndentation] += indentInc;
-      PRINT_WORD("{\n");
+      PRINT_WORD("{");
+      NEW_LINE();
     });
     SUBRULE(triplesBlock, ast.triples);
     F3.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -15019,7 +15234,7 @@ var AstFactory2 = class extends AstFactory {
       type: "tripleCollection",
       subType: "reifiedTriple",
       triples: [this.triple(subject, predicate, object3)],
-      identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
+      identifier: reifier2 ?? this.termBlank(void 0, this.sourceLocationNoMaterialize()),
       loc
     };
   }
@@ -15094,9 +15309,9 @@ var versionDecl = {
     const identifier = SUBRULE(versionSpecifier);
     return ACTION(() => C.astFactory.contextDefinitionVersion(identifier.val, C.astFactory.sourceLocation(versionToken, identifier)));
   },
-  gImpl: ({ PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ PRINT_ON_OWN_LINE }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => {
-      PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`, "\n");
+      PRINT_ON_OWN_LINE("VERSION ", `${grammar_exports.stringEscapedLexical(ast.version)}`);
     });
   }
 };
@@ -15163,7 +15378,7 @@ var reifier = {
       if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.astFactory.wrap(reifier2 ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
+      return C.astFactory.wrap(reifier2 ?? C.astFactory.termBlank(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
     });
   }
 };
@@ -15222,7 +15437,7 @@ function annotationImpl(name, allowPaths) {
               if (!currentReifier && !C.parseMode.has("canCreateBlankNodes")) {
                 throw new Error("Cannot create blanknodes in current parse mode");
               }
-              currentReifier = currentReifier ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation());
+              currentReifier = currentReifier ?? C.astFactory.termBlank(void 0, C.astFactory.sourceLocation());
             });
             const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
             ACTION(() => {
@@ -15257,13 +15472,13 @@ function annotationBlockImpl(name, allowPaths) {
       const close = CONSUME(annotationClose);
       return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(arg, res, C.astFactory.sourceLocation(open, close)));
     },
-    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, C) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
       const { astFactory: F3, indentInc } = C;
       F3.printFilter(ast, () => {
         PRINT_WORD("{|");
         if (ast.triples.length > 1) {
           C[traqulaIndentation] += indentInc;
-          PRINT_WORD("\n");
+          NEW_LINE();
         }
       });
       function printTriple(triple) {
@@ -15273,18 +15488,22 @@ function annotationBlockImpl(name, allowPaths) {
           } else {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           }
+          F3.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath2, triple.object);
         });
       }
       const [head2, ...tail] = ast.triples;
       printTriple(head2);
       for (const triple of tail) {
-        F3.printFilter(ast, () => PRINT_WORD(";\n"));
+        F3.printFilter(ast, () => {
+          PRINT_WORD(";");
+          NEW_LINE();
+        });
         printTriple(triple);
       }
       F3.printFilter(ast, () => {
         if (ast.triples.length > 1) {
-          PRINT_ON_EMPTY("|}\n");
+          PRINT_ON_OWN_LINE("|}");
         } else {
           PRINT_WORD("|}");
         }
@@ -15326,7 +15545,7 @@ var varOrTerm2 = {
     { ALT: () => SUBRULE(grammar_exports.blankNode) },
     { ALT: () => {
       const token = CONSUME(lexer_exports.terminals.nil);
-      return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.NIL));
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), CommonIRIs.NIL));
     } },
     { ALT: () => SUBRULE(tripleTerm) }
   ])
@@ -15352,11 +15571,13 @@ var reifiedTriple = {
     F3.printFilter(ast, () => PRINT_WORD("<<"));
     const triple = ast.triples[0];
     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, [F3.wrap(ast.identifier, ast.identifier.loc)]);
     F3.printFilter(ast, () => PRINT_WORD(">>"));
@@ -15392,7 +15613,9 @@ var tripleTerm = {
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<("));
     SUBRULE(graphNodePath2, ast.subject);
+    F3.printFilter(ast, () => PRINT_WORD(""));
     SUBRULE(graphNodePath2, ast.predicate);
+    F3.printFilter(ast, () => PRINT_WORD(""));
     SUBRULE(graphNodePath2, ast.object);
     F3.printFilter(ast, () => PRINT_WORD(")>>"));
   }
@@ -15422,7 +15645,7 @@ var tripleTermData = {
       { ALT: () => SUBRULE(grammar_exports.iri) },
       { ALT: () => {
         const token = CONSUME(lexer_exports.a);
-        return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE));
+        return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), CommonIRIs.TYPE));
       } }
     ]);
     const object3 = SUBRULE(tripleTermDataObject);
@@ -15509,7 +15732,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR);
         return ACTION(() => {
-          const literal = C.astFactory.literalTerm(C.astFactory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
+          const literal = C.astFactory.termLiteral(C.astFactory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
           langTagHasCorrectRange(literal);
           return literal;
         });
@@ -15517,7 +15740,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
         const iriVal = SUBRULE(grammar_exports.iri);
-        return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   }
@@ -15543,13 +15766,16 @@ var unaryExpression2 = {
 };
 var generateTriplesBlock = {
   name: "triplesBlock",
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, 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(".\n"));
+          F3.printFilter(triple, () => {
+            PRINT_WORD(".");
+            NEW_LINE();
+          });
         } else {
           SUBRULE(graphNodePath2, triple.subject);
           F3.printFilter(ast, () => PRINT_WORD(""));
@@ -15562,11 +15788,17 @@ var generateTriplesBlock = {
           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(".\n"));
+            F3.printFilter(ast, () => {
+              PRINT_WORD(".");
+              NEW_LINE();
+            });
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F3.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F3.printFilter(ast, () => PRINT_WORD(";\n"));
+            F3.printFilter(ast, () => {
+              PRINT_WORD(";");
+              NEW_LINE();
+            });
           }
         }
       });
@@ -15604,8 +15836,9 @@ var sparql12ParserBuilder = ParserBuilder.create(sparql11ParserBuilder).widenCon
 var Parser2 = class {
   parser;
   F = new AstFactory2();
-  constructor() {
+  constructor(args = {}) {
     this.parser = sparql12ParserBuilder.build({
+      ...args,
       queryPreProcessor: sparqlCodepointEscape,
       tokenVocabulary: lexer_exports2.sparql12LexerBuilder.tokenVocabulary
     });