@traqula/generator-sparql-1-1 0.0.16 → 0.0.18

package/lib/index.cjs

@@ -9718,6 +9718,11 @@ 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;
+  }
   safeObjectVisit(value, mapper) {
     if (value && typeof value === "object") {
       if (Array.isArray(value)) {
@@ -9727,104 +9732,213 @@ var TransformerType = class {
     }
     return value;
   }
-  transformNode(curObject, nodeCallBacks) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type) {
-      continueCheck = nodeCallBacks[casted.type]?.continue;
-      transformation = nodeCallBacks[casted.type]?.transform;
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy3 = { ...curObject };
-    for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy3);
-    }
-    return copy3;
+  /**
+   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
+   * @param startObject object to start iterating from
+   * @param mapper mapper to transform the various objects - argument is a copy of the original
+   * @param preVisitor callback that is evaluated before iterating deeper.
+   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
+   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
+   *    - Default false
+   */
+  transformObject(startObject, mapper, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const copy3 = this.clone(curObject);
+      const context = preVisitor(copy3);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const [key, value] of Object.entries(copy3)) {
+          if (didShortCut) {
+            return copy3;
+          }
+          copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
+      }
+      return mapper(copy3);
+    };
+    return recurse(startObject);
   }
-  visitNode(curObject, nodeCallBacks) {
-    let callback;
-    const casted = curObject;
-    if (casted.type) {
-      callback = nodeCallBacks[casted.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject);
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
+  /**
+   * Visitor that visits all objects. Visits deeper objects first.
+   */
+  visitObject(startObject, visitor, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const context = preVisitor(curObject);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const value of Object.values(curObject)) {
+          if (didShortCut) {
+            return;
+          }
+          this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
       }
-    }
+      visitor(curObject);
+    };
+    recurse(startObject);
+  }
+  transformNode(startObject, nodeCallBacks) {
+    const transformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.transform;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return curObject;
+    };
+    const preTransformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    return this.transformObject(startObject, transformWrapper, preTransformWrapper);
+  }
+  visitNode(startObject, nodeCallBacks) {
+    const visitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.visitor;
+        if (ogFunc) {
+          ogFunc(casted);
+        }
+      }
+    };
+    const preVisitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseNodes(currentNode, traverse) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      const traverser = traverse[curNode.type];
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 var TransformerSubType = class extends TransformerType {
-  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
-  //   for (const value of Object.values(curObject)) {
-  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
-  //   }
-  // }
-  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        continueCheck = specific[casted.subType]?.continue;
-        transformation = specific[casted.subType]?.transform;
-      }
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy3 = { ...curObject };
-    for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy3);
-    }
-    return copy3;
+  transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const transformWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.transform;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.transform;
+        }
+      }
+      return ogTransform ? ogTransform(casted) : curObject;
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
   /**
    * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
    */
-  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let callback;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        callback = specific[casted.subType];
+  visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const visitWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.visitor;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.visitor;
+        }
       }
-    }
-    if (!callback && casted.type) {
-      callback = nodeCallBacks[curObject.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject) ?? true;
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+      if (ogTransform) {
+        ogTransform(casted);
       }
-    }
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      let traverser;
+      const subObj = traverseSubNode[curNode.type];
+      if (subObj) {
+        traverser = subObj[curNode.subType];
+      }
+      if (!traverser) {
+        traverser = traverseNode[curNode.type];
+      }
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 
@@ -10318,6 +10432,44 @@ var graph = createToken2({ name: "Graph", pattern: /graph/i, label: "GRAPH" });
 var graphAll = createToken2({ name: "GraphAll", pattern: /all/i, label: "ALL" });
 var allGraphTokens = LexerBuilder.create().add(named, default_, graph, graphAll);
 
+// ../../packages/rules-sparql-1-1/lib/lexer/lexerPatterns.js
+var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
+var pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
+var varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
+var iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
+var pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
+var pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
+var pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
+var percentPattern = /%[\dA-Fa-f]{2}/;
+var pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
+var plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
+var pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
+var pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
+var blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
+var var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
+var var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
+var langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
+var integerPattern = /\d+/;
+var decimalPattern2 = /\d+\.\d+/;
+var exponentPattern = /[Ee][+-]?\d+/;
+var doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
+var interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
+var decimalPositivePattern = new RegExp(`\\+${decimalPattern2.source}`);
+var doublePositivePattern = new RegExp(`\\+${doublePattern.source}`);
+var integerNegativePattern = new RegExp(`-${integerPattern.source}`);
+var decimalNegativePattern = new RegExp(`-${decimalPattern2.source}`);
+var doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
+var echarPattern = /\\[\\"'bfnrt]/u;
+var stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
+var stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
+var stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
+var stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
+var wsPattern = /[\u0009\u000A\u000D ]/;
+var nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
+var anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
+var commentPattern = /#[^\n]*\n/;
+var atLeastOneBlankPattern = new RegExp(`((${wsPattern.source}+)|(${commentPattern.source}))+`);
+
 // ../../packages/rules-sparql-1-1/lib/lexer/symbols.js
 var symbols_exports = {};
 __export(symbols_exports, {
@@ -10406,40 +10558,6 @@ __export(terminals_exports, {
   var2: () => var2,
   ws: () => ws
 });
-var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
-var pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
-var varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
-var iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
-var pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
-var pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
-var pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
-var percentPattern = /%[\dA-Fa-f]{2}/;
-var pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
-var plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
-var pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
-var pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
-var blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
-var var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
-var var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
-var langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
-var integerPattern = /\d+/;
-var decimalPattern2 = /\d+\.\d+/;
-var exponentPattern = /[Ee][+-]?\d+/;
-var doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
-var interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
-var decimalPositivePattern = new RegExp(`\\+${decimalPattern2.source}`);
-var doublePositivePattern = new RegExp(`\\+${doublePattern.source}`);
-var integerNegativePattern = new RegExp(`-${integerPattern.source}`);
-var decimalNegativePattern = new RegExp(`-${decimalPattern2.source}`);
-var doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
-var echarPattern = /\\[\\"'bfnrt]/u;
-var stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
-var stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
-var stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
-var stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
-var wsPattern = /[\u0009\u000A\u000D ]/;
-var nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
-var anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
 var iriRef = createToken2({ name: "IriRef", pattern: iriRefPattern });
 var pNameLn = createToken2({ name: "PNameLn", pattern: pNameLnPattern });
 var pNameNs = createToken2({ name: "PNameNs", pattern: pNameNsPattern, longer_alt: [pNameLn] });
@@ -10461,7 +10579,7 @@ var stringLiteral2 = createToken2({ name: "StringLiteral2", pattern: stringLiter
 var stringLiteralLong1 = createToken2({ name: "StringLiteralLong1", pattern: stringLiteralLong1Pattern });
 var stringLiteralLong2 = createToken2({ name: "StringLiteralLong2", pattern: stringLiteralLong2Pattern });
 var ws = createToken2({ name: "Ws", pattern: wsPattern, group: Lexer.SKIPPED });
-var comment = createToken2({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.SKIPPED });
+var comment = createToken2({ name: "Comment", pattern: commentPattern, group: Lexer.SKIPPED });
 var nil = createToken2({ name: "Nil", pattern: nilPattern });
 var anon = createToken2({ name: "Anon", pattern: anonPattern });
 var allTerminals = LexerBuilder.create().add(iriRef, pNameNs, pNameLn, blankNodeLabel, var1, var2, langTag, double, decimal, integer, integerPositive, decimalPositive, doublePositive, integerNegative, decimalNegative, doubleNegative, stringLiteralLong1, stringLiteralLong2, stringLiteral1, stringLiteral2, ws, comment, nil, anon);
@@ -10498,9 +10616,23 @@ var to = createToken2({ name: "To", pattern: /to/i, label: "TO" });
 var move = createToken2({ name: "Move", pattern: /move/i, label: "MOVE" });
 var copy = createToken2({ name: "Copy", pattern: /copy/i, label: "COPY" });
 var modifyWith = createToken2({ name: "ModifyWith", pattern: /with/i, label: "WITH" });
+var deleteDataClause = createToken2({
+  name: "DeleteDataClause",
+  pattern: new RegExp(`delete(${atLeastOneBlankPattern.source})data`, "i"),
+  label: "DELETE DATA"
+});
+var deleteWhereClause = createToken2({
+  name: "DeleteWhereClause",
+  pattern: new RegExp(`delete(${atLeastOneBlankPattern.source})where`, "i"),
+  label: "DELETE WHERE"
+});
 var deleteClause = createToken2({ name: "DeleteClause", pattern: /delete/i, label: "DELETE" });
-var insertClause = createToken2({ name: "InsertClause", pattern: /insert/i, label: "INSERT" });
-var dataClause = createToken2({ name: "DataClause", pattern: /data/i, label: "DATA", longer_alt: datatype });
+var insertDataClause = createToken2({
+  name: "InsertDataClause",
+  pattern: new RegExp(`insert(${atLeastOneBlankPattern.source})data`, "i"),
+  label: "INSERT DATA"
+});
+var insertClause = createToken2({ name: "InsertClause", pattern: /insert/i, label: "insert" });
 var usingClause = createToken2({ name: "UsingClause", pattern: /using/i, label: "USING" });
 var optional = createToken2({ name: "Optional", pattern: /optional/i, label: "OPTIONAL" });
 var service = createToken2({ name: "Service", pattern: /service/i, label: "SERVICE" });
@@ -10515,8 +10647,8 @@ var false_ = createToken2({ name: "False", pattern: /false/i, label: "false" });
 var in_ = createToken2({ name: "In", pattern: /in/i, label: "IN" });
 var notIn = createToken2({ name: "NotIn", pattern: /not[\u0020\u0009\u000D\u000A]+in/i, label: "NOT IN" });
 var separator = createToken2({ name: "Separator", pattern: /separator/i, label: "SEPARATOR" });
-var allBaseTokens = LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values2, load, silent, loadInto, clear, drop2, create, add, to, move, copy, modifyWith, deleteClause, insertClause, dataClause, usingClause, optional, service, bind, undef, minus, union, filter2, as, a, true_, false_, in_, notIn, separator);
-var sparql11LexerBuilder = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
+var allBaseTokens = LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values2, load, silent, loadInto, clear, drop2, create, add, to, move, copy, modifyWith, deleteWhereClause, deleteDataClause, deleteClause, insertDataClause, insertClause, usingClause, optional, service, bind, undef, minus, union, filter2, as, a, true_, false_, in_, notIn, separator);
+var sparql11LexerBuilder = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
 
 // ../../packages/rules-sparql-1-1/lib/factoryMixins/ContextFactory.js
 var nodeType = "contextDef";
@@ -11261,12 +11393,12 @@ var CommonIRIs;
   CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
   CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
 })(CommonIRIs || (CommonIRIs = {}));
-var TransformerSparql11 = class extends TransformerSubType {
+var AstTransformer = class extends TransformerSubType {
 };
 
 // ../../packages/rules-sparql-1-1/lib/validation/validators.js
 var F = new AstFactory();
-var transformer = new TransformerSparql11();
+var transformer = new AstTransformer();
 function getAggregatesOfExpression(expression2) {
   if (F.isExpressionAggregate(expression2)) {
     return [expression2];
@@ -11345,77 +11477,69 @@ function queryIsGood(query2) {
     }
   }
 }
+function notUndefined(some2) {
+  return some2 !== void 0;
+}
 function findPatternBoundedVars(iter, boundedVars) {
-  if (F.isQuery(iter) || F.isUpdate(iter)) {
-    if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
-      if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
-        findPatternBoundedVars(iter.where, boundedVars);
-      } else {
-        for (const v of iter.variables) {
-          findPatternBoundedVars(v, boundedVars);
-        }
-      }
-      if (iter.solutionModifiers.group) {
-        const grouping = iter.solutionModifiers.group;
-        for (const g of grouping.groupings) {
-          if ("variable" in g) {
-            findPatternBoundedVars(g.variable, boundedVars);
-          }
-        }
-      }
-      if (iter.values?.values && iter.values.values.length > 0) {
-        const values3 = iter.values.values;
-        for (const v of Object.keys(values3[0])) {
+  transformer.traverseSubNodes(iter, {
+    query: (op) => ({ next: [
+      op.solutionModifiers.group
+    ].filter(notUndefined) }),
+    triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
+    path: (op) => ({ next: op.items }),
+    tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
+  }, {
+    query: {
+      select: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) }),
+      describe: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) })
+    },
+    solutionModifier: {
+      group: (op) => ({
+        next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
+      }),
+      having: (op) => ({ next: op.having }),
+      order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
+    },
+    pattern: {
+      values: (op) => {
+        for (const v of Object.keys(op.values.at(0) ?? {})) {
           boundedVars.add(v);
         }
+        return {};
+      },
+      bgp: (op) => ({ next: op.triples }),
+      group: (op) => ({ next: op.patterns }),
+      union: (op) => ({ next: op.patterns }),
+      optional: (op) => ({ next: op.patterns }),
+      service: (op) => ({ next: [op.name, ...op.patterns] }),
+      bind: (op) => ({ next: [op.variable] }),
+      graph: (op) => ({ next: [op.name, ...op.patterns] }),
+      minus: (op) => ({ next: op.patterns.slice(0, 1) })
+    },
+    term: {
+      variable: (op) => {
+        boundedVars.add(op.value);
+        return {};
       }
     }
-  } else if (F.isTerm(iter)) {
-    if (F.isTermVariable(iter)) {
-      boundedVars.add(iter.value);
-    }
-  } else if (F.isTriple(iter)) {
-    findPatternBoundedVars(iter.subject, boundedVars);
-    findPatternBoundedVars(iter.predicate, boundedVars);
-    findPatternBoundedVars(iter.object, boundedVars);
-  } else if (F.isPath(iter)) {
-    if (!F.isTerm(iter)) {
-      for (const item of iter.items) {
-        findPatternBoundedVars(item, boundedVars);
-      }
-    }
-  } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
-    for (const triple of iter.triples) {
-      findPatternBoundedVars(triple, boundedVars);
-    }
-  } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
-    for (const pattern of iter.patterns) {
-      findPatternBoundedVars(pattern, boundedVars);
-    }
-    if (F.isPatternService(iter)) {
-      findPatternBoundedVars(iter.name, boundedVars);
-    }
-  } else if (F.isPatternBind(iter)) {
-    findPatternBoundedVars(iter.variable, boundedVars);
-  } else if (F.isPatternValues(iter)) {
-    for (const variable of Object.keys(iter.values.at(0) ?? {})) {
-      boundedVars.add(variable);
-    }
-  } else if (F.isPatternGraph(iter)) {
-    findPatternBoundedVars(iter.name, boundedVars);
-    for (const pattern of iter.patterns) {
-      findPatternBoundedVars(pattern, boundedVars);
-    }
-  }
+  });
 }
 function checkNote13(patterns) {
   for (const [index, pattern] of patterns.entries()) {
     if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
       const bgp = patterns[index - 1];
       const variables = [];
-      transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
+      transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
         variables.push(var_2);
-      } } });
+      } } } });
       if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
         throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
       }
@@ -11441,12 +11565,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
     const operation = update2.operation;
     if (operation.subType === "insertdata") {
       const blankNodesHere = /* @__PURE__ */ new Set();
-      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
+      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
         blankNodesHere.add(blankNode2.label);
         if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
           throw new Error("Detected reuse blank node across different INSERT DATA clauses");
         }
-      } } });
+      } } } });
       for (const blankNode2 of blankNodesHere) {
         blankLabelsUsedInInsertData.add(blankNode2);
       }
@@ -14133,12 +14257,11 @@ var quadData = {
     return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
   }
 };
-function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
+function insertDeleteDelWhere(name, subType, cons1, dataRule) {
   return {
     name,
     impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
       const insDelToken = CONSUME(cons1);
-      CONSUME(cons2);
       let couldCreateBlankNodes = true;
       if (name !== "insertData") {
         couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
@@ -14170,9 +14293,9 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
     }
   };
 }
-var insertData = insertDeleteDelWhere("insertData", "insertdata", insertClause, dataClause, quadData);
-var deleteData = insertDeleteDelWhere("deleteData", "deletedata", deleteClause, dataClause, quadData);
-var deleteWhere = insertDeleteDelWhere("deleteWhere", "deletewhere", deleteClause, where, quadPattern);
+var insertData = insertDeleteDelWhere("insertData", "insertdata", insertDataClause, quadData);
+var deleteData = insertDeleteDelWhere("deleteData", "deletedata", deleteDataClause, quadData);
+var deleteWhere = insertDeleteDelWhere("deleteWhere", "deletewhere", deleteWhereClause, quadPattern);
 var modify = {
   name: "modify",
   impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => {

package/lib/index.d.ts

@@ -1,70 +1,70 @@
 import { GeneratorBuilder } from '@traqula/core';
 import type * as T11 from '@traqula/rules-sparql-1-1';
-export declare const sparql11GeneratorBuilder: GeneratorBuilder<T11.SparqlGeneratorContext, "filter" | "graphRef" | "load" | "clear" | "drop" | "create" | "add" | "move" | "copy" | "modify" | "update" | "query" | "datasetClauses" | "bind" | "solutionModifier" | "expression" | "aggregate" | "path" | "blankNode" | "selectQuery" | "selectClause" | "constructQuery" | "describeQuery" | "askQuery" | "update1" | "insertData" | "deleteData" | "deleteWhere" | "graphRefAll" | "quads" | "quadsNotTriples" | "usingClauses" | "argList" | "iriOrFunction" | "prologue" | "baseDecl" | "prefixDecl" | "varOrTerm" | "var" | "graphTerm" | "rdfLiteral" | "iri" | "iriFull" | "prefixedName" | "groupClause" | "havingClause" | "orderClause" | "limitOffsetClauses" | "triplesBlock" | "collectionPath" | "triplesNodePath" | "blankNodePropertyListPath" | "graphNodePath" | "whereClause" | "groupGraphPattern" | "generatePattern" | "graphPatternNotTriples" | "optionalGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "minusGraphPattern" | "groupOrUnionGraphPattern" | "queryOrUpdate", {
-    filter: import("@traqula/core").GeneratorRule<any, "filter"> & T11.SparqlGrammarRule<"filter", T11.PatternFilter, []> & T11.SparqlGeneratorRule<"filter", T11.PatternFilter, []>;
-    graphRef: import("@traqula/core").GeneratorRule<any, "graphRef"> & T11.SparqlGrammarRule<"graphRef", T11.GraphRefSpecific, []> & T11.SparqlGeneratorRule<"graphRef", T11.GraphRefSpecific, []>;
-    load: import("@traqula/core").GeneratorRule<any, "load"> & T11.SparqlGrammarRule<"load", T11.UpdateOperationLoad, []> & T11.SparqlGeneratorRule<"load", T11.UpdateOperationLoad, []>;
-    clear: import("@traqula/core").GeneratorRule<any, "clear"> & T11.SparqlGrammarRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
-    drop: import("@traqula/core").GeneratorRule<any, "drop"> & T11.SparqlGrammarRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
-    create: import("@traqula/core").GeneratorRule<any, "create"> & T11.SparqlGrammarRule<"create", T11.UpdateOperationCreate, []> & T11.SparqlGeneratorRule<"create", T11.UpdateOperationCreate, []>;
-    add: import("@traqula/core").GeneratorRule<any, "add"> & T11.SparqlGrammarRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    move: import("@traqula/core").GeneratorRule<any, "move"> & T11.SparqlGrammarRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    copy: import("@traqula/core").GeneratorRule<any, "copy"> & T11.SparqlGrammarRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    modify: import("@traqula/core").GeneratorRule<any, "modify"> & T11.SparqlGrammarRule<"modify", T11.UpdateOperationModify, []> & T11.SparqlGeneratorRule<"modify", T11.UpdateOperationModify, []>;
-    update: import("@traqula/core").GeneratorRule<any, "update"> & T11.SparqlGrammarRule<"update", T11.Update, []> & T11.SparqlGeneratorRule<"update", T11.Update, []>;
-    query: import("@traqula/core").GeneratorRule<any, "query"> & T11.SparqlGrammarRule<"query", T11.Query, []> & T11.SparqlGeneratorRule<"query", T11.Query, []>;
-    datasetClauses: import("@traqula/core").GeneratorRule<any, "datasetClauses"> & T11.SparqlGrammarRule<"datasetClauses", T11.DatasetClauses, []> & T11.SparqlGeneratorRule<"datasetClauses", T11.DatasetClauses, []>;
-    bind: import("@traqula/core").GeneratorRule<any, "bind"> & T11.SparqlGrammarRule<"bind", T11.PatternBind, []> & T11.SparqlGeneratorRule<"bind", T11.PatternBind, []>;
-    solutionModifier: import("@traqula/core").GeneratorRule<any, "solutionModifier"> & T11.SparqlGrammarRule<"solutionModifier", T11.SolutionModifiers, []> & T11.SparqlGeneratorRule<"solutionModifier", T11.SolutionModifiers, []>;
-    expression: import("@traqula/core").GeneratorRule<any, "expression"> & T11.SparqlGrammarRule<"expression", T11.Expression, []> & T11.SparqlGeneratorRule<"expression", T11.Expression, []>;
-    aggregate: import("@traqula/core").GeneratorRule<T11.SparqlGeneratorContext, "aggregate", T11.ExpressionAggregate, []>;
+export declare const sparql11GeneratorBuilder: GeneratorBuilder<T11.SparqlGeneratorContext, "path" | "queryOrUpdate" | "triplesBlock" | "blankNode" | "collectionPath" | "triplesNodePath" | "blankNodePropertyListPath" | "graphNodePath" | "expression" | "iriOrFunction" | "rdfLiteral" | "var" | "aggregate" | "iri" | "prefixedName" | "argList" | "varOrTerm" | "iriFull" | "graphTerm" | "selectClause" | "whereClause" | "solutionModifier" | "query" | "groupGraphPattern" | "graphPatternNotTriples" | "filter" | "bind" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "groupClause" | "havingClause" | "orderClause" | "limitOffsetClauses" | "prologue" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "baseDecl" | "prefixDecl" | "datasetClauses" | "update1" | "load" | "clear" | "drop" | "add" | "move" | "copy" | "create" | "insertData" | "deleteData" | "deleteWhere" | "modify" | "update" | "graphRef" | "graphRefAll" | "quads" | "quadsNotTriples" | "usingClauses" | "generatePattern", {
     path: import("@traqula/core").GeneratorRule<T11.SparqlGeneratorContext, "path", T11.Path, [boolean | undefined]>;
+    queryOrUpdate: import("@traqula/core").GeneratorRule<any, "queryOrUpdate"> & T11.SparqlGrammarRule<"queryOrUpdate", T11.SparqlQuery, []> & T11.SparqlGeneratorRule<"queryOrUpdate", T11.SparqlQuery, []>;
+    triplesBlock: import("@traqula/core").GeneratorRule<any, "triplesBlock"> & T11.SparqlGrammarRule<"triplesBlock", T11.PatternBgp, []> & T11.SparqlGeneratorRule<"triplesBlock", T11.PatternBgp, []>;
     blankNode: import("@traqula/core").GeneratorRule<any, "blankNode"> & T11.SparqlGrammarRule<"blankNode", T11.TermBlank, []> & T11.SparqlGeneratorRule<"blankNode", T11.TermBlank, []>;
-    selectQuery: import("@traqula/core").GeneratorRule<any, "selectQuery"> & T11.SparqlGrammarRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []>;
+    collectionPath: import("@traqula/core").GeneratorRule<any, "collectionPath"> & T11.SparqlGrammarRule<"collectionPath", T11.TripleCollectionList, []> & T11.SparqlGeneratorRule<"collectionPath", T11.TripleCollectionList, []>;
+    triplesNodePath: import("@traqula/core").GeneratorRule<any, "triplesNodePath"> & T11.SparqlGrammarRule<"triplesNodePath", T11.TripleCollection, []> & T11.SparqlGeneratorRule<"triplesNodePath", T11.TripleCollection, []>;
+    blankNodePropertyListPath: import("@traqula/core").GeneratorRule<any, "blankNodePropertyListPath"> & T11.SparqlGrammarRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []> & T11.SparqlGeneratorRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []>;
+    graphNodePath: import("@traqula/core").GeneratorRule<any, "graphNodePath"> & T11.SparqlGrammarRule<"graphNodePath", T11.Term | T11.TripleCollection, []> & T11.SparqlGeneratorRule<"graphNodePath", T11.Term | T11.TripleCollection, []>;
+    expression: import("@traqula/core").GeneratorRule<any, "expression"> & T11.SparqlGrammarRule<"expression", T11.Expression, []> & T11.SparqlGeneratorRule<"expression", T11.Expression, []>;
+    iriOrFunction: import("@traqula/core").GeneratorRule<any, "iriOrFunction"> & T11.SparqlGrammarRule<"iriOrFunction", T11.TermIri | T11.ExpressionFunctionCall, []> & T11.SparqlGeneratorRule<"iriOrFunction", T11.TermIri | T11.ExpressionFunctionCall, []>;
+    rdfLiteral: import("@traqula/core").GeneratorRule<any, "rdfLiteral"> & T11.SparqlGrammarRule<"rdfLiteral", T11.TermLiteral, []> & T11.SparqlGeneratorRule<"rdfLiteral", T11.TermLiteral, []>;
+    var: import("@traqula/core").GeneratorRule<any, "var"> & T11.SparqlGrammarRule<"var", T11.TermVariable, []> & T11.SparqlGeneratorRule<"var", T11.TermVariable, []>;
+    aggregate: import("@traqula/core").GeneratorRule<T11.SparqlGeneratorContext, "aggregate", T11.ExpressionAggregate, []>;
+    iri: import("@traqula/core").GeneratorRule<any, "iri"> & T11.SparqlGrammarRule<"iri", T11.TermIri, []> & T11.SparqlGeneratorRule<"iri", T11.TermIri, []>;
+    prefixedName: import("@traqula/core").GeneratorRule<any, "prefixedName"> & T11.SparqlGrammarRule<"prefixedName", T11.TermIriPrefixed, []> & T11.SparqlGeneratorRule<"prefixedName", T11.TermIriPrefixed, []>;
+    argList: import("@traqula/core").GeneratorRule<any, "argList"> & T11.SparqlGrammarRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []> & T11.SparqlGeneratorRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []>;
+    varOrTerm: import("@traqula/core").GeneratorRule<any, "varOrTerm"> & T11.SparqlGrammarRule<"varOrTerm", T11.Term, []> & T11.SparqlGeneratorRule<"varOrTerm", T11.Term, []>;
+    iriFull: import("@traqula/core").GeneratorRule<any, "iriFull"> & T11.SparqlGrammarRule<"iriFull", T11.TermIriFull, []> & T11.SparqlGeneratorRule<"iriFull", T11.TermIriFull, []>;
+    graphTerm: import("@traqula/core").GeneratorRule<any, "graphTerm"> & T11.SparqlGrammarRule<"graphTerm", T11.GraphTerm, []> & T11.SparqlGeneratorRule<"graphTerm", T11.GraphTerm, []>;
     selectClause: import("@traqula/core").GeneratorRule<any, "selectClause"> & T11.SparqlGrammarRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "variables" | "distinct" | "reduced">>, []> & T11.SparqlGeneratorRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "variables" | "distinct" | "reduced">>, []>;
+    whereClause: import("@traqula/core").GeneratorRule<any, "whereClause"> & T11.SparqlGrammarRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []> & T11.SparqlGeneratorRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []>;
+    solutionModifier: import("@traqula/core").GeneratorRule<any, "solutionModifier"> & T11.SparqlGrammarRule<"solutionModifier", T11.SolutionModifiers, []> & T11.SparqlGeneratorRule<"solutionModifier", T11.SolutionModifiers, []>;
+    query: import("@traqula/core").GeneratorRule<any, "query"> & T11.SparqlGrammarRule<"query", T11.Query, []> & T11.SparqlGeneratorRule<"query", T11.Query, []>;
+    groupGraphPattern: import("@traqula/core").GeneratorRule<any, "groupGraphPattern"> & T11.SparqlGrammarRule<"groupGraphPattern", T11.PatternGroup, []> & T11.SparqlGeneratorRule<"groupGraphPattern", T11.PatternGroup, []>;
+    graphPatternNotTriples: import("@traqula/core").GeneratorRule<any, "graphPatternNotTriples"> & T11.SparqlGrammarRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternValues | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind, []> & T11.SparqlGeneratorRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternValues | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind, []>;
+    filter: import("@traqula/core").GeneratorRule<any, "filter"> & T11.SparqlGrammarRule<"filter", T11.PatternFilter, []> & T11.SparqlGeneratorRule<"filter", T11.PatternFilter, []>;
+    bind: import("@traqula/core").GeneratorRule<any, "bind"> & T11.SparqlGrammarRule<"bind", T11.PatternBind, []> & T11.SparqlGeneratorRule<"bind", T11.PatternBind, []>;
+    groupOrUnionGraphPattern: import("@traqula/core").GeneratorRule<any, "groupOrUnionGraphPattern"> & T11.SparqlGrammarRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []> & T11.SparqlGeneratorRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []>;
+    optionalGraphPattern: import("@traqula/core").GeneratorRule<any, "optionalGraphPattern"> & T11.SparqlGrammarRule<"optionalGraphPattern", T11.PatternOptional, []> & T11.SparqlGeneratorRule<"optionalGraphPattern", T11.PatternOptional, []>;
+    minusGraphPattern: import("@traqula/core").GeneratorRule<any, "minusGraphPattern"> & T11.SparqlGrammarRule<"minusGraphPattern", T11.PatternMinus, []> & T11.SparqlGeneratorRule<"minusGraphPattern", T11.PatternMinus, []>;
+    graphGraphPattern: import("@traqula/core").GeneratorRule<any, "graphGraphPattern"> & T11.SparqlGrammarRule<"graphGraphPattern", T11.PatternGraph, []> & T11.SparqlGeneratorRule<"graphGraphPattern", T11.PatternGraph, []>;
+    serviceGraphPattern: import("@traqula/core").GeneratorRule<any, "serviceGraphPattern"> & T11.SparqlGrammarRule<"serviceGraphPattern", T11.PatternService, []> & T11.SparqlGeneratorRule<"serviceGraphPattern", T11.PatternService, []>;
+    inlineData: import("@traqula/core").GeneratorRule<any, "inlineData"> & T11.SparqlGrammarRule<"inlineData", T11.PatternValues, []> & T11.SparqlGeneratorRule<"inlineData", T11.PatternValues, []>;
+    groupClause: import("@traqula/core").GeneratorRule<any, "groupClause"> & T11.SparqlGrammarRule<"groupClause", T11.SolutionModifierGroup, []> & T11.SparqlGeneratorRule<"groupClause", T11.SolutionModifierGroup, []>;
+    havingClause: import("@traqula/core").GeneratorRule<any, "havingClause"> & T11.SparqlGrammarRule<"havingClause", T11.SolutionModifierHaving, []> & T11.SparqlGeneratorRule<"havingClause", T11.SolutionModifierHaving, []>;
+    orderClause: import("@traqula/core").GeneratorRule<any, "orderClause"> & T11.SparqlGrammarRule<"orderClause", T11.SolutionModifierOrder, []> & T11.SparqlGeneratorRule<"orderClause", T11.SolutionModifierOrder, []>;
+    limitOffsetClauses: import("@traqula/core").GeneratorRule<any, "limitOffsetClauses"> & T11.SparqlGrammarRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []> & T11.SparqlGeneratorRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []>;
+    prologue: import("@traqula/core").GeneratorRule<any, "prologue"> & T11.SparqlGrammarRule<"prologue", T11.ContextDefinition[], []> & T11.SparqlGeneratorRule<"prologue", T11.ContextDefinition[], []>;
+    selectQuery: import("@traqula/core").GeneratorRule<any, "selectQuery"> & T11.SparqlGrammarRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []>;
     constructQuery: import("@traqula/core").GeneratorRule<any, "constructQuery"> & T11.SparqlGrammarRule<"constructQuery", Omit<T11.QueryConstruct, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"constructQuery", Omit<T11.QueryConstruct, T11.gram.HandledByBase>, []>;
     describeQuery: import("@traqula/core").GeneratorRule<any, "describeQuery"> & T11.SparqlGrammarRule<"describeQuery", Omit<T11.QueryDescribe, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"describeQuery", Omit<T11.QueryDescribe, T11.gram.HandledByBase>, []>;
     askQuery: import("@traqula/core").GeneratorRule<any, "askQuery"> & T11.SparqlGrammarRule<"askQuery", Omit<T11.QueryAsk, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"askQuery", Omit<T11.QueryAsk, T11.gram.HandledByBase>, []>;
+    baseDecl: import("@traqula/core").GeneratorRule<any, "baseDecl"> & T11.SparqlGrammarRule<"baseDecl", T11.ContextDefinitionBase, []> & T11.SparqlGeneratorRule<"baseDecl", T11.ContextDefinitionBase, []>;
+    prefixDecl: import("@traqula/core").GeneratorRule<any, "prefixDecl"> & T11.SparqlGrammarRule<"prefixDecl", T11.ContextDefinitionPrefix, []> & T11.SparqlGeneratorRule<"prefixDecl", T11.ContextDefinitionPrefix, []>;
+    datasetClauses: import("@traqula/core").GeneratorRule<any, "datasetClauses"> & T11.SparqlGrammarRule<"datasetClauses", T11.DatasetClauses, []> & T11.SparqlGeneratorRule<"datasetClauses", T11.DatasetClauses, []>;
     update1: import("@traqula/core").GeneratorRule<any, "update1"> & T11.SparqlGrammarRule<"update1", T11.UpdateOperation, []> & T11.SparqlGeneratorRule<"update1", T11.UpdateOperation, []>;
+    load: import("@traqula/core").GeneratorRule<any, "load"> & T11.SparqlGrammarRule<"load", T11.UpdateOperationLoad, []> & T11.SparqlGeneratorRule<"load", T11.UpdateOperationLoad, []>;
+    clear: import("@traqula/core").GeneratorRule<any, "clear"> & T11.SparqlGrammarRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
+    drop: import("@traqula/core").GeneratorRule<any, "drop"> & T11.SparqlGrammarRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
+    add: import("@traqula/core").GeneratorRule<any, "add"> & T11.SparqlGrammarRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    move: import("@traqula/core").GeneratorRule<any, "move"> & T11.SparqlGrammarRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    copy: import("@traqula/core").GeneratorRule<any, "copy"> & T11.SparqlGrammarRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    create: import("@traqula/core").GeneratorRule<any, "create"> & T11.SparqlGrammarRule<"create", T11.UpdateOperationCreate, []> & T11.SparqlGeneratorRule<"create", T11.UpdateOperationCreate, []>;
     insertData: import("@traqula/core").GeneratorRule<any, "insertData"> & T11.SparqlGrammarRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
     deleteData: import("@traqula/core").GeneratorRule<any, "deleteData"> & T11.SparqlGrammarRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
     deleteWhere: import("@traqula/core").GeneratorRule<any, "deleteWhere"> & T11.SparqlGrammarRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
+    modify: import("@traqula/core").GeneratorRule<any, "modify"> & T11.SparqlGrammarRule<"modify", T11.UpdateOperationModify, []> & T11.SparqlGeneratorRule<"modify", T11.UpdateOperationModify, []>;
+    update: import("@traqula/core").GeneratorRule<any, "update"> & T11.SparqlGrammarRule<"update", T11.Update, []> & T11.SparqlGeneratorRule<"update", T11.Update, []>;
+    graphRef: import("@traqula/core").GeneratorRule<any, "graphRef"> & T11.SparqlGrammarRule<"graphRef", T11.GraphRefSpecific, []> & T11.SparqlGeneratorRule<"graphRef", T11.GraphRefSpecific, []>;
     graphRefAll: import("@traqula/core").GeneratorRule<any, "graphRefAll"> & T11.SparqlGrammarRule<"graphRefAll", T11.GraphRef, []> & T11.SparqlGeneratorRule<"graphRefAll", T11.GraphRef, []>;
     quads: import("@traqula/core").GeneratorRule<any, "quads"> & T11.SparqlGrammarRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, []> & T11.SparqlGeneratorRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, []>;
     quadsNotTriples: import("@traqula/core").GeneratorRule<any, "quadsNotTriples"> & T11.SparqlGrammarRule<"quadsNotTriples", T11.GraphQuads, []> & T11.SparqlGeneratorRule<"quadsNotTriples", T11.GraphQuads, []>;
     usingClauses: import("@traqula/core").GeneratorRule<any, "usingClauses"> & T11.SparqlGrammarRule<"usingClauses", T11.DatasetClauses, []> & T11.SparqlGeneratorRule<"usingClauses", T11.DatasetClauses, []>;
-    argList: import("@traqula/core").GeneratorRule<any, "argList"> & T11.SparqlGrammarRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []> & T11.SparqlGeneratorRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []>;
-    iriOrFunction: import("@traqula/core").GeneratorRule<any, "iriOrFunction"> & T11.SparqlGrammarRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, []> & T11.SparqlGeneratorRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, []>;
-    prologue: import("@traqula/core").GeneratorRule<any, "prologue"> & T11.SparqlGrammarRule<"prologue", T11.ContextDefinition[], []> & T11.SparqlGeneratorRule<"prologue", T11.ContextDefinition[], []>;
-    baseDecl: import("@traqula/core").GeneratorRule<any, "baseDecl"> & T11.SparqlGrammarRule<"baseDecl", T11.ContextDefinitionBase, []> & T11.SparqlGeneratorRule<"baseDecl", T11.ContextDefinitionBase, []>;
-    prefixDecl: import("@traqula/core").GeneratorRule<any, "prefixDecl"> & T11.SparqlGrammarRule<"prefixDecl", T11.ContextDefinitionPrefix, []> & T11.SparqlGeneratorRule<"prefixDecl", T11.ContextDefinitionPrefix, []>;
-    varOrTerm: import("@traqula/core").GeneratorRule<any, "varOrTerm"> & T11.SparqlGrammarRule<"varOrTerm", T11.Term, []> & T11.SparqlGeneratorRule<"varOrTerm", T11.Term, []>;
-    var: import("@traqula/core").GeneratorRule<any, "var"> & T11.SparqlGrammarRule<"var", T11.TermVariable, []> & T11.SparqlGeneratorRule<"var", T11.TermVariable, []>;
-    graphTerm: import("@traqula/core").GeneratorRule<any, "graphTerm"> & T11.SparqlGrammarRule<"graphTerm", T11.GraphTerm, []> & T11.SparqlGeneratorRule<"graphTerm", T11.GraphTerm, []>;
-    rdfLiteral: import("@traqula/core").GeneratorRule<any, "rdfLiteral"> & T11.SparqlGrammarRule<"rdfLiteral", T11.TermLiteral, []> & T11.SparqlGeneratorRule<"rdfLiteral", T11.TermLiteral, []>;
-    iri: import("@traqula/core").GeneratorRule<any, "iri"> & T11.SparqlGrammarRule<"iri", T11.TermIri, []> & T11.SparqlGeneratorRule<"iri", T11.TermIri, []>;
-    iriFull: import("@traqula/core").GeneratorRule<any, "iriFull"> & T11.SparqlGrammarRule<"iriFull", T11.TermIriFull, []> & T11.SparqlGeneratorRule<"iriFull", T11.TermIriFull, []>;
-    prefixedName: import("@traqula/core").GeneratorRule<any, "prefixedName"> & T11.SparqlGrammarRule<"prefixedName", T11.TermIriPrefixed, []> & T11.SparqlGeneratorRule<"prefixedName", T11.TermIriPrefixed, []>;
-    groupClause: import("@traqula/core").GeneratorRule<any, "groupClause"> & T11.SparqlGrammarRule<"groupClause", T11.SolutionModifierGroup, []> & T11.SparqlGeneratorRule<"groupClause", T11.SolutionModifierGroup, []>;
-    havingClause: import("@traqula/core").GeneratorRule<any, "havingClause"> & T11.SparqlGrammarRule<"havingClause", T11.SolutionModifierHaving, []> & T11.SparqlGeneratorRule<"havingClause", T11.SolutionModifierHaving, []>;
-    orderClause: import("@traqula/core").GeneratorRule<any, "orderClause"> & T11.SparqlGrammarRule<"orderClause", T11.SolutionModifierOrder, []> & T11.SparqlGeneratorRule<"orderClause", T11.SolutionModifierOrder, []>;
-    limitOffsetClauses: import("@traqula/core").GeneratorRule<any, "limitOffsetClauses"> & T11.SparqlGrammarRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []> & T11.SparqlGeneratorRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []>;
-    triplesBlock: import("@traqula/core").GeneratorRule<any, "triplesBlock"> & T11.SparqlGrammarRule<"triplesBlock", T11.PatternBgp, []> & T11.SparqlGeneratorRule<"triplesBlock", T11.PatternBgp, []>;
-    collectionPath: import("@traqula/core").GeneratorRule<any, "collectionPath"> & T11.SparqlGrammarRule<"collectionPath", T11.TripleCollectionList, []> & T11.SparqlGeneratorRule<"collectionPath", T11.TripleCollectionList, []>;
-    triplesNodePath: import("@traqula/core").GeneratorRule<any, "triplesNodePath"> & T11.SparqlGrammarRule<"triplesNodePath", T11.TripleCollection, []> & T11.SparqlGeneratorRule<"triplesNodePath", T11.TripleCollection, []>;
-    blankNodePropertyListPath: import("@traqula/core").GeneratorRule<any, "blankNodePropertyListPath"> & T11.SparqlGrammarRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []> & T11.SparqlGeneratorRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []>;
-    graphNodePath: import("@traqula/core").GeneratorRule<any, "graphNodePath"> & T11.SparqlGrammarRule<"graphNodePath", T11.TripleCollection | T11.Term, []> & T11.SparqlGeneratorRule<"graphNodePath", T11.TripleCollection | T11.Term, []>;
-    whereClause: import("@traqula/core").GeneratorRule<any, "whereClause"> & T11.SparqlGrammarRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []> & T11.SparqlGeneratorRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []>;
-    groupGraphPattern: import("@traqula/core").GeneratorRule<any, "groupGraphPattern"> & T11.SparqlGrammarRule<"groupGraphPattern", T11.PatternGroup, []> & T11.SparqlGeneratorRule<"groupGraphPattern", T11.PatternGroup, []>;
     generatePattern: import("@traqula/core").GeneratorRule<any, "generatePattern"> & T11.SparqlGeneratorRule<"generatePattern", T11.Pattern>;
-    graphPatternNotTriples: import("@traqula/core").GeneratorRule<any, "graphPatternNotTriples"> & T11.SparqlGrammarRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, []> & T11.SparqlGeneratorRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, []>;
-    optionalGraphPattern: import("@traqula/core").GeneratorRule<any, "optionalGraphPattern"> & T11.SparqlGrammarRule<"optionalGraphPattern", T11.PatternOptional, []> & T11.SparqlGeneratorRule<"optionalGraphPattern", T11.PatternOptional, []>;
-    graphGraphPattern: import("@traqula/core").GeneratorRule<any, "graphGraphPattern"> & T11.SparqlGrammarRule<"graphGraphPattern", T11.PatternGraph, []> & T11.SparqlGeneratorRule<"graphGraphPattern", T11.PatternGraph, []>;
-    serviceGraphPattern: import("@traqula/core").GeneratorRule<any, "serviceGraphPattern"> & T11.SparqlGrammarRule<"serviceGraphPattern", T11.PatternService, []> & T11.SparqlGeneratorRule<"serviceGraphPattern", T11.PatternService, []>;
-    inlineData: import("@traqula/core").GeneratorRule<any, "inlineData"> & T11.SparqlGrammarRule<"inlineData", T11.PatternValues, []> & T11.SparqlGeneratorRule<"inlineData", T11.PatternValues, []>;
-    minusGraphPattern: import("@traqula/core").GeneratorRule<any, "minusGraphPattern"> & T11.SparqlGrammarRule<"minusGraphPattern", T11.PatternMinus, []> & T11.SparqlGeneratorRule<"minusGraphPattern", T11.PatternMinus, []>;
-    groupOrUnionGraphPattern: import("@traqula/core").GeneratorRule<any, "groupOrUnionGraphPattern"> & T11.SparqlGrammarRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []> & T11.SparqlGeneratorRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []>;
-    queryOrUpdate: import("@traqula/core").GeneratorRule<any, "queryOrUpdate"> & T11.SparqlGrammarRule<"queryOrUpdate", T11.SparqlQuery, []> & T11.SparqlGeneratorRule<"queryOrUpdate", T11.SparqlQuery, []>;
 }>;
 export type SparqlGenerator = ReturnType<typeof sparql11GeneratorBuilder.build>;
 export declare class Generator {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/generator-sparql-1-1",
   "type": "module",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "SPARQL 1.1 generator",
   "lsd:module": true,
   "license": "MIT",
@@ -42,12 +42,12 @@
     "build:transpile": " node \"../../node_modules/esbuild/bin/esbuild\" --format=cjs --bundle --log-level=error --outfile=lib/index.cjs lib/index.ts"
   },
   "dependencies": {
-    "@traqula/core": "^0.0.16",
-    "@traqula/rules-sparql-1-1": "^0.0.16"
+    "@traqula/core": "^0.0.18",
+    "@traqula/rules-sparql-1-1": "^0.0.18"
   },
   "devDependencies": {
-    "@traqula/parser-sparql-1-1": "^0.0.16",
-    "@traqula/test-utils": "^0.0.16"
+    "@traqula/parser-sparql-1-1": "^0.0.18",
+    "@traqula/test-utils": "^0.0.18"
   },
-  "gitHead": "2de4ee608a2337bed63ecc5cf336b1a57c39e45f"
+  "gitHead": "1bb6a7d67631010ee01b325e33ff76f2f7530e02"
 }