@traqula/rules-sparql-1-1-adjust 0.0.15 → 0.0.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/lib/index.cjs +561 -378
  2. package/package.json +4 -4
package/lib/index.cjs CHANGED
@@ -322,8 +322,8 @@ __export(BuiltInCalls_exports, {
322
322
  year: () => year
323
323
  });
324
324
 
325
- // ../core/lib/CoreFactory.js
326
- var CoreFactory = class {
325
+ // ../core/lib/AstCoreFactory.js
326
+ var AstCoreFactory = class {
327
327
  wrap(val, loc) {
328
328
  return { val, loc };
329
329
  }
@@ -9660,6 +9660,15 @@ applyMixins(Parser, [
9660
9660
  PerformanceTracer
9661
9661
  ]);
9662
9662
 
9663
+ // ../core/lib/utils.js
9664
+ function unCapitalize(str2) {
9665
+ return str2.charAt(0).toLowerCase() + str2.slice(1);
9666
+ }
9667
+ function createToken2(config) {
9668
+ return createToken(config);
9669
+ }
9670
+ var traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
9671
+
9663
9672
  // ../core/lib/lexer-builder/LexerBuilder.js
9664
9673
  var LexerBuilder = class _LexerBuilder {
9665
9674
  tokens;
@@ -9757,16 +9766,13 @@ var LexerBuilder = class _LexerBuilder {
9757
9766
  }
9758
9767
  };
9759
9768
 
9760
- // ../core/lib/utils.js
9761
- function unCapitalize(str2) {
9762
- return str2.charAt(0).toLowerCase() + str2.slice(1);
9763
- }
9764
- function createToken2(config) {
9765
- return createToken(config);
9766
- }
9767
-
9768
9769
  // ../core/lib/Transformers.js
9769
9770
  var TransformerType = class {
9771
+ clone(obj) {
9772
+ const newObj = Object.create(Object.getPrototypeOf(obj));
9773
+ Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
9774
+ return newObj;
9775
+ }
9770
9776
  safeObjectVisit(value, mapper) {
9771
9777
  if (value && typeof value === "object") {
9772
9778
  if (Array.isArray(value)) {
@@ -9776,104 +9782,213 @@ var TransformerType = class {
9776
9782
  }
9777
9783
  return value;
9778
9784
  }
9779
- transformNode(curObject, nodeCallBacks) {
9780
- let continueCheck;
9781
- let transformation;
9782
- const casted = curObject;
9783
- if (casted.type) {
9784
- continueCheck = nodeCallBacks[casted.type]?.continue;
9785
- transformation = nodeCallBacks[casted.type]?.transform;
9786
- }
9787
- let shouldContinue = true;
9788
- if (continueCheck) {
9789
- shouldContinue = continueCheck(curObject);
9790
- }
9791
- if (!shouldContinue) {
9792
- return curObject;
9793
- }
9794
- const copy3 = { ...curObject };
9795
- for (const [key, value] of Object.entries(copy3)) {
9796
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
9797
- }
9798
- if (transformation) {
9799
- return transformation(copy3);
9800
- }
9801
- return copy3;
9785
+ /**
9786
+ * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
9787
+ * @param startObject object to start iterating from
9788
+ * @param mapper mapper to transform the various objects - argument is a copy of the original
9789
+ * @param preVisitor callback that is evaluated before iterating deeper.
9790
+ * If continues is false, we do not iterate deeper, current object is still mapped. - default: true
9791
+ * If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
9792
+ * - Default false
9793
+ */
9794
+ transformObject(startObject, mapper, preVisitor = () => ({})) {
9795
+ let didShortCut = false;
9796
+ const recurse = (curObject) => {
9797
+ const copy3 = this.clone(curObject);
9798
+ const context = preVisitor(copy3);
9799
+ didShortCut = context.shortcut ?? false;
9800
+ const continues = context.continue ?? true;
9801
+ if (continues && !didShortCut) {
9802
+ for (const [key, value] of Object.entries(copy3)) {
9803
+ if (didShortCut) {
9804
+ return copy3;
9805
+ }
9806
+ copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
9807
+ }
9808
+ }
9809
+ return mapper(copy3);
9810
+ };
9811
+ return recurse(startObject);
9802
9812
  }
9803
- visitNode(curObject, nodeCallBacks) {
9804
- let callback;
9805
- const casted = curObject;
9806
- if (casted.type) {
9807
- callback = nodeCallBacks[casted.type];
9808
- }
9809
- let shouldIterate = true;
9810
- if (callback) {
9811
- shouldIterate = callback(curObject);
9812
- }
9813
- if (shouldIterate) {
9814
- for (const value of Object.values(curObject)) {
9815
- this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
9813
+ /**
9814
+ * Visitor that visits all objects. Visits deeper objects first.
9815
+ */
9816
+ visitObject(startObject, visitor, preVisitor = () => ({})) {
9817
+ let didShortCut = false;
9818
+ const recurse = (curObject) => {
9819
+ const context = preVisitor(curObject);
9820
+ didShortCut = context.shortcut ?? false;
9821
+ const continues = context.continue ?? true;
9822
+ if (continues && !didShortCut) {
9823
+ for (const value of Object.values(curObject)) {
9824
+ if (didShortCut) {
9825
+ return;
9826
+ }
9827
+ this.safeObjectVisit(value, (obj) => recurse(obj));
9828
+ }
9816
9829
  }
9817
- }
9830
+ visitor(curObject);
9831
+ };
9832
+ recurse(startObject);
9833
+ }
9834
+ transformNode(startObject, nodeCallBacks) {
9835
+ const transformWrapper = (curObject) => {
9836
+ const casted = curObject;
9837
+ if (casted.type) {
9838
+ const ogFunc = nodeCallBacks[casted.type]?.transform;
9839
+ if (ogFunc) {
9840
+ return ogFunc(casted);
9841
+ }
9842
+ }
9843
+ return curObject;
9844
+ };
9845
+ const preTransformWrapper = (curObject) => {
9846
+ const casted = curObject;
9847
+ if (casted.type) {
9848
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9849
+ if (ogFunc) {
9850
+ return ogFunc(casted);
9851
+ }
9852
+ }
9853
+ return {};
9854
+ };
9855
+ return this.transformObject(startObject, transformWrapper, preTransformWrapper);
9856
+ }
9857
+ visitNode(startObject, nodeCallBacks) {
9858
+ const visitWrapper = (curObject) => {
9859
+ const casted = curObject;
9860
+ if (casted.type) {
9861
+ const ogFunc = nodeCallBacks[casted.type]?.visitor;
9862
+ if (ogFunc) {
9863
+ ogFunc(casted);
9864
+ }
9865
+ }
9866
+ };
9867
+ const preVisitWrapper = (curObject) => {
9868
+ const casted = curObject;
9869
+ if (casted.type) {
9870
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9871
+ if (ogFunc) {
9872
+ return ogFunc(casted);
9873
+ }
9874
+ }
9875
+ return {};
9876
+ };
9877
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9878
+ }
9879
+ traverseNodes(currentNode, traverse) {
9880
+ let didShortCut = false;
9881
+ const recurse = (curNode) => {
9882
+ const traverser = traverse[curNode.type];
9883
+ if (traverser) {
9884
+ const { next, shortcut } = traverser(curNode);
9885
+ didShortCut = shortcut ?? false;
9886
+ if (!didShortCut) {
9887
+ for (const node of next ?? []) {
9888
+ if (didShortCut) {
9889
+ return;
9890
+ }
9891
+ recurse(node);
9892
+ }
9893
+ }
9894
+ }
9895
+ };
9896
+ recurse(currentNode);
9818
9897
  }
9819
9898
  };
9820
9899
  var TransformerSubType = class extends TransformerType {
9821
- // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
9822
- // for (const value of Object.values(curObject)) {
9823
- // this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
9824
- // }
9825
- // }
9826
- transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9827
- let continueCheck;
9828
- let transformation;
9829
- const casted = curObject;
9830
- if (casted.type && casted.subType) {
9831
- const specific = nodeSpecificCallBacks[casted.type];
9832
- if (specific) {
9833
- continueCheck = specific[casted.subType]?.continue;
9834
- transformation = specific[casted.subType]?.transform;
9835
- }
9836
- }
9837
- let shouldContinue = true;
9838
- if (continueCheck) {
9839
- shouldContinue = continueCheck(curObject);
9840
- }
9841
- if (!shouldContinue) {
9842
- return curObject;
9843
- }
9844
- const copy3 = { ...curObject };
9845
- for (const [key, value] of Object.entries(copy3)) {
9846
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9847
- }
9848
- if (transformation) {
9849
- return transformation(copy3);
9850
- }
9851
- return copy3;
9900
+ transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9901
+ const transformWrapper = (curObject) => {
9902
+ let ogTransform;
9903
+ const casted = curObject;
9904
+ if (casted.type && casted.subType) {
9905
+ const specific = nodeSpecificCallBacks[casted.type];
9906
+ if (specific) {
9907
+ ogTransform = specific[casted.subType]?.transform;
9908
+ }
9909
+ if (!ogTransform) {
9910
+ ogTransform = nodeCallBacks[casted.type]?.transform;
9911
+ }
9912
+ }
9913
+ return ogTransform ? ogTransform(casted) : curObject;
9914
+ };
9915
+ const preVisitWrapper = (curObject) => {
9916
+ let ogPreVisit;
9917
+ const casted = curObject;
9918
+ if (casted.type && casted.subType) {
9919
+ const specific = nodeSpecificCallBacks[casted.type];
9920
+ if (specific) {
9921
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9922
+ }
9923
+ if (!ogPreVisit) {
9924
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9925
+ }
9926
+ }
9927
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9928
+ };
9929
+ return this.transformObject(startObject, transformWrapper, preVisitWrapper);
9852
9930
  }
9853
9931
  /**
9854
9932
  * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
9855
9933
  */
9856
- visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9857
- let callback;
9858
- const casted = curObject;
9859
- if (casted.type && casted.subType) {
9860
- const specific = nodeSpecificCallBacks[casted.type];
9861
- if (specific) {
9862
- callback = specific[casted.subType];
9934
+ visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9935
+ const visitWrapper = (curObject) => {
9936
+ let ogTransform;
9937
+ const casted = curObject;
9938
+ if (casted.type && casted.subType) {
9939
+ const specific = nodeSpecificCallBacks[casted.type];
9940
+ if (specific) {
9941
+ ogTransform = specific[casted.subType]?.visitor;
9942
+ }
9943
+ if (!ogTransform) {
9944
+ ogTransform = nodeCallBacks[casted.type]?.visitor;
9945
+ }
9863
9946
  }
9864
- }
9865
- if (!callback && casted.type) {
9866
- callback = nodeCallBacks[curObject.type];
9867
- }
9868
- let shouldIterate = true;
9869
- if (callback) {
9870
- shouldIterate = callback(curObject) ?? true;
9871
- }
9872
- if (shouldIterate) {
9873
- for (const value of Object.values(curObject)) {
9874
- this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9947
+ if (ogTransform) {
9948
+ ogTransform(casted);
9875
9949
  }
9876
- }
9950
+ };
9951
+ const preVisitWrapper = (curObject) => {
9952
+ let ogPreVisit;
9953
+ const casted = curObject;
9954
+ if (casted.type && casted.subType) {
9955
+ const specific = nodeSpecificCallBacks[casted.type];
9956
+ if (specific) {
9957
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9958
+ }
9959
+ if (!ogPreVisit) {
9960
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9961
+ }
9962
+ }
9963
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9964
+ };
9965
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9966
+ }
9967
+ traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
9968
+ let didShortCut = false;
9969
+ const recurse = (curNode) => {
9970
+ let traverser;
9971
+ const subObj = traverseSubNode[curNode.type];
9972
+ if (subObj) {
9973
+ traverser = subObj[curNode.subType];
9974
+ }
9975
+ if (!traverser) {
9976
+ traverser = traverseNode[curNode.type];
9977
+ }
9978
+ if (traverser) {
9979
+ const { next, shortcut } = traverser(curNode);
9980
+ didShortCut = shortcut ?? false;
9981
+ if (!didShortCut) {
9982
+ for (const node of next ?? []) {
9983
+ if (didShortCut) {
9984
+ return;
9985
+ }
9986
+ recurse(node);
9987
+ }
9988
+ }
9989
+ }
9990
+ };
9991
+ recurse(currentNode);
9877
9992
  }
9878
9993
  };
9879
9994
 
@@ -10924,8 +11039,8 @@ function UpdateOperationFactoryMixin(Base) {
10924
11039
  };
10925
11040
  }
10926
11041
 
10927
- // ../rules-sparql-1-1/lib/factory.js
10928
- var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
11042
+ // ../rules-sparql-1-1/lib/astFactory.js
11043
+ var AstFactory = class extends asArg(AstCoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
10929
11044
  alwaysSparql11(obj) {
10930
11045
  return true;
10931
11046
  }
@@ -11022,12 +11137,12 @@ var CommonIRIs;
11022
11137
  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
11023
11138
  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
11024
11139
  })(CommonIRIs || (CommonIRIs = {}));
11025
- var TransformerSparql11 = class extends TransformerSubType {
11140
+ var AstTransformer = class extends TransformerSubType {
11026
11141
  };
11027
11142
 
11028
11143
  // ../rules-sparql-1-1/lib/validation/validators.js
11029
- var F = new Factory();
11030
- var transformer = new TransformerSparql11();
11144
+ var F = new AstFactory();
11145
+ var transformer = new AstTransformer();
11031
11146
  function getAggregatesOfExpression(expression2) {
11032
11147
  if (F.isExpressionAggregate(expression2)) {
11033
11148
  return [expression2];
@@ -11106,77 +11221,69 @@ function queryIsGood(query2) {
11106
11221
  }
11107
11222
  }
11108
11223
  }
11224
+ function notUndefined(some2) {
11225
+ return some2 !== void 0;
11226
+ }
11109
11227
  function findPatternBoundedVars(iter, boundedVars) {
11110
- if (F.isQuery(iter) || F.isUpdate(iter)) {
11111
- if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
11112
- if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
11113
- findPatternBoundedVars(iter.where, boundedVars);
11114
- } else {
11115
- for (const v of iter.variables) {
11116
- findPatternBoundedVars(v, boundedVars);
11117
- }
11118
- }
11119
- if (iter.solutionModifiers.group) {
11120
- const grouping = iter.solutionModifiers.group;
11121
- for (const g of grouping.groupings) {
11122
- if ("variable" in g) {
11123
- findPatternBoundedVars(g.variable, boundedVars);
11124
- }
11125
- }
11126
- }
11127
- if (iter.values?.values && iter.values.values.length > 0) {
11128
- const values3 = iter.values.values;
11129
- for (const v of Object.keys(values3[0])) {
11228
+ transformer.traverseSubNodes(iter, {
11229
+ query: (op) => ({ next: [
11230
+ op.solutionModifiers.group
11231
+ ].filter(notUndefined) }),
11232
+ triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
11233
+ path: (op) => ({ next: op.items }),
11234
+ tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
11235
+ }, {
11236
+ query: {
11237
+ select: (op) => ({ next: [
11238
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11239
+ op.solutionModifiers.group,
11240
+ op.values
11241
+ ].filter(notUndefined) }),
11242
+ describe: (op) => ({ next: [
11243
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11244
+ op.solutionModifiers.group,
11245
+ op.values
11246
+ ].filter(notUndefined) })
11247
+ },
11248
+ solutionModifier: {
11249
+ group: (op) => ({
11250
+ next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
11251
+ }),
11252
+ having: (op) => ({ next: op.having }),
11253
+ order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
11254
+ },
11255
+ pattern: {
11256
+ values: (op) => {
11257
+ for (const v of Object.keys(op.values.at(0) ?? {})) {
11130
11258
  boundedVars.add(v);
11131
11259
  }
11260
+ return {};
11261
+ },
11262
+ bgp: (op) => ({ next: op.triples }),
11263
+ group: (op) => ({ next: op.patterns }),
11264
+ union: (op) => ({ next: op.patterns }),
11265
+ optional: (op) => ({ next: op.patterns }),
11266
+ service: (op) => ({ next: [op.name, ...op.patterns] }),
11267
+ bind: (op) => ({ next: [op.variable] }),
11268
+ graph: (op) => ({ next: [op.name, ...op.patterns] }),
11269
+ minus: (op) => ({ next: op.patterns.slice(0, 1) })
11270
+ },
11271
+ term: {
11272
+ variable: (op) => {
11273
+ boundedVars.add(op.value);
11274
+ return {};
11132
11275
  }
11133
11276
  }
11134
- } else if (F.isTerm(iter)) {
11135
- if (F.isTermVariable(iter)) {
11136
- boundedVars.add(iter.value);
11137
- }
11138
- } else if (F.isTriple(iter)) {
11139
- findPatternBoundedVars(iter.subject, boundedVars);
11140
- findPatternBoundedVars(iter.predicate, boundedVars);
11141
- findPatternBoundedVars(iter.object, boundedVars);
11142
- } else if (F.isPath(iter)) {
11143
- if (!F.isTerm(iter)) {
11144
- for (const item of iter.items) {
11145
- findPatternBoundedVars(item, boundedVars);
11146
- }
11147
- }
11148
- } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
11149
- for (const triple of iter.triples) {
11150
- findPatternBoundedVars(triple, boundedVars);
11151
- }
11152
- } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
11153
- for (const pattern of iter.patterns) {
11154
- findPatternBoundedVars(pattern, boundedVars);
11155
- }
11156
- if (F.isPatternService(iter)) {
11157
- findPatternBoundedVars(iter.name, boundedVars);
11158
- }
11159
- } else if (F.isPatternBind(iter)) {
11160
- findPatternBoundedVars(iter.variable, boundedVars);
11161
- } else if (F.isPatternValues(iter)) {
11162
- for (const variable of Object.keys(iter.values.at(0) ?? {})) {
11163
- boundedVars.add(variable);
11164
- }
11165
- } else if (F.isPatternGraph(iter)) {
11166
- findPatternBoundedVars(iter.name, boundedVars);
11167
- for (const pattern of iter.patterns) {
11168
- findPatternBoundedVars(pattern, boundedVars);
11169
- }
11170
- }
11277
+ });
11171
11278
  }
11172
11279
  function checkNote13(patterns) {
11173
11280
  for (const [index, pattern] of patterns.entries()) {
11174
11281
  if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
11175
11282
  const bgp = patterns[index - 1];
11176
11283
  const variables = [];
11177
- transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
11284
+ transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
11178
11285
  variables.push(var_2);
11179
- } } });
11286
+ } } } });
11180
11287
  if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
11181
11288
  throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
11182
11289
  }
@@ -11202,12 +11309,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
11202
11309
  const operation = update2.operation;
11203
11310
  if (operation.subType === "insertdata") {
11204
11311
  const blankNodesHere = /* @__PURE__ */ new Set();
11205
- transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
11312
+ transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
11206
11313
  blankNodesHere.add(blankNode2.label);
11207
11314
  if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
11208
11315
  throw new Error("Detected reuse blank node across different INSERT DATA clauses");
11209
11316
  }
11210
- } } });
11317
+ } } } });
11211
11318
  for (const blankNode2 of blankNodesHere) {
11212
11319
  blankLabelsUsedInInsertData.add(blankNode2);
11213
11320
  }
@@ -11246,22 +11353,22 @@ var rdfLiteral = {
11246
11353
  return OPTION(() => OR([
11247
11354
  { ALT: () => {
11248
11355
  const lang2 = CONSUME(terminals_exports.langTag);
11249
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11356
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11250
11357
  } },
11251
11358
  { ALT: () => {
11252
11359
  CONSUME(symbols_exports.hathat);
11253
11360
  const iriVal = SUBRULE1(iri2);
11254
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
11361
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
11255
11362
  } }
11256
11363
  ])) ?? value;
11257
11364
  },
11258
- gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { factory }) => {
11259
- factory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11365
+ gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { astFactory }) => {
11366
+ astFactory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11260
11367
  if (ast.langOrIri) {
11261
11368
  if (typeof ast.langOrIri === "string") {
11262
- factory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11369
+ astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11263
11370
  } else {
11264
- factory.printFilter(ast, () => PRINT("^^"));
11371
+ astFactory.printFilter(ast, () => PRINT("^^"));
11265
11372
  SUBRULE(iri2, ast.langOrIri);
11266
11373
  }
11267
11374
  }
@@ -11283,7 +11390,7 @@ var numericLiteralUnsigned = {
11283
11390
  { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
11284
11391
  { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
11285
11392
  ]);
11286
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11393
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11287
11394
  }
11288
11395
  };
11289
11396
  var numericLiteralPositive = {
@@ -11294,7 +11401,7 @@ var numericLiteralPositive = {
11294
11401
  { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
11295
11402
  { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
11296
11403
  ]);
11297
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11404
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11298
11405
  }
11299
11406
  };
11300
11407
  var numericLiteralNegative = {
@@ -11305,7 +11412,7 @@ var numericLiteralNegative = {
11305
11412
  { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
11306
11413
  { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
11307
11414
  ]);
11308
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11415
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11309
11416
  }
11310
11417
  };
11311
11418
  var booleanLiteral = {
@@ -11315,7 +11422,7 @@ var booleanLiteral = {
11315
11422
  { ALT: () => CONSUME(true_) },
11316
11423
  { ALT: () => CONSUME(false_) }
11317
11424
  ]);
11318
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(token), token.image.toLowerCase(), C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11425
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11319
11426
  }
11320
11427
  };
11321
11428
  var string = {
@@ -11340,7 +11447,7 @@ var string = {
11340
11447
  } }
11341
11448
  ]);
11342
11449
  return ACTION(() => {
11343
- const F2 = C.factory;
11450
+ const F2 = C.astFactory;
11344
11451
  const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
11345
11452
  switch (char) {
11346
11453
  case "t":
@@ -11367,16 +11474,16 @@ var iri2 = {
11367
11474
  { ALT: () => SUBRULE(iriFull) },
11368
11475
  { ALT: () => SUBRULE(prefixedName) }
11369
11476
  ]),
11370
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => F2.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11477
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => F2.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11371
11478
  };
11372
11479
  var iriFull = {
11373
11480
  name: "iriFull",
11374
11481
  impl: ({ ACTION, CONSUME }) => (C) => {
11375
11482
  const iriToken = CONSUME(terminals_exports.iriRef);
11376
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11483
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11377
11484
  },
11378
- gImpl: ({ PRINT }) => (ast, { factory }) => {
11379
- factory.printFilter(ast, () => PRINT("<", ast.value, ">"));
11485
+ gImpl: ({ PRINT }) => (ast, { astFactory: F2 }) => {
11486
+ F2.printFilter(ast, () => PRINT("<", ast.value, ">"));
11380
11487
  }
11381
11488
  };
11382
11489
  var prefixedName = {
@@ -11386,16 +11493,16 @@ var prefixedName = {
11386
11493
  const longName = CONSUME(terminals_exports.pNameLn);
11387
11494
  return ACTION(() => {
11388
11495
  const [prefix, localName] = longName.image.split(":");
11389
- return C.factory.namedNode(C.factory.sourceLocation(longName), localName, prefix);
11496
+ return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
11390
11497
  });
11391
11498
  } },
11392
11499
  { ALT: () => {
11393
11500
  const shortName = CONSUME(terminals_exports.pNameNs);
11394
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11501
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11395
11502
  } }
11396
11503
  ]),
11397
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11398
- factory.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11504
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11505
+ F2.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11399
11506
  }
11400
11507
  };
11401
11508
  var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11405,11 +11512,11 @@ var blankNode = {
11405
11512
  const result = OR([
11406
11513
  { ALT: () => {
11407
11514
  const labelToken = CONSUME(terminals_exports.blankNodeLabel);
11408
- return ACTION(() => C.factory.blankNode(labelToken.image.slice(2), C.factory.sourceLocation(labelToken)));
11515
+ return ACTION(() => C.astFactory.blankNode(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
11409
11516
  } },
11410
11517
  { ALT: () => {
11411
11518
  const anonToken = CONSUME(terminals_exports.anon);
11412
- return ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocation(anonToken)));
11519
+ return ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocation(anonToken)));
11413
11520
  } }
11414
11521
  ]);
11415
11522
  ACTION(() => {
@@ -11419,15 +11526,15 @@ var blankNode = {
11419
11526
  });
11420
11527
  return result;
11421
11528
  },
11422
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11423
- factory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11529
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory }) => {
11530
+ astFactory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11424
11531
  }
11425
11532
  };
11426
11533
  var verbA = {
11427
11534
  name: "VerbA",
11428
11535
  impl: ({ ACTION, CONSUME }) => (C) => {
11429
11536
  const token = CONSUME(a);
11430
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11537
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11431
11538
  }
11432
11539
  };
11433
11540
 
@@ -11444,7 +11551,7 @@ var prologue = {
11444
11551
  ]));
11445
11552
  return result;
11446
11553
  },
11447
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11554
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11448
11555
  for (const context of ast) {
11449
11556
  if (F2.isContextDefinitionBase(context)) {
11450
11557
  SUBRULE(baseDecl2, context);
@@ -11459,11 +11566,12 @@ var baseDecl2 = {
11459
11566
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
11460
11567
  const base = CONSUME(baseDecl);
11461
11568
  const val = SUBRULE(iriFull);
11462
- return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
11569
+ return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
11463
11570
  },
11464
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
11571
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11465
11572
  F2.printFilter(ast, () => PRINT_WORD("BASE"));
11466
11573
  SUBRULE(iri2, ast.value);
11574
+ F2.printFilter(ast, () => PRINT_WORD("\n"));
11467
11575
  }
11468
11576
  };
11469
11577
  var prefixDecl2 = {
@@ -11472,13 +11580,14 @@ var prefixDecl2 = {
11472
11580
  const prefix = CONSUME(prefixDecl);
11473
11581
  const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
11474
11582
  const value = SUBRULE(iriFull);
11475
- return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
11583
+ return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
11476
11584
  },
11477
- gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F2 }) => {
11585
+ gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F2 }) => {
11478
11586
  F2.printFilter(ast, () => {
11479
11587
  PRINT_WORDS("PREFIX", `${ast.key}:`);
11480
11588
  });
11481
11589
  SUBRULE(iri2, ast.value);
11590
+ F2.printFilter(ast, () => PRINT_WORDS("\n"));
11482
11591
  }
11483
11592
  };
11484
11593
  var verb = {
@@ -11494,7 +11603,7 @@ var varOrTerm = {
11494
11603
  { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
11495
11604
  { ALT: () => SUBRULE(graphTerm) }
11496
11605
  ]),
11497
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11606
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11498
11607
  if (F2.isTermVariable(ast)) {
11499
11608
  return SUBRULE(var_, ast);
11500
11609
  }
@@ -11515,9 +11624,9 @@ var var_ = {
11515
11624
  { ALT: () => CONSUME(terminals_exports.var1) },
11516
11625
  { ALT: () => CONSUME(terminals_exports.var2) }
11517
11626
  ]);
11518
- return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
11627
+ return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
11519
11628
  },
11520
- gImpl: ({ PRINT_WORD }) => (ast, { factory: F2 }) => {
11629
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11521
11630
  F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
11522
11631
  }
11523
11632
  };
@@ -11531,10 +11640,10 @@ var graphTerm = {
11531
11640
  { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
11532
11641
  { ALT: () => {
11533
11642
  const tokenNil = CONSUME(terminals_exports.nil);
11534
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
11643
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
11535
11644
  } }
11536
11645
  ]),
11537
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11646
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11538
11647
  if (F2.isTermNamed(ast)) {
11539
11648
  SUBRULE(iri2, ast);
11540
11649
  } else if (F2.isTermLiteral(ast)) {
@@ -11554,14 +11663,14 @@ function datasetClauseUsing(name, token) {
11554
11663
  return OR([
11555
11664
  { ALT: () => {
11556
11665
  const iri3 = SUBRULE(defaultGraphClause);
11557
- return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
11666
+ return ACTION(() => C.astFactory.wrap({ clauseType: "default", value: iri3 }, C.astFactory.sourceLocation(start, iri3)));
11558
11667
  } },
11559
11668
  { ALT: () => {
11560
11669
  const namedClause = SUBRULE(namedGraphClause);
11561
- return ACTION(() => C.factory.wrap({
11670
+ return ACTION(() => C.astFactory.wrap({
11562
11671
  clauseType: "named",
11563
11672
  value: namedClause.val
11564
- }, C.factory.sourceLocation(start, namedClause)));
11673
+ }, C.astFactory.sourceLocation(start, namedClause)));
11565
11674
  } }
11566
11675
  ]);
11567
11676
  }
@@ -11582,9 +11691,9 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
11582
11691
  const clause = SUBRULE(subRule);
11583
11692
  clauses.push(clause);
11584
11693
  });
11585
- return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
11694
+ return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
11586
11695
  },
11587
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
11696
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11588
11697
  for (const clause of ast.clauses) {
11589
11698
  F2.printFilter(ast, () => PRINT_WORD(fromUsing));
11590
11699
  if (clause.clauseType === "named") {
@@ -11602,7 +11711,7 @@ var namedGraphClause = {
11602
11711
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
11603
11712
  const named2 = CONSUME(graph_exports.named);
11604
11713
  const iri3 = SUBRULE(sourceSelector);
11605
- return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
11714
+ return ACTION(() => C.astFactory.wrap(iri3, C.astFactory.sourceLocation(named2, iri3)));
11606
11715
  }
11607
11716
  };
11608
11717
  var sourceSelector = {
@@ -11619,7 +11728,7 @@ function funcExpr1(func) {
11619
11728
  CONSUME(symbols_exports.LParen);
11620
11729
  const arg = SUBRULE(expression);
11621
11730
  const close = CONSUME(symbols_exports.RParen);
11622
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
11731
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
11623
11732
  }
11624
11733
  };
11625
11734
  }
@@ -11633,7 +11742,7 @@ function funcExpr2(func) {
11633
11742
  CONSUME(symbols_exports.comma);
11634
11743
  const arg2 = SUBRULE2(expression);
11635
11744
  const close = CONSUME(symbols_exports.RParen);
11636
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
11745
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
11637
11746
  }
11638
11747
  };
11639
11748
  }
@@ -11649,7 +11758,7 @@ function funcExpr3(func) {
11649
11758
  CONSUME2(symbols_exports.comma);
11650
11759
  const arg3 = SUBRULE3(expression);
11651
11760
  const close = CONSUME(symbols_exports.RParen);
11652
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
11761
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
11653
11762
  }
11654
11763
  };
11655
11764
  }
@@ -11661,7 +11770,7 @@ function funcVar1(func) {
11661
11770
  CONSUME(symbols_exports.LParen);
11662
11771
  const arg = SUBRULE(var_);
11663
11772
  const close = CONSUME(symbols_exports.RParen);
11664
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
11773
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
11665
11774
  }
11666
11775
  };
11667
11776
  }
@@ -11675,11 +11784,11 @@ function funcExprOrNil1(func) {
11675
11784
  CONSUME(symbols_exports.LParen);
11676
11785
  const arg = SUBRULE(expression);
11677
11786
  const close = CONSUME(symbols_exports.RParen);
11678
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
11787
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
11679
11788
  } },
11680
11789
  { ALT: () => {
11681
11790
  const nil2 = CONSUME(terminals_exports.nil);
11682
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
11791
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
11683
11792
  } }
11684
11793
  ]);
11685
11794
  }
@@ -11691,7 +11800,7 @@ function funcNil1(func) {
11691
11800
  impl: ({ ACTION, CONSUME }) => (C) => {
11692
11801
  const operator = CONSUME(func);
11693
11802
  const nil2 = CONSUME(terminals_exports.nil);
11694
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
11803
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
11695
11804
  }
11696
11805
  };
11697
11806
  }
@@ -11701,7 +11810,7 @@ function funcExprList1(func) {
11701
11810
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
11702
11811
  const operator = CONSUME(func);
11703
11812
  const args = SUBRULE(expressionList);
11704
- return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
11813
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, args.val, C.astFactory.sourceLocation(operator, args)));
11705
11814
  }
11706
11815
  };
11707
11816
  }
@@ -11719,7 +11828,7 @@ function funcExpr2or3(func) {
11719
11828
  return SUBRULE3(expression);
11720
11829
  });
11721
11830
  const close = CONSUME(symbols_exports.RParen);
11722
- return ACTION(() => C.factory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.factory.sourceLocation(operator, close)));
11831
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
11723
11832
  }
11724
11833
  };
11725
11834
  }
@@ -11739,7 +11848,7 @@ function funcExpr3or4(func) {
11739
11848
  return SUBRULE4(expression);
11740
11849
  });
11741
11850
  const close = CONSUME(symbols_exports.RParen);
11742
- return ACTION(() => C.factory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
11851
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
11743
11852
  }
11744
11853
  };
11745
11854
  }
@@ -11749,7 +11858,7 @@ function funcGroupGraphPattern(func) {
11749
11858
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
11750
11859
  const operator = CONSUME(func);
11751
11860
  const group = SUBRULE(groupGraphPattern);
11752
- return ACTION(() => C.factory.expressionPatternOperation(operator.image, group, C.factory.sourceLocation(operator, group)));
11861
+ return ACTION(() => C.astFactory.expressionPatternOperation(operator.image, group, C.astFactory.sourceLocation(operator, group)));
11753
11862
  }
11754
11863
  };
11755
11864
  }
@@ -11762,7 +11871,7 @@ function baseAggregateFunc(func) {
11762
11871
  const distinct2 = OPTION(() => CONSUME(distinct));
11763
11872
  const expr1 = SUBRULE(expression);
11764
11873
  const close = CONSUME(symbols_exports.RParen);
11765
- return ACTION(() => C.factory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.factory.sourceLocation(operator, close)));
11874
+ return ACTION(() => C.astFactory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.astFactory.sourceLocation(operator, close)));
11766
11875
  }
11767
11876
  };
11768
11877
  }
@@ -11902,17 +12011,17 @@ var aggregateCount = {
11902
12011
  const expressionVal = OR([
11903
12012
  { ALT: () => {
11904
12013
  const starToken = CONSUME(symbols_exports.star);
11905
- return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
12014
+ return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
11906
12015
  } },
11907
12016
  { ALT: () => SUBRULE(expression) }
11908
12017
  ]);
11909
12018
  const closeToken = CONSUME(symbols_exports.RParen);
11910
12019
  return ACTION(() => {
11911
- const F2 = C.factory;
11912
- if (C.factory.isWildcard(expressionVal)) {
11913
- return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12020
+ const F2 = C.astFactory;
12021
+ if (C.astFactory.isWildcard(expressionVal)) {
12022
+ return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
11914
12023
  }
11915
- return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12024
+ return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
11916
12025
  });
11917
12026
  }
11918
12027
  };
@@ -11936,7 +12045,7 @@ var aggregateGroup_concat = {
11936
12045
  });
11937
12046
  const closeToken = CONSUME(symbols_exports.RParen);
11938
12047
  return ACTION(() => {
11939
- const F2 = C.factory;
12048
+ const F2 = C.astFactory;
11940
12049
  return F2.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F2.sourceLocation(operatorToken, closeToken));
11941
12050
  });
11942
12051
  }
@@ -11966,7 +12075,7 @@ var aggregate = {
11966
12075
  });
11967
12076
  return result;
11968
12077
  },
11969
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12078
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11970
12079
  F2.printFilter(ast, () => {
11971
12080
  PRINT_WORD(ast.aggregation.toUpperCase(), "(");
11972
12081
  if (ast.distinct) {
@@ -11993,7 +12102,7 @@ var path = {
11993
12102
  };
11994
12103
  var pathGenerator = {
11995
12104
  name: "path",
11996
- gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F2 }, braces = true) => {
12105
+ gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F2 }, braces = true) => {
11997
12106
  if (F2.isTerm(ast) && F2.isTermNamed(ast)) {
11998
12107
  SUBRULE(iri2, ast);
11999
12108
  } else {
@@ -12042,7 +12151,7 @@ function pathChainHelper(name, SEP, subType, subRule) {
12042
12151
  tailEnd = SUBRULE2(subRule);
12043
12152
  tail.push(tailEnd);
12044
12153
  });
12045
- return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
12154
+ return ACTION(() => tail.length === 0 ? head2 : C.astFactory.path(subType, [head2, ...tail], C.astFactory.sourceLocation(head2, tailEnd)));
12046
12155
  }
12047
12156
  };
12048
12157
  }
@@ -12053,7 +12162,7 @@ var pathEltOrInverse = {
12053
12162
  { ALT: () => {
12054
12163
  const hat2 = CONSUME(symbols_exports.hat);
12055
12164
  const item = SUBRULE2(pathElt);
12056
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12165
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12057
12166
  } }
12058
12167
  ])
12059
12168
  };
@@ -12064,7 +12173,7 @@ var pathElt = {
12064
12173
  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
12065
12174
  const item = SUBRULE(pathPrimary);
12066
12175
  const modification = OPTION(() => SUBRULE(pathMod));
12067
- return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
12176
+ return ACTION(() => modification === void 0 ? item : C.astFactory.path(modification.image, [item], C.astFactory.sourceLocation(item, modification)));
12068
12177
  }
12069
12178
  };
12070
12179
  var pathMod = {
@@ -12096,7 +12205,7 @@ var pathNegatedPropertySet = {
12096
12205
  return OR([
12097
12206
  { ALT: () => {
12098
12207
  const noAlternative = SUBRULE1(pathOneInPropertySet);
12099
- return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
12208
+ return ACTION(() => C.astFactory.path("!", [noAlternative], C.astFactory.sourceLocation(exclamation2, noAlternative)));
12100
12209
  } },
12101
12210
  { ALT: () => {
12102
12211
  const open = CONSUME(symbols_exports.LParen);
@@ -12109,7 +12218,7 @@ var pathNegatedPropertySet = {
12109
12218
  });
12110
12219
  const close = CONSUME(symbols_exports.RParen);
12111
12220
  return ACTION(() => {
12112
- const F2 = C.factory;
12221
+ const F2 = C.astFactory;
12113
12222
  if (tail.length === 0) {
12114
12223
  return F2.path("!", [head2], F2.sourceLocation(exclamation2, close));
12115
12224
  }
@@ -12130,7 +12239,7 @@ var pathOneInPropertySet = {
12130
12239
  { ALT: () => SUBRULE2(iri2) },
12131
12240
  { ALT: () => SUBRULE2(verbA) }
12132
12241
  ]);
12133
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12242
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12134
12243
  } }
12135
12244
  ])
12136
12245
  };
@@ -12155,33 +12264,35 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
12155
12264
  });
12156
12265
  }
12157
12266
  });
12158
- return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
12267
+ return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
12159
12268
  };
12160
12269
  }
12161
12270
  var triplesBlock = {
12162
12271
  name: "triplesBlock",
12163
12272
  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
12164
- gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F2 }) => {
12273
+ gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F2 }) => {
12165
12274
  for (const [index, triple] of ast.triples.entries()) {
12166
12275
  HANDLE_LOC(triple, () => {
12167
12276
  const nextTriple = ast.triples.at(index);
12168
12277
  if (F2.isTripleCollection(triple)) {
12169
12278
  SUBRULE(graphNodePath, triple);
12170
- F2.printFilter(triple, () => PRINT_WORD("."));
12279
+ F2.printFilter(triple, () => PRINT_WORD(".\n"));
12171
12280
  } else {
12172
12281
  SUBRULE(graphNodePath, triple.subject);
12282
+ F2.printFilter(triple, () => PRINT_WORD(""));
12173
12283
  if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
12174
12284
  SUBRULE(varOrTerm, triple.predicate);
12175
12285
  } else {
12176
12286
  SUBRULE(pathGenerator, triple.predicate, void 0);
12177
12287
  }
12288
+ F2.printFilter(triple, () => PRINT_WORD(""));
12178
12289
  SUBRULE(graphNodePath, triple.object);
12179
12290
  if (nextTriple === void 0 || F2.isTripleCollection(nextTriple) || !F2.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
12180
- F2.printFilter(ast, () => PRINT_WORD("."));
12291
+ F2.printFilter(ast, () => PRINT_WORD(".\n"));
12181
12292
  } else if (F2.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
12182
12293
  F2.printFilter(ast, () => PRINT_WORD(","));
12183
12294
  } else {
12184
- F2.printFilter(ast, () => PRINT_WORD(";"));
12295
+ F2.printFilter(ast, () => PRINT_WORD(";\n"));
12185
12296
  }
12186
12297
  }
12187
12298
  });
@@ -12194,24 +12305,24 @@ function triplesSameSubjectImpl(name, allowPaths) {
12194
12305
  impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
12195
12306
  { ALT: () => {
12196
12307
  const subject = SUBRULE(varOrTerm);
12197
- const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.factory.dematerialized(subject)));
12308
+ const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
12198
12309
  return ACTION(() => {
12199
12310
  if (res.length > 0) {
12200
12311
  res[0].subject = subject;
12201
- res[0].loc = C.factory.sourceLocation(subject, res[0]);
12312
+ res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
12202
12313
  }
12203
12314
  return res;
12204
12315
  });
12205
12316
  } },
12206
12317
  { ALT: () => {
12207
12318
  const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
12208
- const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.factory.graphNodeIdentifier(subjectNode)));
12319
+ const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
12209
12320
  return ACTION(() => {
12210
12321
  if (restNode.length === 0) {
12211
12322
  return [subjectNode];
12212
12323
  }
12213
12324
  restNode[0].subject = subjectNode;
12214
- restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
12325
+ restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
12215
12326
  return restNode;
12216
12327
  });
12217
12328
  } }
@@ -12295,7 +12406,7 @@ function objectImpl(name, allowPaths) {
12295
12406
  name,
12296
12407
  impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
12297
12408
  const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
12298
- return ACTION(() => C.factory.triple(subject, predicate, node));
12409
+ return ACTION(() => C.astFactory.triple(subject, predicate, node));
12299
12410
  }
12300
12411
  };
12301
12412
  }
@@ -12312,7 +12423,7 @@ function collectionImpl(name, allowPaths) {
12312
12423
  });
12313
12424
  const endToken = CONSUME(symbols_exports.RParen);
12314
12425
  return ACTION(() => {
12315
- const F2 = C.factory;
12426
+ const F2 = C.astFactory;
12316
12427
  const triples = [];
12317
12428
  const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
12318
12429
  const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12336,7 +12447,7 @@ function collectionImpl(name, allowPaths) {
12336
12447
  return F2.tripleCollectionList(listHead, triples, F2.sourceLocation(startToken, endToken));
12337
12448
  });
12338
12449
  },
12339
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12450
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12340
12451
  F2.printFilter(ast, () => PRINT_WORD("("));
12341
12452
  for (const [idx, triple] of ast.triples.entries()) {
12342
12453
  if (idx % 2 === 0) {
@@ -12367,13 +12478,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
12367
12478
  name,
12368
12479
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12369
12480
  const startToken = CONSUME(symbols_exports.LSquare);
12370
- const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
12481
+ const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
12371
12482
  const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
12372
12483
  const endToken = CONSUME(symbols_exports.RSquare);
12373
- return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
12484
+ return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
12374
12485
  },
12375
- gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F2 }) => {
12376
- F2.printFilter(ast, () => PRINT("["));
12486
+ gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
12487
+ const { astFactory: F2, indentInc } = c;
12488
+ F2.printFilter(ast, () => {
12489
+ c[traqulaIndentation] += indentInc;
12490
+ PRINT("[\n");
12491
+ });
12377
12492
  for (const triple of ast.triples) {
12378
12493
  HANDLE_LOC(triple, () => {
12379
12494
  if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
@@ -12381,11 +12496,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
12381
12496
  } else {
12382
12497
  SUBRULE(pathGenerator, triple.predicate, void 0);
12383
12498
  }
12499
+ F2.printFilter(triple, () => PRINT_WORD(""));
12384
12500
  SUBRULE(graphNodePath, triple.object);
12385
- F2.printFilter(ast, () => PRINT_WORD(";"));
12501
+ F2.printFilter(ast, () => PRINT_WORD(";\n"));
12386
12502
  });
12387
12503
  }
12388
- F2.printFilter(ast, () => PRINT("]"));
12504
+ F2.printFilter(ast, () => {
12505
+ c[traqulaIndentation] -= indentInc;
12506
+ PRINT_ON_EMPTY("]");
12507
+ });
12389
12508
  }
12390
12509
  };
12391
12510
  }
@@ -12402,7 +12521,7 @@ function graphNodeImpl(name, allowPaths) {
12402
12521
  ALT: () => SUBRULE(triplesNodeRule)
12403
12522
  }
12404
12523
  ]),
12405
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
12524
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
12406
12525
  if (F2.isTerm(ast)) {
12407
12526
  SUBRULE(varOrTerm, ast);
12408
12527
  } else {
@@ -12420,9 +12539,9 @@ var whereClause = {
12420
12539
  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
12421
12540
  const where2 = OPTION(() => CONSUME(where));
12422
12541
  const group = SUBRULE(groupGraphPattern);
12423
- return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
12542
+ return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where2, group)));
12424
12543
  },
12425
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12544
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12426
12545
  F2.printFilter(ast, () => PRINT_WORD("WHERE"));
12427
12546
  SUBRULE(groupGraphPattern, ast.val);
12428
12547
  }
@@ -12436,19 +12555,26 @@ var groupGraphPattern = {
12436
12555
  { ALT: () => SUBRULE(groupGraphPatternSub) }
12437
12556
  ]);
12438
12557
  const close = CONSUME(symbols_exports.RCurly);
12439
- return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
12558
+ return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
12440
12559
  },
12441
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12442
- F2.printFilter(ast, () => PRINT_WORD("{"));
12560
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
12561
+ const { astFactory: F2, indentInc } = C;
12562
+ F2.printFilter(ast, () => {
12563
+ C[traqulaIndentation] += indentInc;
12564
+ PRINT_WORD("{\n");
12565
+ });
12443
12566
  for (const pattern of ast.patterns) {
12444
12567
  SUBRULE(generatePattern, pattern);
12445
12568
  }
12446
- F2.printFilter(ast, () => PRINT_WORD("}"));
12569
+ F2.printFilter(ast, () => {
12570
+ C[traqulaIndentation] -= indentInc;
12571
+ PRINT_ON_EMPTY("}\n");
12572
+ });
12447
12573
  }
12448
12574
  };
12449
12575
  var generatePattern = {
12450
12576
  name: "generatePattern",
12451
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
12577
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
12452
12578
  if (ast.type === "query") {
12453
12579
  SUBRULE(query, F2.querySelect({
12454
12580
  context: [],
@@ -12537,9 +12663,9 @@ var optionalGraphPattern = {
12537
12663
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12538
12664
  const optional2 = CONSUME(optional);
12539
12665
  const group = SUBRULE(groupGraphPattern);
12540
- return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
12666
+ return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional2, group)));
12541
12667
  },
12542
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12668
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12543
12669
  F2.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
12544
12670
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
12545
12671
  }
@@ -12550,9 +12676,9 @@ var graphGraphPattern = {
12550
12676
  const graph2 = CONSUME(graph_exports.graph);
12551
12677
  const name = SUBRULE(varOrIri);
12552
12678
  const group = SUBRULE(groupGraphPattern);
12553
- return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
12679
+ return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph2, group)));
12554
12680
  },
12555
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12681
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12556
12682
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
12557
12683
  SUBRULE(varOrTerm, ast.name);
12558
12684
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
@@ -12568,9 +12694,9 @@ var serviceGraphPattern = {
12568
12694
  }) ?? false;
12569
12695
  const name = SUBRULE1(varOrIri);
12570
12696
  const group = SUBRULE1(groupGraphPattern);
12571
- return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
12697
+ return ACTION(() => C.astFactory.patternService(name, group.patterns, silent2, C.astFactory.sourceLocation(service2, group)));
12572
12698
  },
12573
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12699
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12574
12700
  F2.printFilter(ast, () => {
12575
12701
  PRINT_WORD("SERVICE");
12576
12702
  if (ast.silent) {
@@ -12590,14 +12716,14 @@ var bind2 = {
12590
12716
  CONSUME(as);
12591
12717
  const variable = SUBRULE(var_);
12592
12718
  const close = CONSUME(symbols_exports.RParen);
12593
- return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
12719
+ return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
12594
12720
  },
12595
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12721
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12596
12722
  F2.printFilter(ast, () => PRINT_WORD("BIND", "("));
12597
12723
  SUBRULE(expression, ast.expression);
12598
12724
  F2.printFilter(ast, () => PRINT_WORD("AS"));
12599
12725
  SUBRULE(var_, ast.variable);
12600
- F2.printFilter(ast, () => PRINT_WORD(")"));
12726
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
12601
12727
  }
12602
12728
  };
12603
12729
  var inlineData = {
@@ -12605,16 +12731,19 @@ var inlineData = {
12605
12731
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12606
12732
  const values3 = CONSUME(values2);
12607
12733
  const datablock = SUBRULE(dataBlock);
12608
- return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
12734
+ return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
12609
12735
  },
12610
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12736
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
12737
+ const { astFactory: F2, indentInc } = C;
12611
12738
  const variables = Object.keys(ast.values.at(0) ?? {});
12612
12739
  F2.printFilter(ast, () => {
12740
+ PRINT_ON_EMPTY("");
12613
12741
  PRINT_WORD("VALUES", "(");
12614
12742
  for (const variable of variables) {
12615
12743
  PRINT_WORD(`?${variable}`);
12616
12744
  }
12617
- PRINT_WORD(")", "{");
12745
+ C[traqulaIndentation] += indentInc;
12746
+ PRINT_WORD(")", "{\n");
12618
12747
  });
12619
12748
  for (const mapping of ast.values) {
12620
12749
  F2.printFilter(ast, () => PRINT_WORD("("));
@@ -12625,9 +12754,12 @@ var inlineData = {
12625
12754
  SUBRULE(graphNodePath, mapping[variable]);
12626
12755
  }
12627
12756
  }
12628
- F2.printFilter(ast, () => PRINT_WORD(")"));
12757
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
12629
12758
  }
12630
- F2.printFilter(ast, () => PRINT_WORD("}"));
12759
+ F2.printFilter(ast, () => {
12760
+ C[traqulaIndentation] -= indentInc;
12761
+ PRINT_ON_EMPTY("}\n");
12762
+ });
12631
12763
  }
12632
12764
  };
12633
12765
  var dataBlock = {
@@ -12650,7 +12782,7 @@ var inlineDataOneVar = {
12650
12782
  });
12651
12783
  });
12652
12784
  const close = CONSUME(symbols_exports.RCurly);
12653
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
12785
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(varVal, close)));
12654
12786
  }
12655
12787
  };
12656
12788
  var inlineDataFull = {
@@ -12667,7 +12799,7 @@ var inlineDataFull = {
12667
12799
  res.push({});
12668
12800
  });
12669
12801
  const close = CONSUME1(symbols_exports.RCurly);
12670
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
12802
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(nil2, close)));
12671
12803
  } },
12672
12804
  { ALT: () => {
12673
12805
  const open = CONSUME1(symbols_exports.LParen);
@@ -12699,7 +12831,7 @@ var inlineDataFull = {
12699
12831
  });
12700
12832
  });
12701
12833
  const close = CONSUME2(symbols_exports.RCurly);
12702
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
12834
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(open, close)));
12703
12835
  } }
12704
12836
  ]);
12705
12837
  }
@@ -12722,9 +12854,9 @@ var minusGraphPattern = {
12722
12854
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12723
12855
  const minus2 = CONSUME(minus);
12724
12856
  const group = SUBRULE(groupGraphPattern);
12725
- return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
12857
+ return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus2, group)));
12726
12858
  },
12727
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12859
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12728
12860
  F2.printFilter(ast, () => PRINT_WORD("MINUS"));
12729
12861
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
12730
12862
  }
@@ -12740,9 +12872,9 @@ var groupOrUnionGraphPattern = {
12740
12872
  const group2 = SUBRULE2(groupGraphPattern);
12741
12873
  groups.push(group2);
12742
12874
  });
12743
- return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
12875
+ return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
12744
12876
  },
12745
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12877
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12746
12878
  if (F2.isPatternUnion(ast)) {
12747
12879
  const [head2, ...tail] = ast.patterns;
12748
12880
  SUBRULE(groupGraphPattern, head2);
@@ -12760,12 +12892,12 @@ var filter3 = {
12760
12892
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12761
12893
  const filterToken = CONSUME(filter2);
12762
12894
  const expression2 = SUBRULE(constraint);
12763
- return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
12895
+ return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
12764
12896
  },
12765
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12897
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12766
12898
  F2.printFilter(ast, () => PRINT_WORD("FILTER ("));
12767
12899
  SUBRULE(expression, ast.expression);
12768
- F2.printFilter(ast, () => PRINT_WORD(")"));
12900
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
12769
12901
  }
12770
12902
  };
12771
12903
  var constraint = {
@@ -12781,7 +12913,7 @@ var functionCall = {
12781
12913
  impl: ({ ACTION, SUBRULE }) => (C) => {
12782
12914
  const func = SUBRULE(iri2);
12783
12915
  const args = SUBRULE(argList);
12784
- return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
12916
+ return ACTION(() => C.astFactory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.astFactory.sourceLocation(func, args)));
12785
12917
  }
12786
12918
  };
12787
12919
 
@@ -12791,7 +12923,7 @@ var argList = {
12791
12923
  impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
12792
12924
  { ALT: () => {
12793
12925
  const nil2 = CONSUME(terminals_exports.nil);
12794
- return ACTION(() => C.factory.wrap({ args: [], distinct: false }, C.factory.sourceLocation(nil2)));
12926
+ return ACTION(() => C.astFactory.wrap({ args: [], distinct: false }, C.astFactory.sourceLocation(nil2)));
12795
12927
  } },
12796
12928
  { ALT: () => {
12797
12929
  const args = [];
@@ -12808,10 +12940,10 @@ var argList = {
12808
12940
  }
12809
12941
  });
12810
12942
  const close = CONSUME(symbols_exports.RParen);
12811
- return ACTION(() => C.factory.wrap({ args, distinct: distinct2 }, C.factory.sourceLocation(open, close)));
12943
+ return ACTION(() => C.astFactory.wrap({ args, distinct: distinct2 }, C.astFactory.sourceLocation(open, close)));
12812
12944
  } }
12813
12945
  ]),
12814
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12946
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12815
12947
  F2.printFilter(ast, () => {
12816
12948
  PRINT_WORD("(");
12817
12949
  if (ast.val.distinct) {
@@ -12834,7 +12966,7 @@ var expressionList = {
12834
12966
  impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => (C) => OR([
12835
12967
  { ALT: () => {
12836
12968
  const nil2 = CONSUME(terminals_exports.nil);
12837
- return ACTION(() => C.factory.wrap([], C.factory.sourceLocation(nil2)));
12969
+ return ACTION(() => C.astFactory.wrap([], C.astFactory.sourceLocation(nil2)));
12838
12970
  } },
12839
12971
  { ALT: () => {
12840
12972
  const open = CONSUME(symbols_exports.LParen);
@@ -12846,7 +12978,7 @@ var expressionList = {
12846
12978
  args.push(expr);
12847
12979
  });
12848
12980
  const close = CONSUME(symbols_exports.RParen);
12849
- return ACTION(() => C.factory.wrap(args, C.factory.sourceLocation(open, close)));
12981
+ return ACTION(() => C.astFactory.wrap(args, C.astFactory.sourceLocation(open, close)));
12850
12982
  } }
12851
12983
  ])
12852
12984
  };
@@ -12855,7 +12987,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
12855
12987
  var expression = {
12856
12988
  name: "expression",
12857
12989
  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
12858
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12990
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12859
12991
  if (F2.isTerm(ast)) {
12860
12992
  SUBRULE(varOrTerm, ast);
12861
12993
  } else if (F2.isExpressionOperator(ast)) {
@@ -12920,7 +13052,7 @@ var conditionalOrExpression = {
12920
13052
  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
12921
13053
  CONSUME(symbols_exports.logicOr);
12922
13054
  const args = SUBRULE2(conditionalAndExpression);
12923
- return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
13055
+ return (left) => ACTION(() => C.astFactory.expressionOperation("||", [left, args], C.astFactory.sourceLocation(left, args)));
12924
13056
  }, ACTION, MANY)
12925
13057
  };
12926
13058
  var conditionalAndExpression = {
@@ -12928,7 +13060,7 @@ var conditionalAndExpression = {
12928
13060
  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
12929
13061
  CONSUME(symbols_exports.logicAnd);
12930
13062
  const arg = SUBRULE2(valueLogical);
12931
- return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
13063
+ return (left) => ACTION(() => C.astFactory.expressionOperation("&&", [left, arg], C.astFactory.sourceLocation(left, arg)));
12932
13064
  }, ACTION, MANY)
12933
13065
  };
12934
13066
  var valueLogical = {
@@ -12950,7 +13082,7 @@ var relationalExpression = {
12950
13082
  { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
12951
13083
  ]);
12952
13084
  const expr = SUBRULE2(numericExpression);
12953
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, expr], C.factory.sourceLocation(args1, expr)));
13085
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, expr], C.astFactory.sourceLocation(args1, expr)));
12954
13086
  } },
12955
13087
  { ALT: () => {
12956
13088
  const operator = OR3([
@@ -12958,7 +13090,7 @@ var relationalExpression = {
12958
13090
  { ALT: () => CONSUME(notIn) }
12959
13091
  ]);
12960
13092
  const args = SUBRULE1(expressionList);
12961
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, ...args.val], C.factory.sourceLocation(args1, args)));
13093
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, ...args.val], C.astFactory.sourceLocation(args1, args)));
12962
13094
  } }
12963
13095
  ]));
12964
13096
  return expression2 ?? args1;
@@ -12977,7 +13109,7 @@ var additiveExpression = {
12977
13109
  { ALT: () => CONSUME(symbols_exports.opMinus) }
12978
13110
  ]);
12979
13111
  const arg = SUBRULE2(multiplicativeExpression);
12980
- return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
13112
+ return ACTION(() => (left) => C.astFactory.expressionOperation(operator.image, [left, arg], C.astFactory.sourceLocation(left, arg)));
12981
13113
  } },
12982
13114
  { ALT: () => {
12983
13115
  const { operator, startInt } = OR3([
@@ -13008,9 +13140,9 @@ var additiveExpression = {
13008
13140
  { ALT: () => CONSUME(symbols_exports.slash) }
13009
13141
  ]);
13010
13142
  const innerExpr = SUBRULE1(unaryExpression);
13011
- return ACTION(() => (leftInner) => C.factory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.factory.sourceLocation(leftInner, innerExpr)));
13143
+ return ACTION(() => (leftInner) => C.astFactory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.astFactory.sourceLocation(leftInner, innerExpr)));
13012
13144
  }, ACTION, MANY2);
13013
- return (left) => C.factory.expressionOperation(operator, [left, multiplicativeExpr], C.factory.sourceLocation(left, multiplicativeExpr));
13145
+ return (left) => C.astFactory.expressionOperation(operator, [left, multiplicativeExpr], C.astFactory.sourceLocation(left, multiplicativeExpr));
13014
13146
  } }
13015
13147
  ]), ACTION, MANY1)
13016
13148
  };
@@ -13027,7 +13159,7 @@ var multiplicativeExpression = {
13027
13159
  subType: "operation",
13028
13160
  operator: operator.image,
13029
13161
  args: [left, expr],
13030
- loc: C.factory.sourceLocation(left, expr)
13162
+ loc: C.astFactory.sourceLocation(left, expr)
13031
13163
  });
13032
13164
  }, ACTION, MANY)
13033
13165
  };
@@ -13042,7 +13174,7 @@ var unaryExpression = {
13042
13174
  { ALT: () => CONSUME(symbols_exports.opMinus) }
13043
13175
  ]);
13044
13176
  const expr = SUBRULE2(primaryExpression);
13045
- return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
13177
+ return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
13046
13178
  } }
13047
13179
  ])
13048
13180
  };
@@ -13065,7 +13197,7 @@ var brackettedExpression = {
13065
13197
  const expr = SUBRULE(expression);
13066
13198
  const close = CONSUME(symbols_exports.RParen);
13067
13199
  return ACTION(() => {
13068
- expr.loc = C.factory.sourceLocation(open, close);
13200
+ expr.loc = C.astFactory.sourceLocation(open, close);
13069
13201
  return expr;
13070
13202
  });
13071
13203
  }
@@ -13087,13 +13219,13 @@ var iriOrFunction = {
13087
13219
  function: iriVal,
13088
13220
  args: args.val.args,
13089
13221
  distinct: distinct2,
13090
- loc: C.factory.sourceLocation(iriVal, args)
13222
+ loc: C.astFactory.sourceLocation(iriVal, args)
13091
13223
  };
13092
13224
  });
13093
13225
  });
13094
13226
  return functionCall2 ?? iriVal;
13095
13227
  },
13096
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13228
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13097
13229
  if (F2.isTermNamed(ast)) {
13098
13230
  SUBRULE(iri2, ast);
13099
13231
  } else {
@@ -13146,11 +13278,14 @@ var groupClause = {
13146
13278
  type: "solutionModifier",
13147
13279
  subType: "group",
13148
13280
  groupings,
13149
- loc: C.factory.sourceLocation(start, groupings.at(-1))
13281
+ loc: C.astFactory.sourceLocation(start, groupings.at(-1))
13150
13282
  }));
13151
13283
  },
13152
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F2 }) => {
13153
- F2.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
13284
+ gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
13285
+ F2.printFilter(ast, () => {
13286
+ PRINT_ON_EMPTY("");
13287
+ PRINT_WORDS("GROUP", "BY");
13288
+ });
13154
13289
  for (const grouping of ast.groupings) {
13155
13290
  if (F2.isExpression(grouping)) {
13156
13291
  SUBRULE(expression, grouping);
@@ -13184,7 +13319,7 @@ var groupCondition = {
13184
13319
  return {
13185
13320
  variable,
13186
13321
  value: expressionValue,
13187
- loc: C.factory.sourceLocation(open, close)
13322
+ loc: C.astFactory.sourceLocation(open, close)
13188
13323
  };
13189
13324
  }
13190
13325
  return expressionValue;
@@ -13203,10 +13338,13 @@ var havingClause = {
13203
13338
  expressions.push(SUBRULE(havingCondition));
13204
13339
  });
13205
13340
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13206
- return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
13341
+ return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
13207
13342
  },
13208
- gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F2 }) => {
13209
- F2.printFilter(ast, () => PRINT_WORD("HAVING"));
13343
+ gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
13344
+ F2.printFilter(ast, () => {
13345
+ PRINT_ON_EMPTY("");
13346
+ PRINT_WORD("HAVING");
13347
+ });
13210
13348
  for (const having2 of ast.having) {
13211
13349
  SUBRULE(expression, having2);
13212
13350
  }
@@ -13227,10 +13365,13 @@ var orderClause = {
13227
13365
  orderings.push(SUBRULE1(orderCondition));
13228
13366
  });
13229
13367
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13230
- return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
13368
+ return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order2, orderings.at(-1))));
13231
13369
  },
13232
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F2 }) => {
13233
- F2.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
13370
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
13371
+ F2.printFilter(ast, () => {
13372
+ PRINT_ON_EMPTY("");
13373
+ PRINT_WORDS("ORDER", "BY");
13374
+ });
13234
13375
  for (const ordering of ast.orderDefs) {
13235
13376
  if (ordering.descending) {
13236
13377
  F2.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13261,7 +13402,7 @@ var orderCondition = {
13261
13402
  return ACTION(() => ({
13262
13403
  expression: expr,
13263
13404
  descending: descending[0],
13264
- loc: C.factory.sourceLocation(descending[1], expr)
13405
+ loc: C.astFactory.sourceLocation(descending[1], expr)
13265
13406
  }));
13266
13407
  } },
13267
13408
  { ALT: () => {
@@ -13280,16 +13421,17 @@ var limitOffsetClauses = {
13280
13421
  { ALT: () => {
13281
13422
  const limit2 = SUBRULE1(limitClause);
13282
13423
  const offset2 = OPTION1(() => SUBRULE1(offsetClause));
13283
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13424
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.astFactory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13284
13425
  } },
13285
13426
  { ALT: () => {
13286
13427
  const offset2 = SUBRULE2(offsetClause);
13287
13428
  const limit2 = OPTION2(() => SUBRULE2(limitClause));
13288
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
13429
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
13289
13430
  } }
13290
13431
  ]),
13291
- gImpl: ({ PRINT_WORDS }) => (ast, { factory: F2 }) => {
13432
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
13292
13433
  F2.printFilter(ast, () => {
13434
+ PRINT_ON_EMPTY("");
13293
13435
  if (ast.limit) {
13294
13436
  PRINT_WORDS("LIMIT", String(ast.limit));
13295
13437
  }
@@ -13305,7 +13447,7 @@ var limitClause = {
13305
13447
  const offset2 = CONSUME(limit);
13306
13448
  const value = CONSUME(terminals_exports.integer);
13307
13449
  const val = Number.parseInt(value.image, 10);
13308
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13450
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13309
13451
  }
13310
13452
  };
13311
13453
  var offsetClause = {
@@ -13314,7 +13456,7 @@ var offsetClause = {
13314
13456
  const offset2 = CONSUME(offset);
13315
13457
  const value = CONSUME(terminals_exports.integer);
13316
13458
  const val = Number.parseInt(value.image, 10);
13317
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13459
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13318
13460
  }
13319
13461
  };
13320
13462
 
@@ -13339,10 +13481,10 @@ var query = {
13339
13481
  ...subType,
13340
13482
  type: "query",
13341
13483
  ...values3 && { values: values3 },
13342
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
13484
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
13343
13485
  }));
13344
13486
  },
13345
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13487
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13346
13488
  SUBRULE(prologue, ast.context);
13347
13489
  if (F2.isQuerySelect(ast)) {
13348
13490
  SUBRULE(selectQuery, ast);
@@ -13372,13 +13514,13 @@ var selectQuery = {
13372
13514
  solutionModifiers: modifiers,
13373
13515
  datasets: from2,
13374
13516
  ...selectVal.val,
13375
- loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13517
+ loc: C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13376
13518
  };
13377
13519
  queryIsGood(ret);
13378
13520
  return ret;
13379
13521
  });
13380
13522
  },
13381
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13523
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13382
13524
  SUBRULE(selectClause, F2.wrap({
13383
13525
  variables: ast.variables,
13384
13526
  distinct: ast.distinct,
@@ -13396,14 +13538,14 @@ var subSelect = {
13396
13538
  const where2 = SUBRULE(whereClause);
13397
13539
  const modifiers = SUBRULE(solutionModifier);
13398
13540
  const values3 = SUBRULE(valuesClause);
13399
- return ACTION(() => C.factory.querySelect({
13541
+ return ACTION(() => C.astFactory.querySelect({
13400
13542
  where: where2.val,
13401
- datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
13543
+ datasets: C.astFactory.datasetClauses([], C.astFactory.sourceLocation()),
13402
13544
  context: [],
13403
13545
  solutionModifiers: modifiers,
13404
13546
  ...selectVal.val,
13405
13547
  ...values3 && { values: values3 }
13406
- }, C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13548
+ }, C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13407
13549
  }
13408
13550
  };
13409
13551
  var selectClause = {
@@ -13434,7 +13576,7 @@ var selectClause = {
13434
13576
  const star2 = CONSUME(symbols_exports.star);
13435
13577
  return ACTION(() => {
13436
13578
  last2 = star2;
13437
- return { variables: [C.factory.wildcard(C.factory.sourceLocation(star2))], ...distRed };
13579
+ return { variables: [C.astFactory.wildcard(C.astFactory.sourceLocation(star2))], ...distRed };
13438
13580
  });
13439
13581
  } },
13440
13582
  { ALT: () => {
@@ -13464,7 +13606,7 @@ var selectClause = {
13464
13606
  throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
13465
13607
  }
13466
13608
  usedVars.push(variable);
13467
- variables.push(C.factory.patternBind(expr, variable, C.factory.sourceLocation(open, last2)));
13609
+ variables.push(C.astFactory.patternBind(expr, variable, C.astFactory.sourceLocation(open, last2)));
13468
13610
  });
13469
13611
  } }
13470
13612
  ]));
@@ -13472,9 +13614,9 @@ var selectClause = {
13472
13614
  } }
13473
13615
  ]);
13474
13616
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13475
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select2, last2)));
13617
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
13476
13618
  },
13477
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13619
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13478
13620
  F2.printFilter(ast, () => {
13479
13621
  PRINT_WORD("SELECT");
13480
13622
  if (ast.val.distinct) {
@@ -13514,7 +13656,7 @@ var constructQuery = {
13514
13656
  datasets: from2,
13515
13657
  where: where2.val,
13516
13658
  solutionModifiers: modifiers,
13517
- loc: C.factory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13659
+ loc: C.astFactory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13518
13660
  }));
13519
13661
  } },
13520
13662
  { ALT: () => {
@@ -13526,19 +13668,26 @@ var constructQuery = {
13526
13668
  subType: "construct",
13527
13669
  template: template.val,
13528
13670
  datasets: from2,
13529
- where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
13671
+ where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
13530
13672
  solutionModifiers: modifiers,
13531
- loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13673
+ loc: C.astFactory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13532
13674
  }));
13533
13675
  } }
13534
13676
  ]);
13535
13677
  },
13536
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13678
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
13679
+ const { astFactory: F2, indentInc } = C;
13537
13680
  F2.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
13538
13681
  if (!F2.isSourceLocationNoMaterialize(ast.where.loc)) {
13539
- F2.printFilter(ast, () => PRINT_WORD("{"));
13682
+ F2.printFilter(ast, () => {
13683
+ C[traqulaIndentation] += indentInc;
13684
+ PRINT_WORD("{\n");
13685
+ });
13540
13686
  SUBRULE(triplesBlock, ast.template);
13541
- F2.printFilter(ast, () => PRINT_WORD("}"));
13687
+ F2.printFilter(ast, () => {
13688
+ C[traqulaIndentation] -= indentInc;
13689
+ PRINT_ON_EMPTY("}\n");
13690
+ });
13542
13691
  }
13543
13692
  SUBRULE(datasetClauseStar, ast.datasets);
13544
13693
  if (F2.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13563,7 +13712,7 @@ var describeQuery = {
13563
13712
  } },
13564
13713
  { ALT: () => {
13565
13714
  const star2 = CONSUME(symbols_exports.star);
13566
- return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star2)))];
13715
+ return [ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(star2)))];
13567
13716
  } }
13568
13717
  ]);
13569
13718
  const from2 = SUBRULE1(datasetClauseStar);
@@ -13575,10 +13724,10 @@ var describeQuery = {
13575
13724
  datasets: from2,
13576
13725
  ...where2 && { where: where2.val },
13577
13726
  solutionModifiers: modifiers,
13578
- loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13727
+ loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13579
13728
  }));
13580
13729
  },
13581
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13730
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13582
13731
  F2.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
13583
13732
  if (F2.isWildcard(ast.variables[0])) {
13584
13733
  F2.printFilter(ast, () => PRINT_WORD("*"));
@@ -13606,10 +13755,10 @@ var askQuery = {
13606
13755
  datasets: from2,
13607
13756
  where: where2.val,
13608
13757
  solutionModifiers: modifiers,
13609
- loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13758
+ loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13610
13759
  }));
13611
13760
  },
13612
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13761
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13613
13762
  F2.printFilter(ast, () => PRINT_WORD("ASK"));
13614
13763
  SUBRULE(datasetClauseStar, ast.datasets);
13615
13764
  SUBRULE(whereClause, F2.wrap(ast.where, ast.loc));
@@ -13626,7 +13775,7 @@ var constructTemplate = {
13626
13775
  const open = CONSUME(symbols_exports.LCurly);
13627
13776
  const triples = OPTION(() => SUBRULE1(constructTriples));
13628
13777
  const close = CONSUME(symbols_exports.RCurly);
13629
- return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
13778
+ return ACTION(() => C.astFactory.wrap(triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocation()), C.astFactory.sourceLocation(open, close)));
13630
13779
  }
13631
13780
  };
13632
13781
  var constructTriples = {
@@ -13663,13 +13812,13 @@ var update = {
13663
13812
  const update2 = {
13664
13813
  type: "update",
13665
13814
  updates,
13666
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
13815
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
13667
13816
  };
13668
13817
  updateNoReuseBlankNodeLabels(update2);
13669
13818
  return update2;
13670
13819
  });
13671
13820
  },
13672
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13821
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13673
13822
  const [head2, ...tail] = ast.updates;
13674
13823
  if (head2) {
13675
13824
  SUBRULE(prologue, head2.context);
@@ -13749,9 +13898,9 @@ var load2 = {
13749
13898
  CONSUME(loadInto);
13750
13899
  return SUBRULE1(graphRef);
13751
13900
  });
13752
- return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
13901
+ return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
13753
13902
  },
13754
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13903
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13755
13904
  F2.printFilter(ast, () => {
13756
13905
  PRINT_WORD("LOAD");
13757
13906
  if (ast.silent) {
@@ -13772,9 +13921,9 @@ function clearOrDrop(operation) {
13772
13921
  const opToken = CONSUME(operation);
13773
13922
  const silent2 = OPTION(() => CONSUME(silent));
13774
13923
  const destination = SUBRULE1(graphRefAll);
13775
- return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
13924
+ return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
13776
13925
  },
13777
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13926
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13778
13927
  F2.printFilter(ast, () => {
13779
13928
  PRINT_WORD(operation.name.toUpperCase());
13780
13929
  if (ast.silent) {
@@ -13793,9 +13942,9 @@ var create2 = {
13793
13942
  const createToken3 = CONSUME(create);
13794
13943
  const silent2 = OPTION(() => CONSUME(silent));
13795
13944
  const destination = SUBRULE1(graphRef);
13796
- return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
13945
+ return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
13797
13946
  },
13798
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13947
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13799
13948
  F2.printFilter(ast, () => {
13800
13949
  PRINT_WORD("CREATE");
13801
13950
  if (ast.silent) {
@@ -13814,9 +13963,9 @@ function copyMoveAddOperation(operation) {
13814
13963
  const source = SUBRULE1(graphOrDefault);
13815
13964
  CONSUME(to);
13816
13965
  const destination = SUBRULE2(graphOrDefault);
13817
- return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
13966
+ return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
13818
13967
  },
13819
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13968
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13820
13969
  F2.printFilter(ast, () => {
13821
13970
  PRINT_WORD(operation.name.toUpperCase());
13822
13971
  if (ast.silent) {
@@ -13838,7 +13987,7 @@ var quadPattern = {
13838
13987
  const open = CONSUME(symbols_exports.LCurly);
13839
13988
  const val = SUBRULE1(quads);
13840
13989
  const close = CONSUME(symbols_exports.RCurly);
13841
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
13990
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
13842
13991
  }
13843
13992
  };
13844
13993
  var quadData = {
@@ -13849,7 +13998,7 @@ var quadData = {
13849
13998
  const val = SUBRULE1(quads);
13850
13999
  ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
13851
14000
  const close = CONSUME(symbols_exports.RCurly);
13852
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
14001
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
13853
14002
  }
13854
14003
  };
13855
14004
  function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
@@ -13866,12 +14015,26 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
13866
14015
  if (name !== "insertData") {
13867
14016
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
13868
14017
  }
13869
- return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
14018
+ return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
13870
14019
  },
13871
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13872
- F2.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
14020
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14021
+ const { astFactory: F2, indentInc } = C;
14022
+ F2.printFilter(ast, () => {
14023
+ C[traqulaIndentation] += indentInc;
14024
+ if (subType === "insertdata") {
14025
+ PRINT_WORD("INSERT DATA");
14026
+ } else if (subType === "deletedata") {
14027
+ PRINT_WORD("DELETE DATA");
14028
+ } else if (subType === "deletewhere") {
14029
+ PRINT_WORD("DELETE WHERE");
14030
+ }
14031
+ PRINT_WORD("{\n");
14032
+ });
13873
14033
  SUBRULE(quads, F2.wrap(ast.data, ast.loc));
13874
- F2.printFilter(ast, () => PRINT_WORD("}"));
14034
+ F2.printFilter(ast, () => {
14035
+ C[traqulaIndentation] -= indentInc;
14036
+ PRINT_ON_EMPTY("}\n");
14037
+ });
13875
14038
  }
13876
14039
  };
13877
14040
  }
@@ -13900,22 +14063,35 @@ var modify = {
13900
14063
  const using = SUBRULE1(usingClauseStar);
13901
14064
  CONSUME(where);
13902
14065
  const where2 = SUBRULE1(groupGraphPattern);
13903
- return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
14066
+ return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
13904
14067
  },
13905
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14068
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14069
+ const { astFactory: F2, indentInc } = C;
13906
14070
  if (ast.graph) {
13907
14071
  F2.printFilter(ast, () => PRINT_WORD("WITH"));
13908
14072
  SUBRULE(iri2, ast.graph);
13909
14073
  }
13910
14074
  if (ast.delete.length > 0) {
13911
- F2.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
14075
+ F2.printFilter(ast, () => {
14076
+ C[traqulaIndentation] += indentInc;
14077
+ PRINT_WORD("DELETE", "{\n");
14078
+ });
13912
14079
  SUBRULE(quads, F2.wrap(ast.delete, ast.loc));
13913
- F2.printFilter(ast, () => PRINT_WORD("}"));
14080
+ F2.printFilter(ast, () => {
14081
+ C[traqulaIndentation] -= indentInc;
14082
+ PRINT_ON_EMPTY("}\n");
14083
+ });
13914
14084
  }
13915
14085
  if (ast.insert.length > 0) {
13916
- F2.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
14086
+ F2.printFilter(ast, () => {
14087
+ C[traqulaIndentation] += indentInc;
14088
+ PRINT_WORD("INSERT", "{\n");
14089
+ });
13917
14090
  SUBRULE(quads, F2.wrap(ast.insert, ast.loc));
13918
- F2.printFilter(ast, () => PRINT_WORD("}"));
14091
+ F2.printFilter(ast, () => {
14092
+ C[traqulaIndentation] -= indentInc;
14093
+ PRINT_ON_EMPTY("}\n");
14094
+ });
13919
14095
  }
13920
14096
  SUBRULE(usingClauseStar, ast.from);
13921
14097
  F2.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -13929,7 +14105,7 @@ var deleteClause2 = {
13929
14105
  const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
13930
14106
  const del = SUBRULE(quadPattern);
13931
14107
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
13932
- return ACTION(() => C.factory.wrap(del.val, C.factory.sourceLocation(delToken, del)));
14108
+ return ACTION(() => C.astFactory.wrap(del.val, C.astFactory.sourceLocation(delToken, del)));
13933
14109
  }
13934
14110
  };
13935
14111
  var insertClause2 = {
@@ -13937,7 +14113,7 @@ var insertClause2 = {
13937
14113
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13938
14114
  const insertToken = CONSUME(insertClause);
13939
14115
  const insert = SUBRULE(quadPattern);
13940
- return ACTION(() => C.factory.wrap(insert.val, C.factory.sourceLocation(insertToken, insert)));
14116
+ return ACTION(() => C.astFactory.wrap(insert.val, C.astFactory.sourceLocation(insertToken, insert)));
13941
14117
  }
13942
14118
  };
13943
14119
  var graphOrDefault = {
@@ -13945,12 +14121,12 @@ var graphOrDefault = {
13945
14121
  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => OR([
13946
14122
  { ALT: () => {
13947
14123
  const def = CONSUME(graph_exports.default_);
13948
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14124
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
13949
14125
  } },
13950
14126
  { ALT: () => {
13951
14127
  const graph2 = OPTION(() => CONSUME(graph_exports.graph));
13952
14128
  const name = SUBRULE1(iri2);
13953
- return ACTION(() => C.factory.graphRefSpecific(name, C.factory.sourceLocation(graph2, name)));
14129
+ return ACTION(() => C.astFactory.graphRefSpecific(name, C.astFactory.sourceLocation(graph2, name)));
13954
14130
  } }
13955
14131
  ])
13956
14132
  };
@@ -13959,9 +14135,9 @@ var graphRef = {
13959
14135
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13960
14136
  const graph2 = CONSUME(graph_exports.graph);
13961
14137
  const val = SUBRULE(iri2);
13962
- return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
14138
+ return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph2, val)));
13963
14139
  },
13964
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14140
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13965
14141
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
13966
14142
  SUBRULE(iri2, ast.graph);
13967
14143
  }
@@ -13972,18 +14148,18 @@ var graphRefAll = {
13972
14148
  { ALT: () => SUBRULE(graphRef) },
13973
14149
  { ALT: () => {
13974
14150
  const def = CONSUME(graph_exports.default_);
13975
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14151
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
13976
14152
  } },
13977
14153
  { ALT: () => {
13978
14154
  const named2 = CONSUME(graph_exports.named);
13979
- return ACTION(() => C.factory.graphRefNamed(C.factory.sourceLocation(named2)));
14155
+ return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named2)));
13980
14156
  } },
13981
14157
  { ALT: () => {
13982
14158
  const graphAll2 = CONSUME(graph_exports.graphAll);
13983
- return ACTION(() => C.factory.graphRefAll(C.factory.sourceLocation(graphAll2)));
14159
+ return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll2)));
13984
14160
  } }
13985
14161
  ]),
13986
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14162
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13987
14163
  if (F2.isGraphRefSpecific(ast)) {
13988
14164
  SUBRULE(graphRef, ast);
13989
14165
  } else if (F2.isGraphRefDefault(ast)) {
@@ -14020,9 +14196,9 @@ var quads = {
14020
14196
  ACTION(() => quads2.push(triples));
14021
14197
  });
14022
14198
  });
14023
- return ACTION(() => C.factory.wrap(quads2, C.factory.sourceLocation(quads2.at(0), last2)));
14199
+ return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last2)));
14024
14200
  },
14025
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
14201
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
14026
14202
  for (const quad of ast.val) {
14027
14203
  if (F2.isPattern(quad)) {
14028
14204
  SUBRULE(triplesBlock, quad);
@@ -14040,14 +14216,21 @@ var quadsNotTriples = {
14040
14216
  CONSUME(symbols_exports.LCurly);
14041
14217
  const triples = OPTION(() => SUBRULE1(triplesTemplate));
14042
14218
  const close = CONSUME(symbols_exports.RCurly);
14043
- return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
14219
+ return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
14044
14220
  },
14045
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14221
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14222
+ const { astFactory: F2, indentInc } = C;
14046
14223
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
14047
14224
  SUBRULE(varOrTerm, ast.graph);
14048
- F2.printFilter(ast, () => PRINT_WORD("{"));
14225
+ F2.printFilter(ast, () => {
14226
+ C[traqulaIndentation] += indentInc;
14227
+ PRINT_WORD("{\n");
14228
+ });
14049
14229
  SUBRULE(triplesBlock, ast.triples);
14050
- F2.printFilter(ast, () => PRINT_WORD("}"));
14230
+ F2.printFilter(ast, () => {
14231
+ C[traqulaIndentation] -= indentInc;
14232
+ PRINT_ON_EMPTY("}\n");
14233
+ });
14051
14234
  }
14052
14235
  };
14053
14236
 
@@ -14070,7 +14253,7 @@ var queryOrUpdate = {
14070
14253
  ...subType,
14071
14254
  type: "query",
14072
14255
  ...values3 && { values: values3 },
14073
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
14256
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
14074
14257
  }));
14075
14258
  } },
14076
14259
  { ALT: () => {
@@ -14094,7 +14277,7 @@ var queryOrUpdate = {
14094
14277
  const update2 = {
14095
14278
  type: "update",
14096
14279
  updates,
14097
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14280
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14098
14281
  };
14099
14282
  updateNoReuseBlankNodeLabels(update2);
14100
14283
  return update2;
@@ -14102,7 +14285,7 @@ var queryOrUpdate = {
14102
14285
  } }
14103
14286
  ]);
14104
14287
  },
14105
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
14288
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
14106
14289
  if (F2.isQuery(ast)) {
14107
14290
  SUBRULE(query, ast);
14108
14291
  } else {