@traqula/parser-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 +566 -381
  2. package/package.json +7 -7
package/lib/index.cjs CHANGED
@@ -26,8 +26,8 @@ __export(index_exports, {
26
26
  });
27
27
  module.exports = __toCommonJS(index_exports);
28
28
 
29
- // ../../packages/core/lib/CoreFactory.js
30
- var CoreFactory = class {
29
+ // ../../packages/core/lib/AstCoreFactory.js
30
+ var AstCoreFactory = class {
31
31
  wrap(val, loc) {
32
32
  return { val, loc };
33
33
  }
@@ -9371,6 +9371,15 @@ var EmbeddedActionsParser = class extends Parser {
9371
9371
  }
9372
9372
  };
9373
9373
 
9374
+ // ../../packages/core/lib/utils.js
9375
+ function unCapitalize(str2) {
9376
+ return str2.charAt(0).toLowerCase() + str2.slice(1);
9377
+ }
9378
+ function createToken2(config) {
9379
+ return createToken(config);
9380
+ }
9381
+ var traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
9382
+
9374
9383
  // ../../packages/core/lib/lexer-builder/LexerBuilder.js
9375
9384
  var LexerBuilder = class _LexerBuilder {
9376
9385
  tokens;
@@ -9733,16 +9742,13 @@ ${firstError.message}`);
9733
9742
  }
9734
9743
  };
9735
9744
 
9736
- // ../../packages/core/lib/utils.js
9737
- function unCapitalize(str2) {
9738
- return str2.charAt(0).toLowerCase() + str2.slice(1);
9739
- }
9740
- function createToken2(config) {
9741
- return createToken(config);
9742
- }
9743
-
9744
9745
  // ../../packages/core/lib/Transformers.js
9745
9746
  var TransformerType = class {
9747
+ clone(obj) {
9748
+ const newObj = Object.create(Object.getPrototypeOf(obj));
9749
+ Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
9750
+ return newObj;
9751
+ }
9746
9752
  safeObjectVisit(value, mapper) {
9747
9753
  if (value && typeof value === "object") {
9748
9754
  if (Array.isArray(value)) {
@@ -9752,104 +9758,213 @@ var TransformerType = class {
9752
9758
  }
9753
9759
  return value;
9754
9760
  }
9755
- transformNode(curObject, nodeCallBacks) {
9756
- let continueCheck;
9757
- let transformation;
9758
- const casted = curObject;
9759
- if (casted.type) {
9760
- continueCheck = nodeCallBacks[casted.type]?.continue;
9761
- transformation = nodeCallBacks[casted.type]?.transform;
9762
- }
9763
- let shouldContinue = true;
9764
- if (continueCheck) {
9765
- shouldContinue = continueCheck(curObject);
9766
- }
9767
- if (!shouldContinue) {
9768
- return curObject;
9769
- }
9770
- const copy3 = { ...curObject };
9771
- for (const [key, value] of Object.entries(copy3)) {
9772
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
9773
- }
9774
- if (transformation) {
9775
- return transformation(copy3);
9776
- }
9777
- return copy3;
9761
+ /**
9762
+ * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
9763
+ * @param startObject object to start iterating from
9764
+ * @param mapper mapper to transform the various objects - argument is a copy of the original
9765
+ * @param preVisitor callback that is evaluated before iterating deeper.
9766
+ * If continues is false, we do not iterate deeper, current object is still mapped. - default: true
9767
+ * If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
9768
+ * - Default false
9769
+ */
9770
+ transformObject(startObject, mapper, preVisitor = () => ({})) {
9771
+ let didShortCut = false;
9772
+ const recurse = (curObject) => {
9773
+ const copy3 = this.clone(curObject);
9774
+ const context = preVisitor(copy3);
9775
+ didShortCut = context.shortcut ?? false;
9776
+ const continues = context.continue ?? true;
9777
+ if (continues && !didShortCut) {
9778
+ for (const [key, value] of Object.entries(copy3)) {
9779
+ if (didShortCut) {
9780
+ return copy3;
9781
+ }
9782
+ copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
9783
+ }
9784
+ }
9785
+ return mapper(copy3);
9786
+ };
9787
+ return recurse(startObject);
9778
9788
  }
9779
- visitNode(curObject, nodeCallBacks) {
9780
- let callback;
9781
- const casted = curObject;
9782
- if (casted.type) {
9783
- callback = nodeCallBacks[casted.type];
9784
- }
9785
- let shouldIterate = true;
9786
- if (callback) {
9787
- shouldIterate = callback(curObject);
9788
- }
9789
- if (shouldIterate) {
9790
- for (const value of Object.values(curObject)) {
9791
- this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
9789
+ /**
9790
+ * Visitor that visits all objects. Visits deeper objects first.
9791
+ */
9792
+ visitObject(startObject, visitor, preVisitor = () => ({})) {
9793
+ let didShortCut = false;
9794
+ const recurse = (curObject) => {
9795
+ const context = preVisitor(curObject);
9796
+ didShortCut = context.shortcut ?? false;
9797
+ const continues = context.continue ?? true;
9798
+ if (continues && !didShortCut) {
9799
+ for (const value of Object.values(curObject)) {
9800
+ if (didShortCut) {
9801
+ return;
9802
+ }
9803
+ this.safeObjectVisit(value, (obj) => recurse(obj));
9804
+ }
9792
9805
  }
9793
- }
9806
+ visitor(curObject);
9807
+ };
9808
+ recurse(startObject);
9809
+ }
9810
+ transformNode(startObject, nodeCallBacks) {
9811
+ const transformWrapper = (curObject) => {
9812
+ const casted = curObject;
9813
+ if (casted.type) {
9814
+ const ogFunc = nodeCallBacks[casted.type]?.transform;
9815
+ if (ogFunc) {
9816
+ return ogFunc(casted);
9817
+ }
9818
+ }
9819
+ return curObject;
9820
+ };
9821
+ const preTransformWrapper = (curObject) => {
9822
+ const casted = curObject;
9823
+ if (casted.type) {
9824
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9825
+ if (ogFunc) {
9826
+ return ogFunc(casted);
9827
+ }
9828
+ }
9829
+ return {};
9830
+ };
9831
+ return this.transformObject(startObject, transformWrapper, preTransformWrapper);
9832
+ }
9833
+ visitNode(startObject, nodeCallBacks) {
9834
+ const visitWrapper = (curObject) => {
9835
+ const casted = curObject;
9836
+ if (casted.type) {
9837
+ const ogFunc = nodeCallBacks[casted.type]?.visitor;
9838
+ if (ogFunc) {
9839
+ ogFunc(casted);
9840
+ }
9841
+ }
9842
+ };
9843
+ const preVisitWrapper = (curObject) => {
9844
+ const casted = curObject;
9845
+ if (casted.type) {
9846
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9847
+ if (ogFunc) {
9848
+ return ogFunc(casted);
9849
+ }
9850
+ }
9851
+ return {};
9852
+ };
9853
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9854
+ }
9855
+ traverseNodes(currentNode, traverse) {
9856
+ let didShortCut = false;
9857
+ const recurse = (curNode) => {
9858
+ const traverser = traverse[curNode.type];
9859
+ if (traverser) {
9860
+ const { next, shortcut } = traverser(curNode);
9861
+ didShortCut = shortcut ?? false;
9862
+ if (!didShortCut) {
9863
+ for (const node of next ?? []) {
9864
+ if (didShortCut) {
9865
+ return;
9866
+ }
9867
+ recurse(node);
9868
+ }
9869
+ }
9870
+ }
9871
+ };
9872
+ recurse(currentNode);
9794
9873
  }
9795
9874
  };
9796
9875
  var TransformerSubType = class extends TransformerType {
9797
- // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
9798
- // for (const value of Object.values(curObject)) {
9799
- // this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
9800
- // }
9801
- // }
9802
- transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9803
- let continueCheck;
9804
- let transformation;
9805
- const casted = curObject;
9806
- if (casted.type && casted.subType) {
9807
- const specific = nodeSpecificCallBacks[casted.type];
9808
- if (specific) {
9809
- continueCheck = specific[casted.subType]?.continue;
9810
- transformation = specific[casted.subType]?.transform;
9811
- }
9812
- }
9813
- let shouldContinue = true;
9814
- if (continueCheck) {
9815
- shouldContinue = continueCheck(curObject);
9816
- }
9817
- if (!shouldContinue) {
9818
- return curObject;
9819
- }
9820
- const copy3 = { ...curObject };
9821
- for (const [key, value] of Object.entries(copy3)) {
9822
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9823
- }
9824
- if (transformation) {
9825
- return transformation(copy3);
9826
- }
9827
- return copy3;
9876
+ transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9877
+ const transformWrapper = (curObject) => {
9878
+ let ogTransform;
9879
+ const casted = curObject;
9880
+ if (casted.type && casted.subType) {
9881
+ const specific = nodeSpecificCallBacks[casted.type];
9882
+ if (specific) {
9883
+ ogTransform = specific[casted.subType]?.transform;
9884
+ }
9885
+ if (!ogTransform) {
9886
+ ogTransform = nodeCallBacks[casted.type]?.transform;
9887
+ }
9888
+ }
9889
+ return ogTransform ? ogTransform(casted) : curObject;
9890
+ };
9891
+ const preVisitWrapper = (curObject) => {
9892
+ let ogPreVisit;
9893
+ const casted = curObject;
9894
+ if (casted.type && casted.subType) {
9895
+ const specific = nodeSpecificCallBacks[casted.type];
9896
+ if (specific) {
9897
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9898
+ }
9899
+ if (!ogPreVisit) {
9900
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9901
+ }
9902
+ }
9903
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9904
+ };
9905
+ return this.transformObject(startObject, transformWrapper, preVisitWrapper);
9828
9906
  }
9829
9907
  /**
9830
9908
  * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
9831
9909
  */
9832
- visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9833
- let callback;
9834
- const casted = curObject;
9835
- if (casted.type && casted.subType) {
9836
- const specific = nodeSpecificCallBacks[casted.type];
9837
- if (specific) {
9838
- callback = specific[casted.subType];
9910
+ visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9911
+ const visitWrapper = (curObject) => {
9912
+ let ogTransform;
9913
+ const casted = curObject;
9914
+ if (casted.type && casted.subType) {
9915
+ const specific = nodeSpecificCallBacks[casted.type];
9916
+ if (specific) {
9917
+ ogTransform = specific[casted.subType]?.visitor;
9918
+ }
9919
+ if (!ogTransform) {
9920
+ ogTransform = nodeCallBacks[casted.type]?.visitor;
9921
+ }
9839
9922
  }
9840
- }
9841
- if (!callback && casted.type) {
9842
- callback = nodeCallBacks[curObject.type];
9843
- }
9844
- let shouldIterate = true;
9845
- if (callback) {
9846
- shouldIterate = callback(curObject) ?? true;
9847
- }
9848
- if (shouldIterate) {
9849
- for (const value of Object.values(curObject)) {
9850
- this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9923
+ if (ogTransform) {
9924
+ ogTransform(casted);
9851
9925
  }
9852
- }
9926
+ };
9927
+ const preVisitWrapper = (curObject) => {
9928
+ let ogPreVisit;
9929
+ const casted = curObject;
9930
+ if (casted.type && casted.subType) {
9931
+ const specific = nodeSpecificCallBacks[casted.type];
9932
+ if (specific) {
9933
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9934
+ }
9935
+ if (!ogPreVisit) {
9936
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9937
+ }
9938
+ }
9939
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9940
+ };
9941
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9942
+ }
9943
+ traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
9944
+ let didShortCut = false;
9945
+ const recurse = (curNode) => {
9946
+ let traverser;
9947
+ const subObj = traverseSubNode[curNode.type];
9948
+ if (subObj) {
9949
+ traverser = subObj[curNode.subType];
9950
+ }
9951
+ if (!traverser) {
9952
+ traverser = traverseNode[curNode.type];
9953
+ }
9954
+ if (traverser) {
9955
+ const { next, shortcut } = traverser(curNode);
9956
+ didShortCut = shortcut ?? false;
9957
+ if (!didShortCut) {
9958
+ for (const node of next ?? []) {
9959
+ if (didShortCut) {
9960
+ return;
9961
+ }
9962
+ recurse(node);
9963
+ }
9964
+ }
9965
+ }
9966
+ };
9967
+ recurse(currentNode);
9853
9968
  }
9854
9969
  };
9855
9970
 
@@ -11247,8 +11362,8 @@ function UpdateOperationFactoryMixin(Base) {
11247
11362
  };
11248
11363
  }
11249
11364
 
11250
- // ../../packages/rules-sparql-1-1/lib/factory.js
11251
- 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() {
11365
+ // ../../packages/rules-sparql-1-1/lib/astFactory.js
11366
+ 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() {
11252
11367
  alwaysSparql11(obj) {
11253
11368
  return true;
11254
11369
  }
@@ -11363,12 +11478,12 @@ var CommonIRIs;
11363
11478
  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
11364
11479
  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
11365
11480
  })(CommonIRIs || (CommonIRIs = {}));
11366
- var TransformerSparql11 = class extends TransformerSubType {
11481
+ var AstTransformer = class extends TransformerSubType {
11367
11482
  };
11368
11483
 
11369
11484
  // ../../packages/rules-sparql-1-1/lib/validation/validators.js
11370
- var F = new Factory();
11371
- var transformer = new TransformerSparql11();
11485
+ var F = new AstFactory();
11486
+ var transformer = new AstTransformer();
11372
11487
  function getAggregatesOfExpression(expression2) {
11373
11488
  if (F.isExpressionAggregate(expression2)) {
11374
11489
  return [expression2];
@@ -11447,77 +11562,69 @@ function queryIsGood(query2) {
11447
11562
  }
11448
11563
  }
11449
11564
  }
11565
+ function notUndefined(some2) {
11566
+ return some2 !== void 0;
11567
+ }
11450
11568
  function findPatternBoundedVars(iter, boundedVars) {
11451
- if (F.isQuery(iter) || F.isUpdate(iter)) {
11452
- if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
11453
- if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
11454
- findPatternBoundedVars(iter.where, boundedVars);
11455
- } else {
11456
- for (const v of iter.variables) {
11457
- findPatternBoundedVars(v, boundedVars);
11458
- }
11459
- }
11460
- if (iter.solutionModifiers.group) {
11461
- const grouping = iter.solutionModifiers.group;
11462
- for (const g of grouping.groupings) {
11463
- if ("variable" in g) {
11464
- findPatternBoundedVars(g.variable, boundedVars);
11465
- }
11466
- }
11467
- }
11468
- if (iter.values?.values && iter.values.values.length > 0) {
11469
- const values3 = iter.values.values;
11470
- for (const v of Object.keys(values3[0])) {
11569
+ transformer.traverseSubNodes(iter, {
11570
+ query: (op) => ({ next: [
11571
+ op.solutionModifiers.group
11572
+ ].filter(notUndefined) }),
11573
+ triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
11574
+ path: (op) => ({ next: op.items }),
11575
+ tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
11576
+ }, {
11577
+ query: {
11578
+ select: (op) => ({ next: [
11579
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11580
+ op.solutionModifiers.group,
11581
+ op.values
11582
+ ].filter(notUndefined) }),
11583
+ describe: (op) => ({ next: [
11584
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11585
+ op.solutionModifiers.group,
11586
+ op.values
11587
+ ].filter(notUndefined) })
11588
+ },
11589
+ solutionModifier: {
11590
+ group: (op) => ({
11591
+ next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
11592
+ }),
11593
+ having: (op) => ({ next: op.having }),
11594
+ order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
11595
+ },
11596
+ pattern: {
11597
+ values: (op) => {
11598
+ for (const v of Object.keys(op.values.at(0) ?? {})) {
11471
11599
  boundedVars.add(v);
11472
11600
  }
11601
+ return {};
11602
+ },
11603
+ bgp: (op) => ({ next: op.triples }),
11604
+ group: (op) => ({ next: op.patterns }),
11605
+ union: (op) => ({ next: op.patterns }),
11606
+ optional: (op) => ({ next: op.patterns }),
11607
+ service: (op) => ({ next: [op.name, ...op.patterns] }),
11608
+ bind: (op) => ({ next: [op.variable] }),
11609
+ graph: (op) => ({ next: [op.name, ...op.patterns] }),
11610
+ minus: (op) => ({ next: op.patterns.slice(0, 1) })
11611
+ },
11612
+ term: {
11613
+ variable: (op) => {
11614
+ boundedVars.add(op.value);
11615
+ return {};
11473
11616
  }
11474
11617
  }
11475
- } else if (F.isTerm(iter)) {
11476
- if (F.isTermVariable(iter)) {
11477
- boundedVars.add(iter.value);
11478
- }
11479
- } else if (F.isTriple(iter)) {
11480
- findPatternBoundedVars(iter.subject, boundedVars);
11481
- findPatternBoundedVars(iter.predicate, boundedVars);
11482
- findPatternBoundedVars(iter.object, boundedVars);
11483
- } else if (F.isPath(iter)) {
11484
- if (!F.isTerm(iter)) {
11485
- for (const item of iter.items) {
11486
- findPatternBoundedVars(item, boundedVars);
11487
- }
11488
- }
11489
- } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
11490
- for (const triple of iter.triples) {
11491
- findPatternBoundedVars(triple, boundedVars);
11492
- }
11493
- } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
11494
- for (const pattern of iter.patterns) {
11495
- findPatternBoundedVars(pattern, boundedVars);
11496
- }
11497
- if (F.isPatternService(iter)) {
11498
- findPatternBoundedVars(iter.name, boundedVars);
11499
- }
11500
- } else if (F.isPatternBind(iter)) {
11501
- findPatternBoundedVars(iter.variable, boundedVars);
11502
- } else if (F.isPatternValues(iter)) {
11503
- for (const variable of Object.keys(iter.values.at(0) ?? {})) {
11504
- boundedVars.add(variable);
11505
- }
11506
- } else if (F.isPatternGraph(iter)) {
11507
- findPatternBoundedVars(iter.name, boundedVars);
11508
- for (const pattern of iter.patterns) {
11509
- findPatternBoundedVars(pattern, boundedVars);
11510
- }
11511
- }
11618
+ });
11512
11619
  }
11513
11620
  function checkNote13(patterns) {
11514
11621
  for (const [index, pattern] of patterns.entries()) {
11515
11622
  if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
11516
11623
  const bgp = patterns[index - 1];
11517
11624
  const variables = [];
11518
- transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
11625
+ transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
11519
11626
  variables.push(var_2);
11520
- } } });
11627
+ } } } });
11521
11628
  if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
11522
11629
  throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
11523
11630
  }
@@ -11543,12 +11650,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
11543
11650
  const operation = update2.operation;
11544
11651
  if (operation.subType === "insertdata") {
11545
11652
  const blankNodesHere = /* @__PURE__ */ new Set();
11546
- transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
11653
+ transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
11547
11654
  blankNodesHere.add(blankNode2.label);
11548
11655
  if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
11549
11656
  throw new Error("Detected reuse blank node across different INSERT DATA clauses");
11550
11657
  }
11551
- } } });
11658
+ } } } });
11552
11659
  for (const blankNode2 of blankNodesHere) {
11553
11660
  blankLabelsUsedInInsertData.add(blankNode2);
11554
11661
  }
@@ -11587,22 +11694,22 @@ var rdfLiteral = {
11587
11694
  return OPTION(() => OR([
11588
11695
  { ALT: () => {
11589
11696
  const lang2 = CONSUME(terminals_exports.langTag);
11590
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11697
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11591
11698
  } },
11592
11699
  { ALT: () => {
11593
11700
  CONSUME(symbols_exports.hathat);
11594
11701
  const iriVal = SUBRULE1(iri2);
11595
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
11702
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
11596
11703
  } }
11597
11704
  ])) ?? value;
11598
11705
  },
11599
- gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { factory }) => {
11600
- factory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11706
+ gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { astFactory }) => {
11707
+ astFactory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11601
11708
  if (ast.langOrIri) {
11602
11709
  if (typeof ast.langOrIri === "string") {
11603
- factory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11710
+ astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11604
11711
  } else {
11605
- factory.printFilter(ast, () => PRINT("^^"));
11712
+ astFactory.printFilter(ast, () => PRINT("^^"));
11606
11713
  SUBRULE(iri2, ast.langOrIri);
11607
11714
  }
11608
11715
  }
@@ -11624,7 +11731,7 @@ var numericLiteralUnsigned = {
11624
11731
  { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
11625
11732
  { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
11626
11733
  ]);
11627
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11734
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11628
11735
  }
11629
11736
  };
11630
11737
  var numericLiteralPositive = {
@@ -11635,7 +11742,7 @@ var numericLiteralPositive = {
11635
11742
  { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
11636
11743
  { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
11637
11744
  ]);
11638
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11745
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11639
11746
  }
11640
11747
  };
11641
11748
  var numericLiteralNegative = {
@@ -11646,7 +11753,7 @@ var numericLiteralNegative = {
11646
11753
  { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
11647
11754
  { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
11648
11755
  ]);
11649
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11756
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11650
11757
  }
11651
11758
  };
11652
11759
  var booleanLiteral = {
@@ -11656,7 +11763,7 @@ var booleanLiteral = {
11656
11763
  { ALT: () => CONSUME(true_) },
11657
11764
  { ALT: () => CONSUME(false_) }
11658
11765
  ]);
11659
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(token), token.image.toLowerCase(), C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11766
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11660
11767
  }
11661
11768
  };
11662
11769
  var string = {
@@ -11681,7 +11788,7 @@ var string = {
11681
11788
  } }
11682
11789
  ]);
11683
11790
  return ACTION(() => {
11684
- const F2 = C.factory;
11791
+ const F2 = C.astFactory;
11685
11792
  const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
11686
11793
  switch (char) {
11687
11794
  case "t":
@@ -11708,16 +11815,16 @@ var iri2 = {
11708
11815
  { ALT: () => SUBRULE(iriFull) },
11709
11816
  { ALT: () => SUBRULE(prefixedName) }
11710
11817
  ]),
11711
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => F2.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11818
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => F2.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11712
11819
  };
11713
11820
  var iriFull = {
11714
11821
  name: "iriFull",
11715
11822
  impl: ({ ACTION, CONSUME }) => (C) => {
11716
11823
  const iriToken = CONSUME(terminals_exports.iriRef);
11717
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11824
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11718
11825
  },
11719
- gImpl: ({ PRINT }) => (ast, { factory }) => {
11720
- factory.printFilter(ast, () => PRINT("<", ast.value, ">"));
11826
+ gImpl: ({ PRINT }) => (ast, { astFactory: F2 }) => {
11827
+ F2.printFilter(ast, () => PRINT("<", ast.value, ">"));
11721
11828
  }
11722
11829
  };
11723
11830
  var prefixedName = {
@@ -11727,16 +11834,16 @@ var prefixedName = {
11727
11834
  const longName = CONSUME(terminals_exports.pNameLn);
11728
11835
  return ACTION(() => {
11729
11836
  const [prefix, localName] = longName.image.split(":");
11730
- return C.factory.namedNode(C.factory.sourceLocation(longName), localName, prefix);
11837
+ return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
11731
11838
  });
11732
11839
  } },
11733
11840
  { ALT: () => {
11734
11841
  const shortName = CONSUME(terminals_exports.pNameNs);
11735
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11842
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11736
11843
  } }
11737
11844
  ]),
11738
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11739
- factory.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11845
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11846
+ F2.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11740
11847
  }
11741
11848
  };
11742
11849
  var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11746,11 +11853,11 @@ var blankNode = {
11746
11853
  const result = OR([
11747
11854
  { ALT: () => {
11748
11855
  const labelToken = CONSUME(terminals_exports.blankNodeLabel);
11749
- return ACTION(() => C.factory.blankNode(labelToken.image.slice(2), C.factory.sourceLocation(labelToken)));
11856
+ return ACTION(() => C.astFactory.blankNode(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
11750
11857
  } },
11751
11858
  { ALT: () => {
11752
11859
  const anonToken = CONSUME(terminals_exports.anon);
11753
- return ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocation(anonToken)));
11860
+ return ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocation(anonToken)));
11754
11861
  } }
11755
11862
  ]);
11756
11863
  ACTION(() => {
@@ -11760,15 +11867,15 @@ var blankNode = {
11760
11867
  });
11761
11868
  return result;
11762
11869
  },
11763
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11764
- factory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11870
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory }) => {
11871
+ astFactory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11765
11872
  }
11766
11873
  };
11767
11874
  var verbA = {
11768
11875
  name: "VerbA",
11769
11876
  impl: ({ ACTION, CONSUME }) => (C) => {
11770
11877
  const token = CONSUME(a);
11771
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11878
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11772
11879
  }
11773
11880
  };
11774
11881
 
@@ -11785,7 +11892,7 @@ var prologue = {
11785
11892
  ]));
11786
11893
  return result;
11787
11894
  },
11788
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11895
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11789
11896
  for (const context of ast) {
11790
11897
  if (F2.isContextDefinitionBase(context)) {
11791
11898
  SUBRULE(baseDecl2, context);
@@ -11800,11 +11907,12 @@ var baseDecl2 = {
11800
11907
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
11801
11908
  const base = CONSUME(baseDecl);
11802
11909
  const val = SUBRULE(iriFull);
11803
- return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
11910
+ return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
11804
11911
  },
11805
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
11912
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11806
11913
  F2.printFilter(ast, () => PRINT_WORD("BASE"));
11807
11914
  SUBRULE(iri2, ast.value);
11915
+ F2.printFilter(ast, () => PRINT_WORD("\n"));
11808
11916
  }
11809
11917
  };
11810
11918
  var prefixDecl2 = {
@@ -11813,13 +11921,14 @@ var prefixDecl2 = {
11813
11921
  const prefix = CONSUME(prefixDecl);
11814
11922
  const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
11815
11923
  const value = SUBRULE(iriFull);
11816
- return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
11924
+ return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
11817
11925
  },
11818
- gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F2 }) => {
11926
+ gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F2 }) => {
11819
11927
  F2.printFilter(ast, () => {
11820
11928
  PRINT_WORDS("PREFIX", `${ast.key}:`);
11821
11929
  });
11822
11930
  SUBRULE(iri2, ast.value);
11931
+ F2.printFilter(ast, () => PRINT_WORDS("\n"));
11823
11932
  }
11824
11933
  };
11825
11934
  var verb = {
@@ -11835,7 +11944,7 @@ var varOrTerm = {
11835
11944
  { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
11836
11945
  { ALT: () => SUBRULE(graphTerm) }
11837
11946
  ]),
11838
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11947
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11839
11948
  if (F2.isTermVariable(ast)) {
11840
11949
  return SUBRULE(var_, ast);
11841
11950
  }
@@ -11856,9 +11965,9 @@ var var_ = {
11856
11965
  { ALT: () => CONSUME(terminals_exports.var1) },
11857
11966
  { ALT: () => CONSUME(terminals_exports.var2) }
11858
11967
  ]);
11859
- return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
11968
+ return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
11860
11969
  },
11861
- gImpl: ({ PRINT_WORD }) => (ast, { factory: F2 }) => {
11970
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11862
11971
  F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
11863
11972
  }
11864
11973
  };
@@ -11872,10 +11981,10 @@ var graphTerm = {
11872
11981
  { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
11873
11982
  { ALT: () => {
11874
11983
  const tokenNil = CONSUME(terminals_exports.nil);
11875
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
11984
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
11876
11985
  } }
11877
11986
  ]),
11878
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
11987
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
11879
11988
  if (F2.isTermNamed(ast)) {
11880
11989
  SUBRULE(iri2, ast);
11881
11990
  } else if (F2.isTermLiteral(ast)) {
@@ -11895,14 +12004,14 @@ function datasetClauseUsing(name, token) {
11895
12004
  return OR([
11896
12005
  { ALT: () => {
11897
12006
  const iri3 = SUBRULE(defaultGraphClause);
11898
- return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
12007
+ return ACTION(() => C.astFactory.wrap({ clauseType: "default", value: iri3 }, C.astFactory.sourceLocation(start, iri3)));
11899
12008
  } },
11900
12009
  { ALT: () => {
11901
12010
  const namedClause = SUBRULE(namedGraphClause);
11902
- return ACTION(() => C.factory.wrap({
12011
+ return ACTION(() => C.astFactory.wrap({
11903
12012
  clauseType: "named",
11904
12013
  value: namedClause.val
11905
- }, C.factory.sourceLocation(start, namedClause)));
12014
+ }, C.astFactory.sourceLocation(start, namedClause)));
11906
12015
  } }
11907
12016
  ]);
11908
12017
  }
@@ -11923,9 +12032,9 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
11923
12032
  const clause = SUBRULE(subRule);
11924
12033
  clauses.push(clause);
11925
12034
  });
11926
- return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
12035
+ return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
11927
12036
  },
11928
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12037
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
11929
12038
  for (const clause of ast.clauses) {
11930
12039
  F2.printFilter(ast, () => PRINT_WORD(fromUsing));
11931
12040
  if (clause.clauseType === "named") {
@@ -11943,7 +12052,7 @@ var namedGraphClause = {
11943
12052
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
11944
12053
  const named2 = CONSUME(graph_exports.named);
11945
12054
  const iri3 = SUBRULE(sourceSelector);
11946
- return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
12055
+ return ACTION(() => C.astFactory.wrap(iri3, C.astFactory.sourceLocation(named2, iri3)));
11947
12056
  }
11948
12057
  };
11949
12058
  var sourceSelector = {
@@ -11960,7 +12069,7 @@ function funcExpr1(func) {
11960
12069
  CONSUME(symbols_exports.LParen);
11961
12070
  const arg = SUBRULE(expression);
11962
12071
  const close = CONSUME(symbols_exports.RParen);
11963
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12072
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
11964
12073
  }
11965
12074
  };
11966
12075
  }
@@ -11974,7 +12083,7 @@ function funcExpr2(func) {
11974
12083
  CONSUME(symbols_exports.comma);
11975
12084
  const arg2 = SUBRULE2(expression);
11976
12085
  const close = CONSUME(symbols_exports.RParen);
11977
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
12086
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
11978
12087
  }
11979
12088
  };
11980
12089
  }
@@ -11990,7 +12099,7 @@ function funcExpr3(func) {
11990
12099
  CONSUME2(symbols_exports.comma);
11991
12100
  const arg3 = SUBRULE3(expression);
11992
12101
  const close = CONSUME(symbols_exports.RParen);
11993
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
12102
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
11994
12103
  }
11995
12104
  };
11996
12105
  }
@@ -12002,7 +12111,7 @@ function funcVar1(func) {
12002
12111
  CONSUME(symbols_exports.LParen);
12003
12112
  const arg = SUBRULE(var_);
12004
12113
  const close = CONSUME(symbols_exports.RParen);
12005
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12114
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
12006
12115
  }
12007
12116
  };
12008
12117
  }
@@ -12016,11 +12125,11 @@ function funcExprOrNil1(func) {
12016
12125
  CONSUME(symbols_exports.LParen);
12017
12126
  const arg = SUBRULE(expression);
12018
12127
  const close = CONSUME(symbols_exports.RParen);
12019
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12128
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
12020
12129
  } },
12021
12130
  { ALT: () => {
12022
12131
  const nil2 = CONSUME(terminals_exports.nil);
12023
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
12132
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
12024
12133
  } }
12025
12134
  ]);
12026
12135
  }
@@ -12032,7 +12141,7 @@ function funcNil1(func) {
12032
12141
  impl: ({ ACTION, CONSUME }) => (C) => {
12033
12142
  const operator = CONSUME(func);
12034
12143
  const nil2 = CONSUME(terminals_exports.nil);
12035
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
12144
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
12036
12145
  }
12037
12146
  };
12038
12147
  }
@@ -12042,7 +12151,7 @@ function funcExprList1(func) {
12042
12151
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
12043
12152
  const operator = CONSUME(func);
12044
12153
  const args = SUBRULE(expressionList);
12045
- return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
12154
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, args.val, C.astFactory.sourceLocation(operator, args)));
12046
12155
  }
12047
12156
  };
12048
12157
  }
@@ -12060,7 +12169,7 @@ function funcExpr2or3(func) {
12060
12169
  return SUBRULE3(expression);
12061
12170
  });
12062
12171
  const close = CONSUME(symbols_exports.RParen);
12063
- return ACTION(() => C.factory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.factory.sourceLocation(operator, close)));
12172
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
12064
12173
  }
12065
12174
  };
12066
12175
  }
@@ -12080,7 +12189,7 @@ function funcExpr3or4(func) {
12080
12189
  return SUBRULE4(expression);
12081
12190
  });
12082
12191
  const close = CONSUME(symbols_exports.RParen);
12083
- return ACTION(() => C.factory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
12192
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
12084
12193
  }
12085
12194
  };
12086
12195
  }
@@ -12090,7 +12199,7 @@ function funcGroupGraphPattern(func) {
12090
12199
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12091
12200
  const operator = CONSUME(func);
12092
12201
  const group = SUBRULE(groupGraphPattern);
12093
- return ACTION(() => C.factory.expressionPatternOperation(operator.image, group, C.factory.sourceLocation(operator, group)));
12202
+ return ACTION(() => C.astFactory.expressionPatternOperation(operator.image, group, C.astFactory.sourceLocation(operator, group)));
12094
12203
  }
12095
12204
  };
12096
12205
  }
@@ -12103,7 +12212,7 @@ function baseAggregateFunc(func) {
12103
12212
  const distinct2 = OPTION(() => CONSUME(distinct));
12104
12213
  const expr1 = SUBRULE(expression);
12105
12214
  const close = CONSUME(symbols_exports.RParen);
12106
- return ACTION(() => C.factory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.factory.sourceLocation(operator, close)));
12215
+ return ACTION(() => C.astFactory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.astFactory.sourceLocation(operator, close)));
12107
12216
  }
12108
12217
  };
12109
12218
  }
@@ -12243,17 +12352,17 @@ var aggregateCount = {
12243
12352
  const expressionVal = OR([
12244
12353
  { ALT: () => {
12245
12354
  const starToken = CONSUME(symbols_exports.star);
12246
- return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
12355
+ return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
12247
12356
  } },
12248
12357
  { ALT: () => SUBRULE(expression) }
12249
12358
  ]);
12250
12359
  const closeToken = CONSUME(symbols_exports.RParen);
12251
12360
  return ACTION(() => {
12252
- const F2 = C.factory;
12253
- if (C.factory.isWildcard(expressionVal)) {
12254
- return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12361
+ const F2 = C.astFactory;
12362
+ if (C.astFactory.isWildcard(expressionVal)) {
12363
+ return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
12255
12364
  }
12256
- return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12365
+ return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
12257
12366
  });
12258
12367
  }
12259
12368
  };
@@ -12277,7 +12386,7 @@ var aggregateGroup_concat = {
12277
12386
  });
12278
12387
  const closeToken = CONSUME(symbols_exports.RParen);
12279
12388
  return ACTION(() => {
12280
- const F2 = C.factory;
12389
+ const F2 = C.astFactory;
12281
12390
  return F2.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F2.sourceLocation(operatorToken, closeToken));
12282
12391
  });
12283
12392
  }
@@ -12307,7 +12416,7 @@ var aggregate = {
12307
12416
  });
12308
12417
  return result;
12309
12418
  },
12310
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12419
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12311
12420
  F2.printFilter(ast, () => {
12312
12421
  PRINT_WORD(ast.aggregation.toUpperCase(), "(");
12313
12422
  if (ast.distinct) {
@@ -12334,7 +12443,7 @@ var path = {
12334
12443
  };
12335
12444
  var pathGenerator = {
12336
12445
  name: "path",
12337
- gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F2 }, braces = true) => {
12446
+ gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F2 }, braces = true) => {
12338
12447
  if (F2.isTerm(ast) && F2.isTermNamed(ast)) {
12339
12448
  SUBRULE(iri2, ast);
12340
12449
  } else {
@@ -12383,7 +12492,7 @@ function pathChainHelper(name, SEP, subType, subRule) {
12383
12492
  tailEnd = SUBRULE2(subRule);
12384
12493
  tail.push(tailEnd);
12385
12494
  });
12386
- return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
12495
+ return ACTION(() => tail.length === 0 ? head2 : C.astFactory.path(subType, [head2, ...tail], C.astFactory.sourceLocation(head2, tailEnd)));
12387
12496
  }
12388
12497
  };
12389
12498
  }
@@ -12394,7 +12503,7 @@ var pathEltOrInverse = {
12394
12503
  { ALT: () => {
12395
12504
  const hat2 = CONSUME(symbols_exports.hat);
12396
12505
  const item = SUBRULE2(pathElt);
12397
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12506
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12398
12507
  } }
12399
12508
  ])
12400
12509
  };
@@ -12405,7 +12514,7 @@ var pathElt = {
12405
12514
  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
12406
12515
  const item = SUBRULE(pathPrimary);
12407
12516
  const modification = OPTION(() => SUBRULE(pathMod));
12408
- return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
12517
+ return ACTION(() => modification === void 0 ? item : C.astFactory.path(modification.image, [item], C.astFactory.sourceLocation(item, modification)));
12409
12518
  }
12410
12519
  };
12411
12520
  var pathMod = {
@@ -12437,7 +12546,7 @@ var pathNegatedPropertySet = {
12437
12546
  return OR([
12438
12547
  { ALT: () => {
12439
12548
  const noAlternative = SUBRULE1(pathOneInPropertySet);
12440
- return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
12549
+ return ACTION(() => C.astFactory.path("!", [noAlternative], C.astFactory.sourceLocation(exclamation2, noAlternative)));
12441
12550
  } },
12442
12551
  { ALT: () => {
12443
12552
  const open = CONSUME(symbols_exports.LParen);
@@ -12450,7 +12559,7 @@ var pathNegatedPropertySet = {
12450
12559
  });
12451
12560
  const close = CONSUME(symbols_exports.RParen);
12452
12561
  return ACTION(() => {
12453
- const F2 = C.factory;
12562
+ const F2 = C.astFactory;
12454
12563
  if (tail.length === 0) {
12455
12564
  return F2.path("!", [head2], F2.sourceLocation(exclamation2, close));
12456
12565
  }
@@ -12471,7 +12580,7 @@ var pathOneInPropertySet = {
12471
12580
  { ALT: () => SUBRULE2(iri2) },
12472
12581
  { ALT: () => SUBRULE2(verbA) }
12473
12582
  ]);
12474
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12583
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12475
12584
  } }
12476
12585
  ])
12477
12586
  };
@@ -12496,33 +12605,35 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
12496
12605
  });
12497
12606
  }
12498
12607
  });
12499
- return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
12608
+ return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
12500
12609
  };
12501
12610
  }
12502
12611
  var triplesBlock = {
12503
12612
  name: "triplesBlock",
12504
12613
  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
12505
- gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F2 }) => {
12614
+ gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F2 }) => {
12506
12615
  for (const [index, triple] of ast.triples.entries()) {
12507
12616
  HANDLE_LOC(triple, () => {
12508
12617
  const nextTriple = ast.triples.at(index);
12509
12618
  if (F2.isTripleCollection(triple)) {
12510
12619
  SUBRULE(graphNodePath, triple);
12511
- F2.printFilter(triple, () => PRINT_WORD("."));
12620
+ F2.printFilter(triple, () => PRINT_WORD(".\n"));
12512
12621
  } else {
12513
12622
  SUBRULE(graphNodePath, triple.subject);
12623
+ F2.printFilter(triple, () => PRINT_WORD(""));
12514
12624
  if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
12515
12625
  SUBRULE(varOrTerm, triple.predicate);
12516
12626
  } else {
12517
12627
  SUBRULE(pathGenerator, triple.predicate, void 0);
12518
12628
  }
12629
+ F2.printFilter(triple, () => PRINT_WORD(""));
12519
12630
  SUBRULE(graphNodePath, triple.object);
12520
12631
  if (nextTriple === void 0 || F2.isTripleCollection(nextTriple) || !F2.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
12521
- F2.printFilter(ast, () => PRINT_WORD("."));
12632
+ F2.printFilter(ast, () => PRINT_WORD(".\n"));
12522
12633
  } else if (F2.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
12523
12634
  F2.printFilter(ast, () => PRINT_WORD(","));
12524
12635
  } else {
12525
- F2.printFilter(ast, () => PRINT_WORD(";"));
12636
+ F2.printFilter(ast, () => PRINT_WORD(";\n"));
12526
12637
  }
12527
12638
  }
12528
12639
  });
@@ -12535,24 +12646,24 @@ function triplesSameSubjectImpl(name, allowPaths) {
12535
12646
  impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
12536
12647
  { ALT: () => {
12537
12648
  const subject = SUBRULE(varOrTerm);
12538
- const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.factory.dematerialized(subject)));
12649
+ const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
12539
12650
  return ACTION(() => {
12540
12651
  if (res.length > 0) {
12541
12652
  res[0].subject = subject;
12542
- res[0].loc = C.factory.sourceLocation(subject, res[0]);
12653
+ res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
12543
12654
  }
12544
12655
  return res;
12545
12656
  });
12546
12657
  } },
12547
12658
  { ALT: () => {
12548
12659
  const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
12549
- const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.factory.graphNodeIdentifier(subjectNode)));
12660
+ const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
12550
12661
  return ACTION(() => {
12551
12662
  if (restNode.length === 0) {
12552
12663
  return [subjectNode];
12553
12664
  }
12554
12665
  restNode[0].subject = subjectNode;
12555
- restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
12666
+ restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
12556
12667
  return restNode;
12557
12668
  });
12558
12669
  } }
@@ -12636,7 +12747,7 @@ function objectImpl(name, allowPaths) {
12636
12747
  name,
12637
12748
  impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
12638
12749
  const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
12639
- return ACTION(() => C.factory.triple(subject, predicate, node));
12750
+ return ACTION(() => C.astFactory.triple(subject, predicate, node));
12640
12751
  }
12641
12752
  };
12642
12753
  }
@@ -12653,7 +12764,7 @@ function collectionImpl(name, allowPaths) {
12653
12764
  });
12654
12765
  const endToken = CONSUME(symbols_exports.RParen);
12655
12766
  return ACTION(() => {
12656
- const F2 = C.factory;
12767
+ const F2 = C.astFactory;
12657
12768
  const triples = [];
12658
12769
  const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
12659
12770
  const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12677,7 +12788,7 @@ function collectionImpl(name, allowPaths) {
12677
12788
  return F2.tripleCollectionList(listHead, triples, F2.sourceLocation(startToken, endToken));
12678
12789
  });
12679
12790
  },
12680
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12791
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12681
12792
  F2.printFilter(ast, () => PRINT_WORD("("));
12682
12793
  for (const [idx, triple] of ast.triples.entries()) {
12683
12794
  if (idx % 2 === 0) {
@@ -12708,13 +12819,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
12708
12819
  name,
12709
12820
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12710
12821
  const startToken = CONSUME(symbols_exports.LSquare);
12711
- const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
12822
+ const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
12712
12823
  const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
12713
12824
  const endToken = CONSUME(symbols_exports.RSquare);
12714
- return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
12825
+ return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
12715
12826
  },
12716
- gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F2 }) => {
12717
- F2.printFilter(ast, () => PRINT("["));
12827
+ gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
12828
+ const { astFactory: F2, indentInc } = c;
12829
+ F2.printFilter(ast, () => {
12830
+ c[traqulaIndentation] += indentInc;
12831
+ PRINT("[\n");
12832
+ });
12718
12833
  for (const triple of ast.triples) {
12719
12834
  HANDLE_LOC(triple, () => {
12720
12835
  if (F2.isTerm(triple.predicate) && F2.isTermVariable(triple.predicate)) {
@@ -12722,11 +12837,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
12722
12837
  } else {
12723
12838
  SUBRULE(pathGenerator, triple.predicate, void 0);
12724
12839
  }
12840
+ F2.printFilter(triple, () => PRINT_WORD(""));
12725
12841
  SUBRULE(graphNodePath, triple.object);
12726
- F2.printFilter(ast, () => PRINT_WORD(";"));
12842
+ F2.printFilter(ast, () => PRINT_WORD(";\n"));
12727
12843
  });
12728
12844
  }
12729
- F2.printFilter(ast, () => PRINT("]"));
12845
+ F2.printFilter(ast, () => {
12846
+ c[traqulaIndentation] -= indentInc;
12847
+ PRINT_ON_EMPTY("]");
12848
+ });
12730
12849
  }
12731
12850
  };
12732
12851
  }
@@ -12743,7 +12862,7 @@ function graphNodeImpl(name, allowPaths) {
12743
12862
  ALT: () => SUBRULE(triplesNodeRule)
12744
12863
  }
12745
12864
  ]),
12746
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
12865
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
12747
12866
  if (F2.isTerm(ast)) {
12748
12867
  SUBRULE(varOrTerm, ast);
12749
12868
  } else {
@@ -12761,9 +12880,9 @@ var whereClause = {
12761
12880
  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
12762
12881
  const where2 = OPTION(() => CONSUME(where));
12763
12882
  const group = SUBRULE(groupGraphPattern);
12764
- return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
12883
+ return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where2, group)));
12765
12884
  },
12766
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12885
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12767
12886
  F2.printFilter(ast, () => PRINT_WORD("WHERE"));
12768
12887
  SUBRULE(groupGraphPattern, ast.val);
12769
12888
  }
@@ -12777,19 +12896,26 @@ var groupGraphPattern = {
12777
12896
  { ALT: () => SUBRULE(groupGraphPatternSub) }
12778
12897
  ]);
12779
12898
  const close = CONSUME(symbols_exports.RCurly);
12780
- return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
12899
+ return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
12781
12900
  },
12782
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
12783
- F2.printFilter(ast, () => PRINT_WORD("{"));
12901
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
12902
+ const { astFactory: F2, indentInc } = C;
12903
+ F2.printFilter(ast, () => {
12904
+ C[traqulaIndentation] += indentInc;
12905
+ PRINT_WORD("{\n");
12906
+ });
12784
12907
  for (const pattern of ast.patterns) {
12785
12908
  SUBRULE(generatePattern, pattern);
12786
12909
  }
12787
- F2.printFilter(ast, () => PRINT_WORD("}"));
12910
+ F2.printFilter(ast, () => {
12911
+ C[traqulaIndentation] -= indentInc;
12912
+ PRINT_ON_EMPTY("}\n");
12913
+ });
12788
12914
  }
12789
12915
  };
12790
12916
  var generatePattern = {
12791
12917
  name: "generatePattern",
12792
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
12918
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
12793
12919
  if (ast.type === "query") {
12794
12920
  SUBRULE(query, F2.querySelect({
12795
12921
  context: [],
@@ -12878,9 +13004,9 @@ var optionalGraphPattern = {
12878
13004
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12879
13005
  const optional2 = CONSUME(optional);
12880
13006
  const group = SUBRULE(groupGraphPattern);
12881
- return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
13007
+ return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional2, group)));
12882
13008
  },
12883
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13009
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12884
13010
  F2.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
12885
13011
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
12886
13012
  }
@@ -12891,9 +13017,9 @@ var graphGraphPattern = {
12891
13017
  const graph2 = CONSUME(graph_exports.graph);
12892
13018
  const name = SUBRULE(varOrIri);
12893
13019
  const group = SUBRULE(groupGraphPattern);
12894
- return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
13020
+ return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph2, group)));
12895
13021
  },
12896
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13022
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12897
13023
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
12898
13024
  SUBRULE(varOrTerm, ast.name);
12899
13025
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
@@ -12909,9 +13035,9 @@ var serviceGraphPattern = {
12909
13035
  }) ?? false;
12910
13036
  const name = SUBRULE1(varOrIri);
12911
13037
  const group = SUBRULE1(groupGraphPattern);
12912
- return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
13038
+ return ACTION(() => C.astFactory.patternService(name, group.patterns, silent2, C.astFactory.sourceLocation(service2, group)));
12913
13039
  },
12914
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13040
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12915
13041
  F2.printFilter(ast, () => {
12916
13042
  PRINT_WORD("SERVICE");
12917
13043
  if (ast.silent) {
@@ -12931,14 +13057,14 @@ var bind2 = {
12931
13057
  CONSUME(as);
12932
13058
  const variable = SUBRULE(var_);
12933
13059
  const close = CONSUME(symbols_exports.RParen);
12934
- return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
13060
+ return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
12935
13061
  },
12936
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13062
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
12937
13063
  F2.printFilter(ast, () => PRINT_WORD("BIND", "("));
12938
13064
  SUBRULE(expression, ast.expression);
12939
13065
  F2.printFilter(ast, () => PRINT_WORD("AS"));
12940
13066
  SUBRULE(var_, ast.variable);
12941
- F2.printFilter(ast, () => PRINT_WORD(")"));
13067
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
12942
13068
  }
12943
13069
  };
12944
13070
  var inlineData = {
@@ -12946,16 +13072,19 @@ var inlineData = {
12946
13072
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12947
13073
  const values3 = CONSUME(values2);
12948
13074
  const datablock = SUBRULE(dataBlock);
12949
- return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
13075
+ return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
12950
13076
  },
12951
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13077
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
13078
+ const { astFactory: F2, indentInc } = C;
12952
13079
  const variables = Object.keys(ast.values.at(0) ?? {});
12953
13080
  F2.printFilter(ast, () => {
13081
+ PRINT_ON_EMPTY("");
12954
13082
  PRINT_WORD("VALUES", "(");
12955
13083
  for (const variable of variables) {
12956
13084
  PRINT_WORD(`?${variable}`);
12957
13085
  }
12958
- PRINT_WORD(")", "{");
13086
+ C[traqulaIndentation] += indentInc;
13087
+ PRINT_WORD(")", "{\n");
12959
13088
  });
12960
13089
  for (const mapping of ast.values) {
12961
13090
  F2.printFilter(ast, () => PRINT_WORD("("));
@@ -12966,9 +13095,12 @@ var inlineData = {
12966
13095
  SUBRULE(graphNodePath, mapping[variable]);
12967
13096
  }
12968
13097
  }
12969
- F2.printFilter(ast, () => PRINT_WORD(")"));
13098
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
12970
13099
  }
12971
- F2.printFilter(ast, () => PRINT_WORD("}"));
13100
+ F2.printFilter(ast, () => {
13101
+ C[traqulaIndentation] -= indentInc;
13102
+ PRINT_ON_EMPTY("}\n");
13103
+ });
12972
13104
  }
12973
13105
  };
12974
13106
  var dataBlock = {
@@ -12991,7 +13123,7 @@ var inlineDataOneVar = {
12991
13123
  });
12992
13124
  });
12993
13125
  const close = CONSUME(symbols_exports.RCurly);
12994
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
13126
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(varVal, close)));
12995
13127
  }
12996
13128
  };
12997
13129
  var inlineDataFull = {
@@ -13008,7 +13140,7 @@ var inlineDataFull = {
13008
13140
  res.push({});
13009
13141
  });
13010
13142
  const close = CONSUME1(symbols_exports.RCurly);
13011
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
13143
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(nil2, close)));
13012
13144
  } },
13013
13145
  { ALT: () => {
13014
13146
  const open = CONSUME1(symbols_exports.LParen);
@@ -13040,7 +13172,7 @@ var inlineDataFull = {
13040
13172
  });
13041
13173
  });
13042
13174
  const close = CONSUME2(symbols_exports.RCurly);
13043
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
13175
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(open, close)));
13044
13176
  } }
13045
13177
  ]);
13046
13178
  }
@@ -13063,9 +13195,9 @@ var minusGraphPattern = {
13063
13195
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13064
13196
  const minus2 = CONSUME(minus);
13065
13197
  const group = SUBRULE(groupGraphPattern);
13066
- return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
13198
+ return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus2, group)));
13067
13199
  },
13068
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13200
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13069
13201
  F2.printFilter(ast, () => PRINT_WORD("MINUS"));
13070
13202
  SUBRULE(groupGraphPattern, F2.patternGroup(ast.patterns, ast.loc));
13071
13203
  }
@@ -13081,9 +13213,9 @@ var groupOrUnionGraphPattern = {
13081
13213
  const group2 = SUBRULE2(groupGraphPattern);
13082
13214
  groups.push(group2);
13083
13215
  });
13084
- return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
13216
+ return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
13085
13217
  },
13086
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13218
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13087
13219
  if (F2.isPatternUnion(ast)) {
13088
13220
  const [head2, ...tail] = ast.patterns;
13089
13221
  SUBRULE(groupGraphPattern, head2);
@@ -13101,12 +13233,12 @@ var filter3 = {
13101
13233
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13102
13234
  const filterToken = CONSUME(filter2);
13103
13235
  const expression2 = SUBRULE(constraint);
13104
- return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
13236
+ return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
13105
13237
  },
13106
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13238
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13107
13239
  F2.printFilter(ast, () => PRINT_WORD("FILTER ("));
13108
13240
  SUBRULE(expression, ast.expression);
13109
- F2.printFilter(ast, () => PRINT_WORD(")"));
13241
+ F2.printFilter(ast, () => PRINT_WORD(")\n"));
13110
13242
  }
13111
13243
  };
13112
13244
  var constraint = {
@@ -13122,7 +13254,7 @@ var functionCall = {
13122
13254
  impl: ({ ACTION, SUBRULE }) => (C) => {
13123
13255
  const func = SUBRULE(iri2);
13124
13256
  const args = SUBRULE(argList);
13125
- return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
13257
+ return ACTION(() => C.astFactory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.astFactory.sourceLocation(func, args)));
13126
13258
  }
13127
13259
  };
13128
13260
 
@@ -13132,7 +13264,7 @@ var argList = {
13132
13264
  impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
13133
13265
  { ALT: () => {
13134
13266
  const nil2 = CONSUME(terminals_exports.nil);
13135
- return ACTION(() => C.factory.wrap({ args: [], distinct: false }, C.factory.sourceLocation(nil2)));
13267
+ return ACTION(() => C.astFactory.wrap({ args: [], distinct: false }, C.astFactory.sourceLocation(nil2)));
13136
13268
  } },
13137
13269
  { ALT: () => {
13138
13270
  const args = [];
@@ -13149,10 +13281,10 @@ var argList = {
13149
13281
  }
13150
13282
  });
13151
13283
  const close = CONSUME(symbols_exports.RParen);
13152
- return ACTION(() => C.factory.wrap({ args, distinct: distinct2 }, C.factory.sourceLocation(open, close)));
13284
+ return ACTION(() => C.astFactory.wrap({ args, distinct: distinct2 }, C.astFactory.sourceLocation(open, close)));
13153
13285
  } }
13154
13286
  ]),
13155
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13287
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13156
13288
  F2.printFilter(ast, () => {
13157
13289
  PRINT_WORD("(");
13158
13290
  if (ast.val.distinct) {
@@ -13175,7 +13307,7 @@ var expressionList = {
13175
13307
  impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => (C) => OR([
13176
13308
  { ALT: () => {
13177
13309
  const nil2 = CONSUME(terminals_exports.nil);
13178
- return ACTION(() => C.factory.wrap([], C.factory.sourceLocation(nil2)));
13310
+ return ACTION(() => C.astFactory.wrap([], C.astFactory.sourceLocation(nil2)));
13179
13311
  } },
13180
13312
  { ALT: () => {
13181
13313
  const open = CONSUME(symbols_exports.LParen);
@@ -13187,7 +13319,7 @@ var expressionList = {
13187
13319
  args.push(expr);
13188
13320
  });
13189
13321
  const close = CONSUME(symbols_exports.RParen);
13190
- return ACTION(() => C.factory.wrap(args, C.factory.sourceLocation(open, close)));
13322
+ return ACTION(() => C.astFactory.wrap(args, C.astFactory.sourceLocation(open, close)));
13191
13323
  } }
13192
13324
  ])
13193
13325
  };
@@ -13196,7 +13328,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
13196
13328
  var expression = {
13197
13329
  name: "expression",
13198
13330
  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
13199
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13331
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13200
13332
  if (F2.isTerm(ast)) {
13201
13333
  SUBRULE(varOrTerm, ast);
13202
13334
  } else if (F2.isExpressionOperator(ast)) {
@@ -13261,7 +13393,7 @@ var conditionalOrExpression = {
13261
13393
  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
13262
13394
  CONSUME(symbols_exports.logicOr);
13263
13395
  const args = SUBRULE2(conditionalAndExpression);
13264
- return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
13396
+ return (left) => ACTION(() => C.astFactory.expressionOperation("||", [left, args], C.astFactory.sourceLocation(left, args)));
13265
13397
  }, ACTION, MANY)
13266
13398
  };
13267
13399
  var conditionalAndExpression = {
@@ -13269,7 +13401,7 @@ var conditionalAndExpression = {
13269
13401
  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
13270
13402
  CONSUME(symbols_exports.logicAnd);
13271
13403
  const arg = SUBRULE2(valueLogical);
13272
- return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
13404
+ return (left) => ACTION(() => C.astFactory.expressionOperation("&&", [left, arg], C.astFactory.sourceLocation(left, arg)));
13273
13405
  }, ACTION, MANY)
13274
13406
  };
13275
13407
  var valueLogical = {
@@ -13291,7 +13423,7 @@ var relationalExpression = {
13291
13423
  { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
13292
13424
  ]);
13293
13425
  const expr = SUBRULE2(numericExpression);
13294
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, expr], C.factory.sourceLocation(args1, expr)));
13426
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, expr], C.astFactory.sourceLocation(args1, expr)));
13295
13427
  } },
13296
13428
  { ALT: () => {
13297
13429
  const operator = OR3([
@@ -13299,7 +13431,7 @@ var relationalExpression = {
13299
13431
  { ALT: () => CONSUME(notIn) }
13300
13432
  ]);
13301
13433
  const args = SUBRULE1(expressionList);
13302
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, ...args.val], C.factory.sourceLocation(args1, args)));
13434
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, ...args.val], C.astFactory.sourceLocation(args1, args)));
13303
13435
  } }
13304
13436
  ]));
13305
13437
  return expression2 ?? args1;
@@ -13318,7 +13450,7 @@ var additiveExpression = {
13318
13450
  { ALT: () => CONSUME(symbols_exports.opMinus) }
13319
13451
  ]);
13320
13452
  const arg = SUBRULE2(multiplicativeExpression);
13321
- return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
13453
+ return ACTION(() => (left) => C.astFactory.expressionOperation(operator.image, [left, arg], C.astFactory.sourceLocation(left, arg)));
13322
13454
  } },
13323
13455
  { ALT: () => {
13324
13456
  const { operator, startInt } = OR3([
@@ -13349,9 +13481,9 @@ var additiveExpression = {
13349
13481
  { ALT: () => CONSUME(symbols_exports.slash) }
13350
13482
  ]);
13351
13483
  const innerExpr = SUBRULE1(unaryExpression);
13352
- return ACTION(() => (leftInner) => C.factory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.factory.sourceLocation(leftInner, innerExpr)));
13484
+ return ACTION(() => (leftInner) => C.astFactory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.astFactory.sourceLocation(leftInner, innerExpr)));
13353
13485
  }, ACTION, MANY2);
13354
- return (left) => C.factory.expressionOperation(operator, [left, multiplicativeExpr], C.factory.sourceLocation(left, multiplicativeExpr));
13486
+ return (left) => C.astFactory.expressionOperation(operator, [left, multiplicativeExpr], C.astFactory.sourceLocation(left, multiplicativeExpr));
13355
13487
  } }
13356
13488
  ]), ACTION, MANY1)
13357
13489
  };
@@ -13368,7 +13500,7 @@ var multiplicativeExpression = {
13368
13500
  subType: "operation",
13369
13501
  operator: operator.image,
13370
13502
  args: [left, expr],
13371
- loc: C.factory.sourceLocation(left, expr)
13503
+ loc: C.astFactory.sourceLocation(left, expr)
13372
13504
  });
13373
13505
  }, ACTION, MANY)
13374
13506
  };
@@ -13383,7 +13515,7 @@ var unaryExpression = {
13383
13515
  { ALT: () => CONSUME(symbols_exports.opMinus) }
13384
13516
  ]);
13385
13517
  const expr = SUBRULE2(primaryExpression);
13386
- return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
13518
+ return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
13387
13519
  } }
13388
13520
  ])
13389
13521
  };
@@ -13406,7 +13538,7 @@ var brackettedExpression = {
13406
13538
  const expr = SUBRULE(expression);
13407
13539
  const close = CONSUME(symbols_exports.RParen);
13408
13540
  return ACTION(() => {
13409
- expr.loc = C.factory.sourceLocation(open, close);
13541
+ expr.loc = C.astFactory.sourceLocation(open, close);
13410
13542
  return expr;
13411
13543
  });
13412
13544
  }
@@ -13428,13 +13560,13 @@ var iriOrFunction = {
13428
13560
  function: iriVal,
13429
13561
  args: args.val.args,
13430
13562
  distinct: distinct2,
13431
- loc: C.factory.sourceLocation(iriVal, args)
13563
+ loc: C.astFactory.sourceLocation(iriVal, args)
13432
13564
  };
13433
13565
  });
13434
13566
  });
13435
13567
  return functionCall2 ?? iriVal;
13436
13568
  },
13437
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13569
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13438
13570
  if (F2.isTermNamed(ast)) {
13439
13571
  SUBRULE(iri2, ast);
13440
13572
  } else {
@@ -13487,11 +13619,14 @@ var groupClause = {
13487
13619
  type: "solutionModifier",
13488
13620
  subType: "group",
13489
13621
  groupings,
13490
- loc: C.factory.sourceLocation(start, groupings.at(-1))
13622
+ loc: C.astFactory.sourceLocation(start, groupings.at(-1))
13491
13623
  }));
13492
13624
  },
13493
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F2 }) => {
13494
- F2.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
13625
+ gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
13626
+ F2.printFilter(ast, () => {
13627
+ PRINT_ON_EMPTY("");
13628
+ PRINT_WORDS("GROUP", "BY");
13629
+ });
13495
13630
  for (const grouping of ast.groupings) {
13496
13631
  if (F2.isExpression(grouping)) {
13497
13632
  SUBRULE(expression, grouping);
@@ -13525,7 +13660,7 @@ var groupCondition = {
13525
13660
  return {
13526
13661
  variable,
13527
13662
  value: expressionValue,
13528
- loc: C.factory.sourceLocation(open, close)
13663
+ loc: C.astFactory.sourceLocation(open, close)
13529
13664
  };
13530
13665
  }
13531
13666
  return expressionValue;
@@ -13544,10 +13679,13 @@ var havingClause = {
13544
13679
  expressions.push(SUBRULE(havingCondition));
13545
13680
  });
13546
13681
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13547
- return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
13682
+ return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
13548
13683
  },
13549
- gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F2 }) => {
13550
- F2.printFilter(ast, () => PRINT_WORD("HAVING"));
13684
+ gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
13685
+ F2.printFilter(ast, () => {
13686
+ PRINT_ON_EMPTY("");
13687
+ PRINT_WORD("HAVING");
13688
+ });
13551
13689
  for (const having2 of ast.having) {
13552
13690
  SUBRULE(expression, having2);
13553
13691
  }
@@ -13568,10 +13706,13 @@ var orderClause = {
13568
13706
  orderings.push(SUBRULE1(orderCondition));
13569
13707
  });
13570
13708
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13571
- return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
13709
+ return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order2, orderings.at(-1))));
13572
13710
  },
13573
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F2 }) => {
13574
- F2.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
13711
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F2 }) => {
13712
+ F2.printFilter(ast, () => {
13713
+ PRINT_ON_EMPTY("");
13714
+ PRINT_WORDS("ORDER", "BY");
13715
+ });
13575
13716
  for (const ordering of ast.orderDefs) {
13576
13717
  if (ordering.descending) {
13577
13718
  F2.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13602,7 +13743,7 @@ var orderCondition = {
13602
13743
  return ACTION(() => ({
13603
13744
  expression: expr,
13604
13745
  descending: descending[0],
13605
- loc: C.factory.sourceLocation(descending[1], expr)
13746
+ loc: C.astFactory.sourceLocation(descending[1], expr)
13606
13747
  }));
13607
13748
  } },
13608
13749
  { ALT: () => {
@@ -13621,16 +13762,17 @@ var limitOffsetClauses = {
13621
13762
  { ALT: () => {
13622
13763
  const limit2 = SUBRULE1(limitClause);
13623
13764
  const offset2 = OPTION1(() => SUBRULE1(offsetClause));
13624
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13765
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.astFactory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13625
13766
  } },
13626
13767
  { ALT: () => {
13627
13768
  const offset2 = SUBRULE2(offsetClause);
13628
13769
  const limit2 = OPTION2(() => SUBRULE2(limitClause));
13629
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
13770
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
13630
13771
  } }
13631
13772
  ]),
13632
- gImpl: ({ PRINT_WORDS }) => (ast, { factory: F2 }) => {
13773
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F2 }) => {
13633
13774
  F2.printFilter(ast, () => {
13775
+ PRINT_ON_EMPTY("");
13634
13776
  if (ast.limit) {
13635
13777
  PRINT_WORDS("LIMIT", String(ast.limit));
13636
13778
  }
@@ -13646,7 +13788,7 @@ var limitClause = {
13646
13788
  const offset2 = CONSUME(limit);
13647
13789
  const value = CONSUME(terminals_exports.integer);
13648
13790
  const val = Number.parseInt(value.image, 10);
13649
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13791
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13650
13792
  }
13651
13793
  };
13652
13794
  var offsetClause = {
@@ -13655,7 +13797,7 @@ var offsetClause = {
13655
13797
  const offset2 = CONSUME(offset);
13656
13798
  const value = CONSUME(terminals_exports.integer);
13657
13799
  const val = Number.parseInt(value.image, 10);
13658
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13800
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13659
13801
  }
13660
13802
  };
13661
13803
 
@@ -13680,10 +13822,10 @@ var query = {
13680
13822
  ...subType,
13681
13823
  type: "query",
13682
13824
  ...values3 && { values: values3 },
13683
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
13825
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
13684
13826
  }));
13685
13827
  },
13686
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13828
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13687
13829
  SUBRULE(prologue, ast.context);
13688
13830
  if (F2.isQuerySelect(ast)) {
13689
13831
  SUBRULE(selectQuery, ast);
@@ -13713,13 +13855,13 @@ var selectQuery = {
13713
13855
  solutionModifiers: modifiers,
13714
13856
  datasets: from2,
13715
13857
  ...selectVal.val,
13716
- loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13858
+ loc: C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13717
13859
  };
13718
13860
  queryIsGood(ret);
13719
13861
  return ret;
13720
13862
  });
13721
13863
  },
13722
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
13864
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
13723
13865
  SUBRULE(selectClause, F2.wrap({
13724
13866
  variables: ast.variables,
13725
13867
  distinct: ast.distinct,
@@ -13737,14 +13879,14 @@ var subSelect = {
13737
13879
  const where2 = SUBRULE(whereClause);
13738
13880
  const modifiers = SUBRULE(solutionModifier);
13739
13881
  const values3 = SUBRULE(valuesClause);
13740
- return ACTION(() => C.factory.querySelect({
13882
+ return ACTION(() => C.astFactory.querySelect({
13741
13883
  where: where2.val,
13742
- datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
13884
+ datasets: C.astFactory.datasetClauses([], C.astFactory.sourceLocation()),
13743
13885
  context: [],
13744
13886
  solutionModifiers: modifiers,
13745
13887
  ...selectVal.val,
13746
13888
  ...values3 && { values: values3 }
13747
- }, C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13889
+ }, C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13748
13890
  }
13749
13891
  };
13750
13892
  var selectClause = {
@@ -13775,7 +13917,7 @@ var selectClause = {
13775
13917
  const star2 = CONSUME(symbols_exports.star);
13776
13918
  return ACTION(() => {
13777
13919
  last2 = star2;
13778
- return { variables: [C.factory.wildcard(C.factory.sourceLocation(star2))], ...distRed };
13920
+ return { variables: [C.astFactory.wildcard(C.astFactory.sourceLocation(star2))], ...distRed };
13779
13921
  });
13780
13922
  } },
13781
13923
  { ALT: () => {
@@ -13805,7 +13947,7 @@ var selectClause = {
13805
13947
  throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
13806
13948
  }
13807
13949
  usedVars.push(variable);
13808
- variables.push(C.factory.patternBind(expr, variable, C.factory.sourceLocation(open, last2)));
13950
+ variables.push(C.astFactory.patternBind(expr, variable, C.astFactory.sourceLocation(open, last2)));
13809
13951
  });
13810
13952
  } }
13811
13953
  ]));
@@ -13813,9 +13955,9 @@ var selectClause = {
13813
13955
  } }
13814
13956
  ]);
13815
13957
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13816
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select2, last2)));
13958
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
13817
13959
  },
13818
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
13960
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13819
13961
  F2.printFilter(ast, () => {
13820
13962
  PRINT_WORD("SELECT");
13821
13963
  if (ast.val.distinct) {
@@ -13855,7 +13997,7 @@ var constructQuery = {
13855
13997
  datasets: from2,
13856
13998
  where: where2.val,
13857
13999
  solutionModifiers: modifiers,
13858
- loc: C.factory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14000
+ loc: C.astFactory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13859
14001
  }));
13860
14002
  } },
13861
14003
  { ALT: () => {
@@ -13867,19 +14009,26 @@ var constructQuery = {
13867
14009
  subType: "construct",
13868
14010
  template: template.val,
13869
14011
  datasets: from2,
13870
- where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
14012
+ where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
13871
14013
  solutionModifiers: modifiers,
13872
- loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14014
+ loc: C.astFactory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13873
14015
  }));
13874
14016
  } }
13875
14017
  ]);
13876
14018
  },
13877
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14019
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14020
+ const { astFactory: F2, indentInc } = C;
13878
14021
  F2.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
13879
14022
  if (!F2.isSourceLocationNoMaterialize(ast.where.loc)) {
13880
- F2.printFilter(ast, () => PRINT_WORD("{"));
14023
+ F2.printFilter(ast, () => {
14024
+ C[traqulaIndentation] += indentInc;
14025
+ PRINT_WORD("{\n");
14026
+ });
13881
14027
  SUBRULE(triplesBlock, ast.template);
13882
- F2.printFilter(ast, () => PRINT_WORD("}"));
14028
+ F2.printFilter(ast, () => {
14029
+ C[traqulaIndentation] -= indentInc;
14030
+ PRINT_ON_EMPTY("}\n");
14031
+ });
13883
14032
  }
13884
14033
  SUBRULE(datasetClauseStar, ast.datasets);
13885
14034
  if (F2.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13904,7 +14053,7 @@ var describeQuery = {
13904
14053
  } },
13905
14054
  { ALT: () => {
13906
14055
  const star2 = CONSUME(symbols_exports.star);
13907
- return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star2)))];
14056
+ return [ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(star2)))];
13908
14057
  } }
13909
14058
  ]);
13910
14059
  const from2 = SUBRULE1(datasetClauseStar);
@@ -13916,10 +14065,10 @@ var describeQuery = {
13916
14065
  datasets: from2,
13917
14066
  ...where2 && { where: where2.val },
13918
14067
  solutionModifiers: modifiers,
13919
- loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14068
+ loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13920
14069
  }));
13921
14070
  },
13922
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14071
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13923
14072
  F2.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
13924
14073
  if (F2.isWildcard(ast.variables[0])) {
13925
14074
  F2.printFilter(ast, () => PRINT_WORD("*"));
@@ -13947,10 +14096,10 @@ var askQuery = {
13947
14096
  datasets: from2,
13948
14097
  where: where2.val,
13949
14098
  solutionModifiers: modifiers,
13950
- loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14099
+ loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13951
14100
  }));
13952
14101
  },
13953
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14102
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
13954
14103
  F2.printFilter(ast, () => PRINT_WORD("ASK"));
13955
14104
  SUBRULE(datasetClauseStar, ast.datasets);
13956
14105
  SUBRULE(whereClause, F2.wrap(ast.where, ast.loc));
@@ -13967,7 +14116,7 @@ var constructTemplate = {
13967
14116
  const open = CONSUME(symbols_exports.LCurly);
13968
14117
  const triples = OPTION(() => SUBRULE1(constructTriples));
13969
14118
  const close = CONSUME(symbols_exports.RCurly);
13970
- return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
14119
+ return ACTION(() => C.astFactory.wrap(triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocation()), C.astFactory.sourceLocation(open, close)));
13971
14120
  }
13972
14121
  };
13973
14122
  var constructTriples = {
@@ -14004,13 +14153,13 @@ var update = {
14004
14153
  const update2 = {
14005
14154
  type: "update",
14006
14155
  updates,
14007
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14156
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14008
14157
  };
14009
14158
  updateNoReuseBlankNodeLabels(update2);
14010
14159
  return update2;
14011
14160
  });
14012
14161
  },
14013
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14162
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14014
14163
  const [head2, ...tail] = ast.updates;
14015
14164
  if (head2) {
14016
14165
  SUBRULE(prologue, head2.context);
@@ -14090,9 +14239,9 @@ var load2 = {
14090
14239
  CONSUME(loadInto);
14091
14240
  return SUBRULE1(graphRef);
14092
14241
  });
14093
- return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
14242
+ return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
14094
14243
  },
14095
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14244
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14096
14245
  F2.printFilter(ast, () => {
14097
14246
  PRINT_WORD("LOAD");
14098
14247
  if (ast.silent) {
@@ -14113,9 +14262,9 @@ function clearOrDrop(operation) {
14113
14262
  const opToken = CONSUME(operation);
14114
14263
  const silent2 = OPTION(() => CONSUME(silent));
14115
14264
  const destination = SUBRULE1(graphRefAll);
14116
- return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
14265
+ return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
14117
14266
  },
14118
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14267
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14119
14268
  F2.printFilter(ast, () => {
14120
14269
  PRINT_WORD(operation.name.toUpperCase());
14121
14270
  if (ast.silent) {
@@ -14134,9 +14283,9 @@ var create2 = {
14134
14283
  const createToken3 = CONSUME(create);
14135
14284
  const silent2 = OPTION(() => CONSUME(silent));
14136
14285
  const destination = SUBRULE1(graphRef);
14137
- return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
14286
+ return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
14138
14287
  },
14139
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14288
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14140
14289
  F2.printFilter(ast, () => {
14141
14290
  PRINT_WORD("CREATE");
14142
14291
  if (ast.silent) {
@@ -14155,9 +14304,9 @@ function copyMoveAddOperation(operation) {
14155
14304
  const source = SUBRULE1(graphOrDefault);
14156
14305
  CONSUME(to);
14157
14306
  const destination = SUBRULE2(graphOrDefault);
14158
- return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
14307
+ return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
14159
14308
  },
14160
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14309
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14161
14310
  F2.printFilter(ast, () => {
14162
14311
  PRINT_WORD(operation.name.toUpperCase());
14163
14312
  if (ast.silent) {
@@ -14179,7 +14328,7 @@ var quadPattern = {
14179
14328
  const open = CONSUME(symbols_exports.LCurly);
14180
14329
  const val = SUBRULE1(quads);
14181
14330
  const close = CONSUME(symbols_exports.RCurly);
14182
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
14331
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
14183
14332
  }
14184
14333
  };
14185
14334
  var quadData = {
@@ -14190,7 +14339,7 @@ var quadData = {
14190
14339
  const val = SUBRULE1(quads);
14191
14340
  ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
14192
14341
  const close = CONSUME(symbols_exports.RCurly);
14193
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
14342
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
14194
14343
  }
14195
14344
  };
14196
14345
  function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
@@ -14207,12 +14356,26 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
14207
14356
  if (name !== "insertData") {
14208
14357
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
14209
14358
  }
14210
- return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
14359
+ return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
14211
14360
  },
14212
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14213
- F2.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
14361
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14362
+ const { astFactory: F2, indentInc } = C;
14363
+ F2.printFilter(ast, () => {
14364
+ C[traqulaIndentation] += indentInc;
14365
+ if (subType === "insertdata") {
14366
+ PRINT_WORD("INSERT DATA");
14367
+ } else if (subType === "deletedata") {
14368
+ PRINT_WORD("DELETE DATA");
14369
+ } else if (subType === "deletewhere") {
14370
+ PRINT_WORD("DELETE WHERE");
14371
+ }
14372
+ PRINT_WORD("{\n");
14373
+ });
14214
14374
  SUBRULE(quads, F2.wrap(ast.data, ast.loc));
14215
- F2.printFilter(ast, () => PRINT_WORD("}"));
14375
+ F2.printFilter(ast, () => {
14376
+ C[traqulaIndentation] -= indentInc;
14377
+ PRINT_ON_EMPTY("}\n");
14378
+ });
14216
14379
  }
14217
14380
  };
14218
14381
  }
@@ -14241,22 +14404,35 @@ var modify = {
14241
14404
  const using = SUBRULE1(usingClauseStar);
14242
14405
  CONSUME(where);
14243
14406
  const where2 = SUBRULE1(groupGraphPattern);
14244
- return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
14407
+ return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
14245
14408
  },
14246
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14409
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14410
+ const { astFactory: F2, indentInc } = C;
14247
14411
  if (ast.graph) {
14248
14412
  F2.printFilter(ast, () => PRINT_WORD("WITH"));
14249
14413
  SUBRULE(iri2, ast.graph);
14250
14414
  }
14251
14415
  if (ast.delete.length > 0) {
14252
- F2.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
14416
+ F2.printFilter(ast, () => {
14417
+ C[traqulaIndentation] += indentInc;
14418
+ PRINT_WORD("DELETE", "{\n");
14419
+ });
14253
14420
  SUBRULE(quads, F2.wrap(ast.delete, ast.loc));
14254
- F2.printFilter(ast, () => PRINT_WORD("}"));
14421
+ F2.printFilter(ast, () => {
14422
+ C[traqulaIndentation] -= indentInc;
14423
+ PRINT_ON_EMPTY("}\n");
14424
+ });
14255
14425
  }
14256
14426
  if (ast.insert.length > 0) {
14257
- F2.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
14427
+ F2.printFilter(ast, () => {
14428
+ C[traqulaIndentation] += indentInc;
14429
+ PRINT_WORD("INSERT", "{\n");
14430
+ });
14258
14431
  SUBRULE(quads, F2.wrap(ast.insert, ast.loc));
14259
- F2.printFilter(ast, () => PRINT_WORD("}"));
14432
+ F2.printFilter(ast, () => {
14433
+ C[traqulaIndentation] -= indentInc;
14434
+ PRINT_ON_EMPTY("}\n");
14435
+ });
14260
14436
  }
14261
14437
  SUBRULE(usingClauseStar, ast.from);
14262
14438
  F2.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -14270,7 +14446,7 @@ var deleteClause2 = {
14270
14446
  const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
14271
14447
  const del = SUBRULE(quadPattern);
14272
14448
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
14273
- return ACTION(() => C.factory.wrap(del.val, C.factory.sourceLocation(delToken, del)));
14449
+ return ACTION(() => C.astFactory.wrap(del.val, C.astFactory.sourceLocation(delToken, del)));
14274
14450
  }
14275
14451
  };
14276
14452
  var insertClause2 = {
@@ -14278,7 +14454,7 @@ var insertClause2 = {
14278
14454
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
14279
14455
  const insertToken = CONSUME(insertClause);
14280
14456
  const insert = SUBRULE(quadPattern);
14281
- return ACTION(() => C.factory.wrap(insert.val, C.factory.sourceLocation(insertToken, insert)));
14457
+ return ACTION(() => C.astFactory.wrap(insert.val, C.astFactory.sourceLocation(insertToken, insert)));
14282
14458
  }
14283
14459
  };
14284
14460
  var graphOrDefault = {
@@ -14286,12 +14462,12 @@ var graphOrDefault = {
14286
14462
  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => OR([
14287
14463
  { ALT: () => {
14288
14464
  const def = CONSUME(graph_exports.default_);
14289
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14465
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
14290
14466
  } },
14291
14467
  { ALT: () => {
14292
14468
  const graph2 = OPTION(() => CONSUME(graph_exports.graph));
14293
14469
  const name = SUBRULE1(iri2);
14294
- return ACTION(() => C.factory.graphRefSpecific(name, C.factory.sourceLocation(graph2, name)));
14470
+ return ACTION(() => C.astFactory.graphRefSpecific(name, C.astFactory.sourceLocation(graph2, name)));
14295
14471
  } }
14296
14472
  ])
14297
14473
  };
@@ -14300,9 +14476,9 @@ var graphRef = {
14300
14476
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
14301
14477
  const graph2 = CONSUME(graph_exports.graph);
14302
14478
  const val = SUBRULE(iri2);
14303
- return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
14479
+ return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph2, val)));
14304
14480
  },
14305
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14481
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14306
14482
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
14307
14483
  SUBRULE(iri2, ast.graph);
14308
14484
  }
@@ -14313,18 +14489,18 @@ var graphRefAll = {
14313
14489
  { ALT: () => SUBRULE(graphRef) },
14314
14490
  { ALT: () => {
14315
14491
  const def = CONSUME(graph_exports.default_);
14316
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14492
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
14317
14493
  } },
14318
14494
  { ALT: () => {
14319
14495
  const named2 = CONSUME(graph_exports.named);
14320
- return ACTION(() => C.factory.graphRefNamed(C.factory.sourceLocation(named2)));
14496
+ return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named2)));
14321
14497
  } },
14322
14498
  { ALT: () => {
14323
14499
  const graphAll2 = CONSUME(graph_exports.graphAll);
14324
- return ACTION(() => C.factory.graphRefAll(C.factory.sourceLocation(graphAll2)));
14500
+ return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll2)));
14325
14501
  } }
14326
14502
  ]),
14327
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14503
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F2 }) => {
14328
14504
  if (F2.isGraphRefSpecific(ast)) {
14329
14505
  SUBRULE(graphRef, ast);
14330
14506
  } else if (F2.isGraphRefDefault(ast)) {
@@ -14361,9 +14537,9 @@ var quads = {
14361
14537
  ACTION(() => quads2.push(triples));
14362
14538
  });
14363
14539
  });
14364
- return ACTION(() => C.factory.wrap(quads2, C.factory.sourceLocation(quads2.at(0), last2)));
14540
+ return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last2)));
14365
14541
  },
14366
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
14542
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
14367
14543
  for (const quad of ast.val) {
14368
14544
  if (F2.isPattern(quad)) {
14369
14545
  SUBRULE(triplesBlock, quad);
@@ -14381,14 +14557,21 @@ var quadsNotTriples = {
14381
14557
  CONSUME(symbols_exports.LCurly);
14382
14558
  const triples = OPTION(() => SUBRULE1(triplesTemplate));
14383
14559
  const close = CONSUME(symbols_exports.RCurly);
14384
- return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
14560
+ return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
14385
14561
  },
14386
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
14562
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14563
+ const { astFactory: F2, indentInc } = C;
14387
14564
  F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
14388
14565
  SUBRULE(varOrTerm, ast.graph);
14389
- F2.printFilter(ast, () => PRINT_WORD("{"));
14566
+ F2.printFilter(ast, () => {
14567
+ C[traqulaIndentation] += indentInc;
14568
+ PRINT_WORD("{\n");
14569
+ });
14390
14570
  SUBRULE(triplesBlock, ast.triples);
14391
- F2.printFilter(ast, () => PRINT_WORD("}"));
14571
+ F2.printFilter(ast, () => {
14572
+ C[traqulaIndentation] -= indentInc;
14573
+ PRINT_ON_EMPTY("}\n");
14574
+ });
14392
14575
  }
14393
14576
  };
14394
14577
 
@@ -14411,7 +14594,7 @@ var queryOrUpdate = {
14411
14594
  ...subType,
14412
14595
  type: "query",
14413
14596
  ...values3 && { values: values3 },
14414
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
14597
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
14415
14598
  }));
14416
14599
  } },
14417
14600
  { ALT: () => {
@@ -14435,7 +14618,7 @@ var queryOrUpdate = {
14435
14618
  const update2 = {
14436
14619
  type: "update",
14437
14620
  updates,
14438
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14621
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14439
14622
  };
14440
14623
  updateNoReuseBlankNodeLabels(update2);
14441
14624
  return update2;
@@ -14443,7 +14626,7 @@ var queryOrUpdate = {
14443
14626
  } }
14444
14627
  ]);
14445
14628
  },
14446
- gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
14629
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F2 }) => {
14447
14630
  if (F2.isQuery(ast)) {
14448
14631
  SUBRULE(query, ast);
14449
14632
  } else {
@@ -14455,13 +14638,15 @@ var queryOrUpdate = {
14455
14638
  // ../../packages/rules-sparql-1-1/lib/MinimalSparqlParser.js
14456
14639
  function completeParseContext(context) {
14457
14640
  return {
14458
- factory: context.factory ?? new Factory(),
14641
+ astFactory: context.astFactory ?? new AstFactory(),
14459
14642
  baseIRI: context.baseIRI,
14460
14643
  prefixes: { ...context.prefixes },
14461
14644
  origSource: context.origSource ?? "",
14462
14645
  offset: context.offset,
14463
14646
  parseMode: context.parseMode ? new Set(context.parseMode) : /* @__PURE__ */ new Set(["canParseVars", "canCreateBlankNodes"]),
14464
- skipValidation: context.skipValidation ?? false
14647
+ skipValidation: context.skipValidation ?? false,
14648
+ [traqulaIndentation]: context[traqulaIndentation] ?? 0,
14649
+ indentInc: context.indentInc ?? 2
14465
14650
  };
14466
14651
  }
14467
14652
  var MinimalSparqlParser = class {
@@ -14469,7 +14654,7 @@ var MinimalSparqlParser = class {
14469
14654
  constructor(parser) {
14470
14655
  this.parser = parser;
14471
14656
  }
14472
- F = new Factory();
14657
+ F = new AstFactory();
14473
14658
  parse(query2, context = {}) {
14474
14659
  return this.parser.queryOrUpdate(query2, completeParseContext(context));
14475
14660
  }