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

package/lib/index.cjs

@@ -50,7 +50,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",
@@ -9611,10 +9611,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) {
@@ -9663,6 +9663,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.
@@ -9749,21 +9752,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.
@@ -9775,90 +9788,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) => {
@@ -9879,11 +10030,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) {
@@ -9893,7 +10057,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;
@@ -9907,12 +10071,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) => {
@@ -9943,10 +10108,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) => {
@@ -11019,8 +11190,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");
@@ -11195,7 +11366,7 @@ function TermFactoryMixin(Base) {
     isTerm(x) {
       return this.isOfType(x, "term");
     }
-    blankNode(label, loc) {
+    termBlank(label, loc) {
       const base = {
         type: "term",
         subType: "blankNode",
@@ -11209,7 +11380,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",
@@ -11231,7 +11402,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",
@@ -11242,7 +11413,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",
@@ -11505,7 +11676,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
@@ -11721,17 +11892,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));
@@ -11758,7 +11932,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 = {
@@ -11769,7 +11943,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 = {
@@ -11780,7 +11954,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 = {
@@ -11790,7 +11964,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 = {
@@ -11832,7 +12006,7 @@ var string = {
             return char;
         }
       });
-      return F2.literalTerm(F2.sourceLocation(x[0]), value);
+      return F2.termLiteral(F2.sourceLocation(x[0]), value);
     });
   }
 };
@@ -11848,7 +12022,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: F2 }) => {
     F2.printFilter(ast, () => PRINT("<", ast.value, ">"));
@@ -11861,16 +12035,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => PRINT(ast.prefix, ":", ast.value));
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11880,11 +12054,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(() => {
@@ -11894,15 +12068,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));
   }
 };
 
@@ -11936,10 +12110,10 @@ var baseDecl2 = {
     const val = SUBRULE(iriFull);
     return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("BASE"));
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => PRINT_ON_EMPTY("BASE "));
     SUBRULE(iri2, ast.value);
-    F2.printFilter(ast, () => PRINT_WORD("\n"));
+    F2.printFilter(ast, () => NEW_LINE());
   }
 };
 var prefixDecl2 = {
@@ -11950,12 +12124,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_WORDS("PREFIX", `${ast.key}:`);
+      PRINT_ON_EMPTY("PREFIX ", `${ast.key}: `);
     });
     SUBRULE(iri2, ast.value);
-    F2.printFilter(ast, () => PRINT_WORDS("\n"));
+    F2.printFilter(ast, () => NEW_LINE());
   }
 };
 var verb = {
@@ -11992,10 +12166,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
+  gImpl: ({ PRINT }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => PRINT(`?${ast.value}`));
   }
 };
 var graphTerm = {
@@ -12008,7 +12182,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: F2 }) => {
@@ -12638,13 +12812,16 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
 var triplesBlock = {
   name: "triplesBlock",
   impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     for (const [index, triple] of ast.triples.entries()) {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F2.isTripleCollection(triple)) {
           SUBRULE(graphNodePath, triple);
-          F2.printFilter(triple, () => PRINT_WORD(".\n"));
+          F2.printFilter(triple, () => {
+            PRINT_WORD(".");
+            NEW_LINE();
+          });
         } else {
           SUBRULE(graphNodePath, triple.subject);
           F2.printFilter(triple, () => PRINT_WORD(""));
@@ -12656,11 +12833,17 @@ var triplesBlock = {
           F2.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
           if (nextTriple === void 0 || F2.isTripleCollection(nextTriple) || !F2.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F2.printFilter(ast, () => PRINT_WORD(".\n"));
+            F2.printFilter(ast, () => {
+              PRINT_WORD(".");
+              NEW_LINE();
+            });
           } else if (F2.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
             F2.printFilter(ast, () => PRINT_WORD(","));
           } else {
-            F2.printFilter(ast, () => PRINT_WORD(";\n"));
+            F2.printFilter(ast, () => {
+              PRINT_WORD(";");
+              NEW_LINE();
+            });
           }
         }
       });
@@ -12793,10 +12976,10 @@ function collectionImpl(name, allowPaths) {
       return ACTION(() => {
         const F2 = C.astFactory;
         const triples = [];
-        const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
-        const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
-        const predNil = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
-        const listHead = F2.blankNode(void 0, F2.sourceLocationNoMaterialize());
+        const predFirst = F2.termNamed(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
+        const predRest = F2.termNamed(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
+        const predNil = F2.termNamed(F2.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
+        const listHead = F2.termBlank(void 0, F2.sourceLocationNoMaterialize());
         let iterHead = listHead;
         for (const [index, term] of terms.entries()) {
           const lastInList = index === terms.length - 1;
@@ -12806,7 +12989,7 @@ function collectionImpl(name, allowPaths) {
             const nilTriple = F2.triple(iterHead, predRest, predNil);
             triples.push(nilTriple);
           } else {
-            const tail = F2.blankNode(void 0, F2.sourceLocationNoMaterialize());
+            const tail = F2.termBlank(void 0, F2.sourceLocationNoMaterialize());
             const linkTriple = F2.triple(iterHead, predRest, tail);
             triples.push(linkTriple);
             iterHead = tail;
@@ -12846,16 +13029,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: F2, indentInc } = c;
       F2.printFilter(ast, () => {
         c[traqulaIndentation] += indentInc;
-        PRINT("[\n");
+        PRINT("[");
+        NEW_LINE();
       });
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
@@ -12866,7 +13050,10 @@ function blankNodePropertyListImpl(name, allowPaths) {
           }
           F2.printFilter(triple, () => PRINT_WORD(""));
           SUBRULE(graphNodePath, triple.object);
-          F2.printFilter(ast, () => PRINT_WORD(";\n"));
+          F2.printFilter(ast, () => {
+            PRINT_WORD(";");
+            NEW_LINE();
+          });
         });
       }
       F2.printFilter(ast, () => {
@@ -12925,18 +13112,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: F2, indentInc } = C;
     F2.printFilter(ast, () => {
       C[traqulaIndentation] += indentInc;
-      PRINT_WORD("{\n");
+      PRINT_WORD("{");
+      NEW_LINE();
     });
     for (const pattern of ast.patterns) {
       SUBRULE(generatePattern, pattern);
     }
     F2.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -13086,12 +13274,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("BIND", "("));
     SUBRULE(expression, ast.expression);
     F2.printFilter(ast, () => PRINT_WORD("AS"));
     SUBRULE(var_, ast.variable);
-    F2.printFilter(ast, () => PRINT_WORD(")\n"));
+    F2.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
   }
 };
 var inlineData = {
@@ -13099,34 +13290,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: F2, indentInc } = C;
-    const variables = Object.keys(ast.values.at(0) ?? {});
+    const variables = ast.variables;
+    const singleVar = variables.length === 1;
+    F2.printFilter(ast, () => {
+      PRINT_ON_EMPTY("VALUES", singleVar ? "" : "( ");
+    });
+    for (const variable of variables) {
+      F2.printFilter(ast, () => PRINT_WORD(""));
+      SUBRULE(varOrTerm, variable);
+      F2.printFilter(ast, () => PRINT_WORD(""));
+    }
     F2.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) {
-      F2.printFilter(ast, () => PRINT_WORD("("));
+      F2.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) {
           F2.printFilter(ast, () => PRINT_WORD("UNDEF"));
         } else {
-          SUBRULE(graphNodePath, mapping[variable]);
+          SUBRULE(graphNodePath, mapping[var_2]);
         }
       }
-      F2.printFilter(ast, () => PRINT_WORD(")\n"));
+      F2.printFilter(ast, () => {
+        PRINT_WORD(singleVar ? "" : ")");
+        NEW_LINE();
+      });
     }
     F2.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -13150,7 +13353,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 = {
@@ -13167,7 +13370,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);
@@ -13199,7 +13402,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)));
       } }
     ]);
   }
@@ -13262,10 +13465,13 @@ var filter3 = {
     const expression2 = SUBRULE(constraint);
     return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("FILTER ("));
     SUBRULE(expression, ast.expression);
-    F2.printFilter(ast, () => PRINT_WORD(")\n"));
+    F2.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
   }
 };
 var constraint = {
@@ -13651,8 +13857,7 @@ var groupClause = {
   },
   gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORDS("GROUP", "BY");
+      PRINT_ON_EMPTY("GROUP BY ");
     });
     for (const grouping of ast.groupings) {
       if (F2.isExpression(grouping)) {
@@ -13708,10 +13913,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: F2 }) => {
+  gImpl: ({ PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORD("HAVING");
+      PRINT_ON_EMPTY("HAVING ");
     });
     for (const having2 of ast.having) {
       SUBRULE(expression, having2);
@@ -13737,8 +13941,7 @@ var orderClause = {
   },
   gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
-      PRINT_WORDS("ORDER", "BY");
+      PRINT_ON_EMPTY("ORDER BY ");
     });
     for (const ordering of ast.orderDefs) {
       if (ordering.descending) {
@@ -13797,9 +14000,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: F2 }) => {
+  gImpl: ({ PRINT_WORDS, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_ON_EMPTY("");
+      NEW_LINE();
       if (ast.limit) {
         PRINT_WORDS("LIMIT", String(ast.limit));
       }
@@ -13984,9 +14187,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_WORD("SELECT");
+      PRINT_ON_EMPTY("SELECT ");
       if (ast.val.distinct) {
         PRINT_WORD("DISTINCT");
       } else if (ast.val.reduced) {
@@ -14005,7 +14208,9 @@ var selectClause = {
         SUBRULE(var_, variable.variable);
         F2.printFilter(ast, () => PRINT_WORD(")"));
       }
+      F2.printFilter(ast, () => PRINT_WORD(""));
     }
+    F2.printFilter(ast, () => PRINT_WORD(""));
   }
 };
 var constructQuery = {
@@ -14043,18 +14248,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: F2, indentInc } = C;
-    F2.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
+    F2.printFilter(ast, () => PRINT_ON_EMPTY("CONSTRUCT "));
     if (!F2.isSourceLocationNoMaterialize(ast.where.loc)) {
       F2.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("{\n");
+        PRINT_WORD("{");
+        NEW_LINE();
       });
       SUBRULE(triplesBlock, ast.template);
       F2.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_OWN_LINE("}");
       });
     }
     SUBRULE(datasetClauseStar, ast.datasets);
@@ -14095,8 +14301,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: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => PRINT_ON_EMPTY("DESCRIBE "));
     if (F2.isWildcard(ast.variables[0])) {
       F2.printFilter(ast, () => PRINT_WORD("*"));
     } else {
@@ -14126,8 +14332,8 @@ var askQuery = {
       loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("ASK"));
+  gImpl: ({ SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
+    F2.printFilter(ast, () => PRINT_ON_EMPTY("ASK "));
     SUBRULE(datasetClauseStar, ast.datasets);
     SUBRULE(whereClause, F2.wrap(ast.where, ast.loc));
     SUBRULE(solutionModifier, ast.solutionModifiers);
@@ -14186,7 +14392,7 @@ var update = {
       return update2;
     });
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT, NEW_LINE }) => (ast, { astFactory: F2 }) => {
     const [head2, ...tail] = ast.updates;
     if (head2) {
       SUBRULE(prologue, head2.context);
@@ -14195,7 +14401,10 @@ var update = {
       }
     }
     for (const update2 of tail) {
-      F2.printFilter(ast, () => PRINT_WORD(";\n"));
+      F2.printFilter(ast, () => {
+        PRINT(";");
+        NEW_LINE();
+      });
       SUBRULE(prologue, update2.context);
       if (update2.operation) {
         SUBRULE(update1, update2.operation);
@@ -14268,9 +14477,9 @@ var load2 = {
     });
     return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
   },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_WORD("LOAD");
+      PRINT_ON_EMPTY("LOAD ");
       if (ast.silent) {
         PRINT_WORD("SILENT");
       }
@@ -14291,9 +14500,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: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
       F2.printFilter(ast, () => {
-        PRINT_WORD(operation.name.toUpperCase());
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
         if (ast.silent) {
           PRINT_WORD("SILENT");
         }
@@ -14312,9 +14521,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: F2 }) => {
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_WORD("CREATE");
+      PRINT_ON_EMPTY("CREATE ");
       if (ast.silent) {
         PRINT_WORD("SILENT");
       }
@@ -14333,9 +14542,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: F2 }) => {
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
       F2.printFilter(ast, () => {
-        PRINT_WORD(operation.name.toUpperCase());
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
         if (ast.silent) {
           PRINT_WORD("SILENT");
         }
@@ -14384,23 +14593,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: F2, indentInc } = C;
       F2.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, F2.wrap(ast.data, ast.loc));
       F2.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_OWN_LINE("}");
       });
     }
   };
@@ -14432,36 +14642,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: F2, indentInc } = C;
     if (ast.graph) {
-      F2.printFilter(ast, () => PRINT_WORD("WITH"));
+      F2.printFilter(ast, () => PRINT_WORDS("WITH"));
       SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
       F2.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("DELETE", "{\n");
+        PRINT_WORDS("DELETE", "{");
+        NEW_LINE();
       });
       SUBRULE(quads, F2.wrap(ast.delete, ast.loc));
       F2.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_EMPTY("}");
+        NEW_LINE();
       });
     }
     if (ast.insert.length > 0) {
       F2.printFilter(ast, () => {
         C[traqulaIndentation] += indentInc;
-        PRINT_WORD("INSERT", "{\n");
+        PRINT_WORDS("INSERT", "{");
+        NEW_LINE();
       });
       SUBRULE(quads, F2.wrap(ast.insert, ast.loc));
       F2.printFilter(ast, () => {
         C[traqulaIndentation] -= indentInc;
-        PRINT_ON_EMPTY("}\n");
+        PRINT_ON_EMPTY("} ");
+        NEW_LINE();
       });
     }
     SUBRULE(usingClauseStar, ast.from);
-    F2.printFilter(ast, () => PRINT_WORD("WHERE"));
+    F2.printFilter(ast, () => PRINT_WORDS("WHERE"));
     SUBRULE(groupGraphPattern, ast.where);
   }
 };
@@ -14585,18 +14799,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: F2, indentInc } = C;
     F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
     SUBRULE(varOrTerm, ast.graph);
     F2.printFilter(ast, () => {
       C[traqulaIndentation] += indentInc;
-      PRINT_WORD("{\n");
+      PRINT_WORD("{");
+      NEW_LINE();
     });
     SUBRULE(triplesBlock, ast.triples);
     F2.printFilter(ast, () => {
       C[traqulaIndentation] -= indentInc;
-      PRINT_ON_EMPTY("}\n");
+      PRINT_ON_OWN_LINE("}");
     });
   }
 };
@@ -14936,8 +15151,9 @@ var updateParserBuilder = ParserBuilder.create(updateNoModifyParserBuilder).patc
 // lib/Parser.js
 var sparql11ParserBuilder = ParserBuilder.create(queryUnitParserBuilder).merge(updateParserBuilder, []).addRule(grammar_exports.queryOrUpdate);
 var Parser2 = class extends MinimalSparqlParser {
-  constructor() {
+  constructor(args = {}) {
     const parser = sparql11ParserBuilder.build({
+      ...args,
       tokenVocabulary: lexer_exports.sparql11LexerBuilder.tokenVocabulary,
       queryPreProcessor: sparqlCodepointEscape
     });