@traqula/generator-sparql-1-1 0.0.19 → 0.0.21

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,34 @@ 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 _TransformerObject {
+  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);
+  clone(newDefaultContext = {}) {
+    return new _TransformerObject({ ...this.defaultContext, ...newDefaultContext });
+  }
+  /**
+   * Function to shallow clone any type.
+   * @param obj
+   * @protected
+   */
+  cloneObj(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 +9788,231 @@ 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.cloneObj(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.cloneObj(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 _TransformerTyped extends TransformerObject {
+  defaultNodePreVisitor;
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext);
+    this.defaultNodePreVisitor = defaultNodePreVisitor;
   }
+  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+    return new _TransformerTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+  }
+  /**
+   * 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 +10033,27 @@ var TransformerType = class {
     recurse(currentNode);
   }
 };
-var TransformerSubType = class extends TransformerType {
+
+// ../../packages/core/lib/TransformerSubTyped.js
+var TransformerSubTyped = class _TransformerSubTyped extends TransformerTyped {
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext, defaultNodePreVisitor);
+  }
+  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+    return new _TransformerSubTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+  }
+  /**
+   * 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 +10063,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 +10077,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 +10114,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) => {
@@ -10925,8 +11135,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");
@@ -11101,7 +11311,7 @@ function TermFactoryMixin(Base) {
     isTerm(x) {
       return this.isOfType(x, "term");
     }
-    blankNode(label, loc) {
+    termBlank(label, loc) {
       const base = {
         type: "term",
         subType: "blankNode",
@@ -11115,7 +11325,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",
@@ -11137,7 +11347,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",
@@ -11148,7 +11358,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",
@@ -11393,7 +11603,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
@@ -11521,8 +11731,7 @@ function findPatternBoundedVars(iter, boundedVars) {
       optional: (op) => ({ next: op.patterns }),
       service: (op) => ({ next: [op.name, ...op.patterns] }),
       bind: (op) => ({ next: [op.variable] }),
-      graph: (op) => ({ next: [op.name, ...op.patterns] }),
-      minus: (op) => ({ next: op.patterns.slice(0, 1) })
+      graph: (op) => ({ next: [op.name, ...op.patterns] })
     },
     term: {
       variable: (op) => {
@@ -11609,17 +11818,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));
@@ -11646,7 +11858,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 = {
@@ -11657,7 +11869,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 = {
@@ -11668,7 +11880,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 = {
@@ -11678,7 +11890,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 = {
@@ -11720,7 +11932,7 @@ var string = {
             return char;
         }
       });
-      return F2.literalTerm(F2.sourceLocation(x[0]), value);
+      return F2.termLiteral(F2.sourceLocation(x[0]), value);
     });
   }
 };
@@ -11736,7 +11948,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, ">"));
@@ -11749,16 +11961,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");
@@ -11768,11 +11980,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(() => {
@@ -11782,15 +11994,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));
   }
 };
 
@@ -11824,10 +12036,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 = {
@@ -11838,12 +12050,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 = {
@@ -11880,10 +12092,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 = {
@@ -11896,7 +12108,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 }) => {
@@ -12526,13 +12738,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(""));
@@ -12544,11 +12759,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();
+            });
           }
         }
       });
@@ -12681,10 +12902,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;
@@ -12694,7 +12915,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;
@@ -12734,16 +12955,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, () => {
@@ -12754,7 +12976,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, () => {
@@ -12813,18 +13038,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("}");
     });
   }
 };
@@ -12974,12 +13200,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 = {
@@ -12987,34 +13216,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("}");
     });
   }
 };
@@ -13038,7 +13279,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 = {
@@ -13055,7 +13296,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);
@@ -13087,7 +13328,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)));
       } }
     ]);
   }
@@ -13150,10 +13391,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 = {
@@ -13539,8 +13783,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)) {
@@ -13596,10 +13839,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);
@@ -13625,8 +13867,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) {
@@ -13685,9 +13926,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));
       }
@@ -13872,9 +14113,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) {
@@ -13893,7 +14134,9 @@ var selectClause = {
         SUBRULE(var_, variable.variable);
         F2.printFilter(ast, () => PRINT_WORD(")"));
       }
+      F2.printFilter(ast, () => PRINT_WORD(""));
     }
+    F2.printFilter(ast, () => PRINT_WORD(""));
   }
 };
 var constructQuery = {
@@ -13931,18 +14174,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);
@@ -13983,8 +14227,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 {
@@ -14014,8 +14258,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);
@@ -14074,7 +14318,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);
@@ -14083,7 +14327,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);
@@ -14156,9 +14403,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");
       }
@@ -14179,9 +14426,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");
         }
@@ -14200,9 +14447,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");
       }
@@ -14221,9 +14468,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");
         }
@@ -14272,23 +14519,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("}");
       });
     }
   };
@@ -14320,36 +14568,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);
   }
 };
@@ -14473,18 +14725,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("}");
     });
   }
 };
@@ -14638,13 +14891,16 @@ var sparql11GeneratorBuilder = GeneratorBuilder.create([
   grammar_exports.filter
 );
 var Generator = class {
+  constructor(defaultContext = {}) {
+    this.defaultContext = defaultContext;
+  }
   generator = sparql11GeneratorBuilder.build();
   factory = new AstFactory();
   generate(ast, context = {}) {
-    return this.generator.queryOrUpdate(ast, completeParseContext(context));
+    return this.generator.queryOrUpdate(ast, completeParseContext({ ...this.defaultContext, ...context })).trim();
   }
   generatePath(ast, context = {}) {
-    return this.generator.path(ast, completeParseContext(context), void 0);
+    return this.generator.path(ast, completeParseContext({ ...this.defaultContext, ...context }), void 0).trim();
   }
 };
 /*! Bundled license information: