@traqula/generator-sparql-1-2 0.0.19 → 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",
@@ -9379,13 +9379,16 @@ var DynamicGenerator = class {
   __context = void 0;
   origSource = "";
   generatedUntil = 0;
-  expectsSpace;
+  toEnsure = [];
+  /**
+   * Should not contain empty strings
+   * @protected
+   */
   stringBuilder = [];
   constructor(rules) {
     this.rules = rules;
     for (const rule of Object.values(rules)) {
       this[rule.name] = ((input, context, args) => {
-        this.expectsSpace = false;
         this.stringBuilder.length = 0;
         this.origSource = context.origSource;
         this.generatedUntil = context?.offset ?? 0;
@@ -9410,12 +9413,15 @@ var DynamicGenerator = class {
     const generate = () => def.gImpl({
       SUBRULE: this.subrule,
       PRINT: this.print,
-      PRINT_SPACE_LEFT: this.printSpaceLeft,
+      ENSURE: this.ensure,
+      ENSURE_EITHER: this.ensureEither,
+      NEW_LINE: this.newLine,
+      HANDLE_LOC: this.handleLoc,
+      CATCHUP: this.catchup,
       PRINT_WORD: this.printWord,
       PRINT_WORDS: this.printWords,
       PRINT_ON_EMPTY: this.printOnEmpty,
-      CATCHUP: this.catchup,
-      HANDLE_LOC: this.handleLoc
+      PRINT_ON_OWN_LINE: this.printOnOwnLine
     })(ast, this.getSafeContext(), ...arg);
     if (this.factory.isLocalized(ast)) {
       this.handleLoc(ast, generate);
@@ -9453,43 +9459,82 @@ var DynamicGenerator = class {
     }
     this.generatedUntil = Math.max(this.generatedUntil, until);
   };
+  handeEnsured(toPrint) {
+    for (const callBack of this.toEnsure) {
+      callBack(toPrint);
+    }
+    this.toEnsure.length = 0;
+  }
   print = (...args) => {
-    const pureArgs = args.filter((x) => x.length > 0);
-    if (pureArgs.length > 0) {
-      const head2 = pureArgs[0];
-      if (this.expectsSpace) {
-        this.expectsSpace = false;
-        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
-        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
-          this.stringBuilder.push(" ");
+    const joined = args.join("");
+    this.handeEnsured(joined);
+    this.stringBuilder.push(joined);
+  };
+  doesEndWith(subsStr) {
+    const len = subsStr.length;
+    let temp = "";
+    while (temp.length < len && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.stringBuilder.push(temp);
+    return temp.endsWith(subsStr);
+  }
+  ensure = (...args) => {
+    const toEnsure = args.join("");
+    if (!this.doesEndWith(toEnsure)) {
+      this.toEnsure.push((willPrint) => {
+        if (!willPrint.startsWith(toEnsure) && !this.doesEndWith(toEnsure)) {
+          this.stringBuilder.push(toEnsure);
         }
-      }
-      const context = this.getSafeContext();
-      if (context[traqulaIndentation] && typeof context[traqulaIndentation] === "number") {
-        const indent = context[traqulaIndentation];
-        for (const str2 of pureArgs) {
-          const [noNl, ...postNl] = str2.split("\n");
-          this.stringBuilder.push(noNl);
-          for (const subStr of postNl.map((line) => line.trimStart())) {
-            this.stringBuilder.push("\n", " ".repeat(indent));
-            if (subStr.length > 0) {
-              this.stringBuilder.push(subStr);
-            }
-          }
+      });
+    }
+  };
+  ensureEither = (...args) => {
+    if (args.length === 1) {
+      this.ensure(...args);
+    } else if (args.length > 1 && // Not already matched?
+    !args.some((subStr) => this.doesEndWith(subStr))) {
+      this.toEnsure.push((willPrint) => {
+        if (!args.some((subStr) => willPrint.startsWith(subStr)) && !args.some((subStr) => this.doesEndWith(subStr))) {
+          this.stringBuilder.push(args[0]);
         }
+      });
+    }
+  };
+  pruneEndingBlanks() {
+    let temp = "";
+    while (/^[ \t]*$/u.test(temp) && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.print(temp.trimEnd());
+  }
+  newLine = (arg) => {
+    const indentation = this.getSafeContext()[traqulaIndentation] ?? 0;
+    if (indentation === -1) {
+      return;
+    }
+    const force = arg?.force ?? false;
+    this.pruneEndingBlanks();
+    if (force) {
+      this.print("\n", " ".repeat(indentation));
+    } else {
+      let temp = "";
+      while (!temp.includes("\n") && this.stringBuilder.length > 0) {
+        temp = this.stringBuilder.pop() + temp;
+      }
+      if (/\n[ \t]*$/u.test(temp)) {
+        temp = temp.replace(/\n[ \t]*$/u, `
+${" ".repeat(indentation)}`);
+        this.print(temp);
       } else {
-        this.stringBuilder.push(...pureArgs);
+        this.print(temp, "\n", " ".repeat(indentation));
       }
     }
   };
   printWord = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-    this.expectsSpace = true;
-  };
-  printSpaceLeft = (...args) => {
-    this.expectsSpace = true;
+    this.ensureEither(" ", "\n");
     this.print(...args);
+    this.ensureEither(" ", "\n");
   };
   printWords = (...args) => {
     for (const arg of args) {
@@ -9497,28 +9542,13 @@ var DynamicGenerator = class {
     }
   };
   printOnEmpty = (...args) => {
-    let counter = this.stringBuilder.length - 1;
-    let onEmpty = true;
-    const isEmptyTest = /^[ \t\n]*$/u;
-    while (counter >= 0 && onEmpty) {
-      const cur = this.stringBuilder[counter];
-      const indexOfNl = cur.lastIndexOf("\n");
-      if (indexOfNl >= 0) {
-        onEmpty = isEmptyTest.test(cur.slice(indexOfNl));
-        if (onEmpty) {
-          const newVal = cur.slice(0, indexOfNl);
-          if (newVal) {
-            this.stringBuilder[counter] = cur.slice(0, indexOfNl);
-          } else {
-            this.stringBuilder.splice(counter, 1);
-          }
-        }
-        break;
-      }
-      onEmpty = isEmptyTest.test(cur);
-      counter--;
-    }
-    this.print("\n", ...args);
+    this.newLine();
+    this.print(...args);
+  };
+  printOnOwnLine = (...args) => {
+    this.newLine();
+    this.print(...args);
+    this.newLine();
   };
 };
 
@@ -9584,6 +9614,9 @@ var GeneratorBuilder = class _GeneratorBuilder {
     delete this.rules[ruleName];
     return this;
   }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
   /**
    * Merge this grammar GeneratorBuilder with another.
    * It is best to merge the bigger grammar with the smaller one.
@@ -9716,21 +9749,31 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../../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.
@@ -9742,90 +9785,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) => {
@@ -9846,11 +10027,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) {
@@ -9860,7 +10054,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;
@@ -9874,12 +10068,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) => {
@@ -9910,10 +10105,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) => {
@@ -10986,8 +11187,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");
@@ -11162,7 +11363,7 @@ function TermFactoryMixin(Base) {
     isTerm(x) {
       return this.isOfType(x, "term");
     }
-    blankNode(label, loc) {
+    termBlank(label, loc) {
       const base = {
         type: "term",
         subType: "blankNode",
@@ -11176,7 +11377,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",
@@ -11198,7 +11399,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",
@@ -11209,7 +11410,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",
@@ -11454,7 +11655,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
@@ -11670,17 +11871,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));
@@ -11707,7 +11911,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 = {
@@ -11718,7 +11922,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 = {
@@ -11729,7 +11933,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 = {
@@ -11739,7 +11943,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 = {
@@ -11781,7 +11985,7 @@ var string = {
             return char;
         }
       });
-      return F3.literalTerm(F3.sourceLocation(x[0]), value);
+      return F3.termLiteral(F3.sourceLocation(x[0]), value);
     });
   }
 };
@@ -11797,7 +12001,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, ">"));
@@ -11810,16 +12014,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");
@@ -11829,11 +12033,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(() => {
@@ -11843,15 +12047,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));
   }
 };
 
@@ -11885,10 +12089,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 = {
@@ -11899,12 +12103,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 = {
@@ -11941,10 +12145,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 = {
@@ -11957,7 +12161,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 }) => {
@@ -12587,13 +12791,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(""));
@@ -12605,11 +12812,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();
+            });
           }
         }
       });
@@ -12742,10 +12955,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;
@@ -12755,7 +12968,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;
@@ -12795,16 +13008,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, () => {
@@ -12815,7 +13029,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, () => {
@@ -12874,18 +13091,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("}");
     });
   }
 };
@@ -13035,12 +13253,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 = {
@@ -13048,34 +13269,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("}");
     });
   }
 };
@@ -13099,7 +13332,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 = {
@@ -13116,7 +13349,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);
@@ -13148,7 +13381,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)));
       } }
     ]);
   }
@@ -13211,10 +13444,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 = {
@@ -13600,8 +13836,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)) {
@@ -13657,10 +13892,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);
@@ -13686,8 +13920,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) {
@@ -13746,9 +13979,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));
       }
@@ -13933,9 +14166,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) {
@@ -13954,7 +14187,9 @@ var selectClause = {
         SUBRULE(var_, variable.variable);
         F3.printFilter(ast, () => PRINT_WORD(")"));
       }
+      F3.printFilter(ast, () => PRINT_WORD(""));
     }
+    F3.printFilter(ast, () => PRINT_WORD(""));
   }
 };
 var constructQuery = {
@@ -13992,18 +14227,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);
@@ -14044,8 +14280,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 {
@@ -14075,8 +14311,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);
@@ -14135,7 +14371,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);
@@ -14144,7 +14380,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);
@@ -14217,9 +14456,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");
       }
@@ -14240,9 +14479,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");
         }
@@ -14261,9 +14500,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");
       }
@@ -14282,9 +14521,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");
         }
@@ -14333,23 +14572,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("}");
       });
     }
   };
@@ -14381,36 +14621,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);
   }
 };
@@ -14534,18 +14778,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("}");
     });
   }
 };
@@ -14725,7 +14970,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
     };
   }
@@ -14800,9 +15045,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)}`);
     });
   }
 };
@@ -14869,7 +15114,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));
     });
   }
 };
@@ -14928,7 +15173,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(() => {
@@ -14963,13 +15208,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) {
@@ -14979,18 +15224,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("|}");
         }
@@ -15032,7 +15281,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) }
   ])
@@ -15058,11 +15307,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(">>"));
@@ -15098,7 +15349,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(")>>"));
   }
@@ -15128,7 +15381,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);
@@ -15215,7 +15468,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;
         });
@@ -15223,7 +15476,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;
   }
@@ -15249,13 +15502,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(""));
@@ -15268,11 +15524,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();
+            });
           }
         }
       });
@@ -15308,13 +15570,16 @@ function completeParseContext2(context) {
 // lib/index.ts
 var sparql12GeneratorBuilder = GeneratorBuilder.create(sparql11GeneratorBuilder).widenContext().typePatch().addRule(grammar_exports2.tripleTerm).addRule(grammar_exports2.reifiedTriple).patchRule(grammar_exports2.graphNodePath).addRule(grammar_exports2.annotationBlockPath).addRule(grammar_exports2.annotationPath).addRule(grammar_exports2.versionDecl).patchRule(grammar_exports2.prologue).patchRule(grammar_exports2.generateTriplesBlock).patchRule(grammar_exports2.generateGraphTerm);
 var Generator = class {
+  constructor(defaultContext = {}) {
+    this.defaultContext = defaultContext;
+  }
   generator = sparql12GeneratorBuilder.build();
   F = new AstFactory2();
   generate(ast, context = {}) {
-    return this.generator.queryOrUpdate(ast, completeParseContext2(context));
+    return this.generator.queryOrUpdate(ast, completeParseContext2({ ...this.defaultContext, ...context })).trim();
   }
   generatePath(ast, context = {}) {
-    return this.generator.path(ast, completeParseContext2(context), void 0);
+    return this.generator.path(ast, completeParseContext2({ ...this.defaultContext, ...context }), void 0).trim();
   }
 };
 /*! Bundled license information: