@traqula/parser-sparql-1-2 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 (4) hide show
  1. package/lib/Parser.js +2 -2
  2. package/lib/Parser.js.map +1 -1
  3. package/lib/index.cjs +691 -486
  4. package/package.json +7 -7
package/lib/index.cjs CHANGED
@@ -25,8 +25,8 @@ __export(index_exports, {
25
25
  });
26
26
  module.exports = __toCommonJS(index_exports);
27
27
 
28
- // ../../packages/core/lib/CoreFactory.js
29
- var CoreFactory = class {
28
+ // ../../packages/core/lib/AstCoreFactory.js
29
+ var AstCoreFactory = class {
30
30
  wrap(val, loc) {
31
31
  return { val, loc };
32
32
  }
@@ -9370,6 +9370,15 @@ var EmbeddedActionsParser = class extends Parser {
9370
9370
  }
9371
9371
  };
9372
9372
 
9373
+ // ../../packages/core/lib/utils.js
9374
+ function unCapitalize(str2) {
9375
+ return str2.charAt(0).toLowerCase() + str2.slice(1);
9376
+ }
9377
+ function createToken2(config) {
9378
+ return createToken(config);
9379
+ }
9380
+ var traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
9381
+
9373
9382
  // ../../packages/core/lib/lexer-builder/LexerBuilder.js
9374
9383
  var LexerBuilder = class _LexerBuilder {
9375
9384
  tokens;
@@ -9732,16 +9741,13 @@ ${firstError.message}`);
9732
9741
  }
9733
9742
  };
9734
9743
 
9735
- // ../../packages/core/lib/utils.js
9736
- function unCapitalize(str2) {
9737
- return str2.charAt(0).toLowerCase() + str2.slice(1);
9738
- }
9739
- function createToken2(config) {
9740
- return createToken(config);
9741
- }
9742
-
9743
9744
  // ../../packages/core/lib/Transformers.js
9744
9745
  var TransformerType = class {
9746
+ clone(obj) {
9747
+ const newObj = Object.create(Object.getPrototypeOf(obj));
9748
+ Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
9749
+ return newObj;
9750
+ }
9745
9751
  safeObjectVisit(value, mapper) {
9746
9752
  if (value && typeof value === "object") {
9747
9753
  if (Array.isArray(value)) {
@@ -9751,104 +9757,213 @@ var TransformerType = class {
9751
9757
  }
9752
9758
  return value;
9753
9759
  }
9754
- transformNode(curObject, nodeCallBacks) {
9755
- let continueCheck;
9756
- let transformation;
9757
- const casted = curObject;
9758
- if (casted.type) {
9759
- continueCheck = nodeCallBacks[casted.type]?.continue;
9760
- transformation = nodeCallBacks[casted.type]?.transform;
9761
- }
9762
- let shouldContinue = true;
9763
- if (continueCheck) {
9764
- shouldContinue = continueCheck(curObject);
9765
- }
9766
- if (!shouldContinue) {
9767
- return curObject;
9768
- }
9769
- const copy3 = { ...curObject };
9770
- for (const [key, value] of Object.entries(copy3)) {
9771
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
9772
- }
9773
- if (transformation) {
9774
- return transformation(copy3);
9775
- }
9776
- return copy3;
9760
+ /**
9761
+ * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
9762
+ * @param startObject object to start iterating from
9763
+ * @param mapper mapper to transform the various objects - argument is a copy of the original
9764
+ * @param preVisitor callback that is evaluated before iterating deeper.
9765
+ * If continues is false, we do not iterate deeper, current object is still mapped. - default: true
9766
+ * If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
9767
+ * - Default false
9768
+ */
9769
+ transformObject(startObject, mapper, preVisitor = () => ({})) {
9770
+ let didShortCut = false;
9771
+ const recurse = (curObject) => {
9772
+ const copy3 = this.clone(curObject);
9773
+ const context = preVisitor(copy3);
9774
+ didShortCut = context.shortcut ?? false;
9775
+ const continues = context.continue ?? true;
9776
+ if (continues && !didShortCut) {
9777
+ for (const [key, value] of Object.entries(copy3)) {
9778
+ if (didShortCut) {
9779
+ return copy3;
9780
+ }
9781
+ copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
9782
+ }
9783
+ }
9784
+ return mapper(copy3);
9785
+ };
9786
+ return recurse(startObject);
9777
9787
  }
9778
- visitNode(curObject, nodeCallBacks) {
9779
- let callback;
9780
- const casted = curObject;
9781
- if (casted.type) {
9782
- callback = nodeCallBacks[casted.type];
9783
- }
9784
- let shouldIterate = true;
9785
- if (callback) {
9786
- shouldIterate = callback(curObject);
9787
- }
9788
- if (shouldIterate) {
9789
- for (const value of Object.values(curObject)) {
9790
- this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
9788
+ /**
9789
+ * Visitor that visits all objects. Visits deeper objects first.
9790
+ */
9791
+ visitObject(startObject, visitor, preVisitor = () => ({})) {
9792
+ let didShortCut = false;
9793
+ const recurse = (curObject) => {
9794
+ const context = preVisitor(curObject);
9795
+ didShortCut = context.shortcut ?? false;
9796
+ const continues = context.continue ?? true;
9797
+ if (continues && !didShortCut) {
9798
+ for (const value of Object.values(curObject)) {
9799
+ if (didShortCut) {
9800
+ return;
9801
+ }
9802
+ this.safeObjectVisit(value, (obj) => recurse(obj));
9803
+ }
9791
9804
  }
9792
- }
9805
+ visitor(curObject);
9806
+ };
9807
+ recurse(startObject);
9808
+ }
9809
+ transformNode(startObject, nodeCallBacks) {
9810
+ const transformWrapper = (curObject) => {
9811
+ const casted = curObject;
9812
+ if (casted.type) {
9813
+ const ogFunc = nodeCallBacks[casted.type]?.transform;
9814
+ if (ogFunc) {
9815
+ return ogFunc(casted);
9816
+ }
9817
+ }
9818
+ return curObject;
9819
+ };
9820
+ const preTransformWrapper = (curObject) => {
9821
+ const casted = curObject;
9822
+ if (casted.type) {
9823
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9824
+ if (ogFunc) {
9825
+ return ogFunc(casted);
9826
+ }
9827
+ }
9828
+ return {};
9829
+ };
9830
+ return this.transformObject(startObject, transformWrapper, preTransformWrapper);
9831
+ }
9832
+ visitNode(startObject, nodeCallBacks) {
9833
+ const visitWrapper = (curObject) => {
9834
+ const casted = curObject;
9835
+ if (casted.type) {
9836
+ const ogFunc = nodeCallBacks[casted.type]?.visitor;
9837
+ if (ogFunc) {
9838
+ ogFunc(casted);
9839
+ }
9840
+ }
9841
+ };
9842
+ const preVisitWrapper = (curObject) => {
9843
+ const casted = curObject;
9844
+ if (casted.type) {
9845
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9846
+ if (ogFunc) {
9847
+ return ogFunc(casted);
9848
+ }
9849
+ }
9850
+ return {};
9851
+ };
9852
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9853
+ }
9854
+ traverseNodes(currentNode, traverse) {
9855
+ let didShortCut = false;
9856
+ const recurse = (curNode) => {
9857
+ const traverser = traverse[curNode.type];
9858
+ if (traverser) {
9859
+ const { next, shortcut } = traverser(curNode);
9860
+ didShortCut = shortcut ?? false;
9861
+ if (!didShortCut) {
9862
+ for (const node of next ?? []) {
9863
+ if (didShortCut) {
9864
+ return;
9865
+ }
9866
+ recurse(node);
9867
+ }
9868
+ }
9869
+ }
9870
+ };
9871
+ recurse(currentNode);
9793
9872
  }
9794
9873
  };
9795
9874
  var TransformerSubType = class extends TransformerType {
9796
- // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
9797
- // for (const value of Object.values(curObject)) {
9798
- // this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
9799
- // }
9800
- // }
9801
- transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9802
- let continueCheck;
9803
- let transformation;
9804
- const casted = curObject;
9805
- if (casted.type && casted.subType) {
9806
- const specific = nodeSpecificCallBacks[casted.type];
9807
- if (specific) {
9808
- continueCheck = specific[casted.subType]?.continue;
9809
- transformation = specific[casted.subType]?.transform;
9810
- }
9811
- }
9812
- let shouldContinue = true;
9813
- if (continueCheck) {
9814
- shouldContinue = continueCheck(curObject);
9815
- }
9816
- if (!shouldContinue) {
9817
- return curObject;
9818
- }
9819
- const copy3 = { ...curObject };
9820
- for (const [key, value] of Object.entries(copy3)) {
9821
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9822
- }
9823
- if (transformation) {
9824
- return transformation(copy3);
9825
- }
9826
- return copy3;
9875
+ transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9876
+ const transformWrapper = (curObject) => {
9877
+ let ogTransform;
9878
+ const casted = curObject;
9879
+ if (casted.type && casted.subType) {
9880
+ const specific = nodeSpecificCallBacks[casted.type];
9881
+ if (specific) {
9882
+ ogTransform = specific[casted.subType]?.transform;
9883
+ }
9884
+ if (!ogTransform) {
9885
+ ogTransform = nodeCallBacks[casted.type]?.transform;
9886
+ }
9887
+ }
9888
+ return ogTransform ? ogTransform(casted) : curObject;
9889
+ };
9890
+ const preVisitWrapper = (curObject) => {
9891
+ let ogPreVisit;
9892
+ const casted = curObject;
9893
+ if (casted.type && casted.subType) {
9894
+ const specific = nodeSpecificCallBacks[casted.type];
9895
+ if (specific) {
9896
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9897
+ }
9898
+ if (!ogPreVisit) {
9899
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9900
+ }
9901
+ }
9902
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9903
+ };
9904
+ return this.transformObject(startObject, transformWrapper, preVisitWrapper);
9827
9905
  }
9828
9906
  /**
9829
9907
  * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
9830
9908
  */
9831
- visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9832
- let callback;
9833
- const casted = curObject;
9834
- if (casted.type && casted.subType) {
9835
- const specific = nodeSpecificCallBacks[casted.type];
9836
- if (specific) {
9837
- callback = specific[casted.subType];
9909
+ visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9910
+ const visitWrapper = (curObject) => {
9911
+ let ogTransform;
9912
+ const casted = curObject;
9913
+ if (casted.type && casted.subType) {
9914
+ const specific = nodeSpecificCallBacks[casted.type];
9915
+ if (specific) {
9916
+ ogTransform = specific[casted.subType]?.visitor;
9917
+ }
9918
+ if (!ogTransform) {
9919
+ ogTransform = nodeCallBacks[casted.type]?.visitor;
9920
+ }
9838
9921
  }
9839
- }
9840
- if (!callback && casted.type) {
9841
- callback = nodeCallBacks[curObject.type];
9842
- }
9843
- let shouldIterate = true;
9844
- if (callback) {
9845
- shouldIterate = callback(curObject) ?? true;
9846
- }
9847
- if (shouldIterate) {
9848
- for (const value of Object.values(curObject)) {
9849
- this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9922
+ if (ogTransform) {
9923
+ ogTransform(casted);
9850
9924
  }
9851
- }
9925
+ };
9926
+ const preVisitWrapper = (curObject) => {
9927
+ let ogPreVisit;
9928
+ const casted = curObject;
9929
+ if (casted.type && casted.subType) {
9930
+ const specific = nodeSpecificCallBacks[casted.type];
9931
+ if (specific) {
9932
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9933
+ }
9934
+ if (!ogPreVisit) {
9935
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9936
+ }
9937
+ }
9938
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9939
+ };
9940
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9941
+ }
9942
+ traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
9943
+ let didShortCut = false;
9944
+ const recurse = (curNode) => {
9945
+ let traverser;
9946
+ const subObj = traverseSubNode[curNode.type];
9947
+ if (subObj) {
9948
+ traverser = subObj[curNode.subType];
9949
+ }
9950
+ if (!traverser) {
9951
+ traverser = traverseNode[curNode.type];
9952
+ }
9953
+ if (traverser) {
9954
+ const { next, shortcut } = traverser(curNode);
9955
+ didShortCut = shortcut ?? false;
9956
+ if (!didShortCut) {
9957
+ for (const node of next ?? []) {
9958
+ if (didShortCut) {
9959
+ return;
9960
+ }
9961
+ recurse(node);
9962
+ }
9963
+ }
9964
+ }
9965
+ };
9966
+ recurse(currentNode);
9852
9967
  }
9853
9968
  };
9854
9969
 
@@ -11246,8 +11361,8 @@ function UpdateOperationFactoryMixin(Base) {
11246
11361
  };
11247
11362
  }
11248
11363
 
11249
- // ../../packages/rules-sparql-1-1/lib/factory.js
11250
- 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() {
11364
+ // ../../packages/rules-sparql-1-1/lib/astFactory.js
11365
+ 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() {
11251
11366
  alwaysSparql11(obj) {
11252
11367
  return true;
11253
11368
  }
@@ -11362,12 +11477,12 @@ var CommonIRIs;
11362
11477
  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
11363
11478
  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
11364
11479
  })(CommonIRIs || (CommonIRIs = {}));
11365
- var TransformerSparql11 = class extends TransformerSubType {
11480
+ var AstTransformer = class extends TransformerSubType {
11366
11481
  };
11367
11482
 
11368
11483
  // ../../packages/rules-sparql-1-1/lib/validation/validators.js
11369
- var F = new Factory();
11370
- var transformer = new TransformerSparql11();
11484
+ var F = new AstFactory();
11485
+ var transformer = new AstTransformer();
11371
11486
  function getAggregatesOfExpression(expression2) {
11372
11487
  if (F.isExpressionAggregate(expression2)) {
11373
11488
  return [expression2];
@@ -11446,77 +11561,69 @@ function queryIsGood(query2) {
11446
11561
  }
11447
11562
  }
11448
11563
  }
11564
+ function notUndefined(some2) {
11565
+ return some2 !== void 0;
11566
+ }
11449
11567
  function findPatternBoundedVars(iter, boundedVars) {
11450
- if (F.isQuery(iter) || F.isUpdate(iter)) {
11451
- if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
11452
- if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
11453
- findPatternBoundedVars(iter.where, boundedVars);
11454
- } else {
11455
- for (const v of iter.variables) {
11456
- findPatternBoundedVars(v, boundedVars);
11457
- }
11458
- }
11459
- if (iter.solutionModifiers.group) {
11460
- const grouping = iter.solutionModifiers.group;
11461
- for (const g of grouping.groupings) {
11462
- if ("variable" in g) {
11463
- findPatternBoundedVars(g.variable, boundedVars);
11464
- }
11465
- }
11466
- }
11467
- if (iter.values?.values && iter.values.values.length > 0) {
11468
- const values3 = iter.values.values;
11469
- for (const v of Object.keys(values3[0])) {
11568
+ transformer.traverseSubNodes(iter, {
11569
+ query: (op) => ({ next: [
11570
+ op.solutionModifiers.group
11571
+ ].filter(notUndefined) }),
11572
+ triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
11573
+ path: (op) => ({ next: op.items }),
11574
+ tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
11575
+ }, {
11576
+ query: {
11577
+ select: (op) => ({ next: [
11578
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11579
+ op.solutionModifiers.group,
11580
+ op.values
11581
+ ].filter(notUndefined) }),
11582
+ describe: (op) => ({ next: [
11583
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11584
+ op.solutionModifiers.group,
11585
+ op.values
11586
+ ].filter(notUndefined) })
11587
+ },
11588
+ solutionModifier: {
11589
+ group: (op) => ({
11590
+ next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
11591
+ }),
11592
+ having: (op) => ({ next: op.having }),
11593
+ order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
11594
+ },
11595
+ pattern: {
11596
+ values: (op) => {
11597
+ for (const v of Object.keys(op.values.at(0) ?? {})) {
11470
11598
  boundedVars.add(v);
11471
11599
  }
11600
+ return {};
11601
+ },
11602
+ bgp: (op) => ({ next: op.triples }),
11603
+ group: (op) => ({ next: op.patterns }),
11604
+ union: (op) => ({ next: op.patterns }),
11605
+ optional: (op) => ({ next: op.patterns }),
11606
+ service: (op) => ({ next: [op.name, ...op.patterns] }),
11607
+ bind: (op) => ({ next: [op.variable] }),
11608
+ graph: (op) => ({ next: [op.name, ...op.patterns] }),
11609
+ minus: (op) => ({ next: op.patterns.slice(0, 1) })
11610
+ },
11611
+ term: {
11612
+ variable: (op) => {
11613
+ boundedVars.add(op.value);
11614
+ return {};
11472
11615
  }
11473
11616
  }
11474
- } else if (F.isTerm(iter)) {
11475
- if (F.isTermVariable(iter)) {
11476
- boundedVars.add(iter.value);
11477
- }
11478
- } else if (F.isTriple(iter)) {
11479
- findPatternBoundedVars(iter.subject, boundedVars);
11480
- findPatternBoundedVars(iter.predicate, boundedVars);
11481
- findPatternBoundedVars(iter.object, boundedVars);
11482
- } else if (F.isPath(iter)) {
11483
- if (!F.isTerm(iter)) {
11484
- for (const item of iter.items) {
11485
- findPatternBoundedVars(item, boundedVars);
11486
- }
11487
- }
11488
- } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
11489
- for (const triple of iter.triples) {
11490
- findPatternBoundedVars(triple, boundedVars);
11491
- }
11492
- } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
11493
- for (const pattern of iter.patterns) {
11494
- findPatternBoundedVars(pattern, boundedVars);
11495
- }
11496
- if (F.isPatternService(iter)) {
11497
- findPatternBoundedVars(iter.name, boundedVars);
11498
- }
11499
- } else if (F.isPatternBind(iter)) {
11500
- findPatternBoundedVars(iter.variable, boundedVars);
11501
- } else if (F.isPatternValues(iter)) {
11502
- for (const variable of Object.keys(iter.values.at(0) ?? {})) {
11503
- boundedVars.add(variable);
11504
- }
11505
- } else if (F.isPatternGraph(iter)) {
11506
- findPatternBoundedVars(iter.name, boundedVars);
11507
- for (const pattern of iter.patterns) {
11508
- findPatternBoundedVars(pattern, boundedVars);
11509
- }
11510
- }
11617
+ });
11511
11618
  }
11512
11619
  function checkNote13(patterns) {
11513
11620
  for (const [index, pattern] of patterns.entries()) {
11514
11621
  if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
11515
11622
  const bgp = patterns[index - 1];
11516
11623
  const variables = [];
11517
- transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
11624
+ transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
11518
11625
  variables.push(var_2);
11519
- } } });
11626
+ } } } });
11520
11627
  if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
11521
11628
  throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
11522
11629
  }
@@ -11542,12 +11649,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
11542
11649
  const operation = update2.operation;
11543
11650
  if (operation.subType === "insertdata") {
11544
11651
  const blankNodesHere = /* @__PURE__ */ new Set();
11545
- transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
11652
+ transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
11546
11653
  blankNodesHere.add(blankNode2.label);
11547
11654
  if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
11548
11655
  throw new Error("Detected reuse blank node across different INSERT DATA clauses");
11549
11656
  }
11550
- } } });
11657
+ } } } });
11551
11658
  for (const blankNode2 of blankNodesHere) {
11552
11659
  blankLabelsUsedInInsertData.add(blankNode2);
11553
11660
  }
@@ -11586,22 +11693,22 @@ var rdfLiteral = {
11586
11693
  return OPTION(() => OR([
11587
11694
  { ALT: () => {
11588
11695
  const lang2 = CONSUME(terminals_exports.langTag);
11589
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11696
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
11590
11697
  } },
11591
11698
  { ALT: () => {
11592
11699
  CONSUME(symbols_exports.hathat);
11593
11700
  const iriVal = SUBRULE1(iri2);
11594
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
11701
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
11595
11702
  } }
11596
11703
  ])) ?? value;
11597
11704
  },
11598
- gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { factory }) => {
11599
- factory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11705
+ gImpl: ({ SUBRULE, PRINT, PRINT_SPACE_LEFT }) => (ast, { astFactory }) => {
11706
+ astFactory.printFilter(ast, () => PRINT_SPACE_LEFT(stringEscapedLexical(ast.value)));
11600
11707
  if (ast.langOrIri) {
11601
11708
  if (typeof ast.langOrIri === "string") {
11602
- factory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11709
+ astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
11603
11710
  } else {
11604
- factory.printFilter(ast, () => PRINT("^^"));
11711
+ astFactory.printFilter(ast, () => PRINT("^^"));
11605
11712
  SUBRULE(iri2, ast.langOrIri);
11606
11713
  }
11607
11714
  }
@@ -11623,7 +11730,7 @@ var numericLiteralUnsigned = {
11623
11730
  { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
11624
11731
  { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
11625
11732
  ]);
11626
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11733
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11627
11734
  }
11628
11735
  };
11629
11736
  var numericLiteralPositive = {
@@ -11634,7 +11741,7 @@ var numericLiteralPositive = {
11634
11741
  { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
11635
11742
  { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
11636
11743
  ]);
11637
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11744
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11638
11745
  }
11639
11746
  };
11640
11747
  var numericLiteralNegative = {
@@ -11645,7 +11752,7 @@ var numericLiteralNegative = {
11645
11752
  { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
11646
11753
  { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
11647
11754
  ]);
11648
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
11755
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
11649
11756
  }
11650
11757
  };
11651
11758
  var booleanLiteral = {
@@ -11655,7 +11762,7 @@ var booleanLiteral = {
11655
11762
  { ALT: () => CONSUME(true_) },
11656
11763
  { ALT: () => CONSUME(false_) }
11657
11764
  ]);
11658
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(token), token.image.toLowerCase(), C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11765
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.namedNode(C.astFactory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
11659
11766
  }
11660
11767
  };
11661
11768
  var string = {
@@ -11680,7 +11787,7 @@ var string = {
11680
11787
  } }
11681
11788
  ]);
11682
11789
  return ACTION(() => {
11683
- const F3 = C.factory;
11790
+ const F3 = C.astFactory;
11684
11791
  const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
11685
11792
  switch (char) {
11686
11793
  case "t":
@@ -11707,16 +11814,16 @@ var iri2 = {
11707
11814
  { ALT: () => SUBRULE(iriFull) },
11708
11815
  { ALT: () => SUBRULE(prefixedName) }
11709
11816
  ]),
11710
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11817
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
11711
11818
  };
11712
11819
  var iriFull = {
11713
11820
  name: "iriFull",
11714
11821
  impl: ({ ACTION, CONSUME }) => (C) => {
11715
11822
  const iriToken = CONSUME(terminals_exports.iriRef);
11716
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11823
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
11717
11824
  },
11718
- gImpl: ({ PRINT }) => (ast, { factory }) => {
11719
- factory.printFilter(ast, () => PRINT("<", ast.value, ">"));
11825
+ gImpl: ({ PRINT }) => (ast, { astFactory: F3 }) => {
11826
+ F3.printFilter(ast, () => PRINT("<", ast.value, ">"));
11720
11827
  }
11721
11828
  };
11722
11829
  var prefixedName = {
@@ -11726,16 +11833,16 @@ var prefixedName = {
11726
11833
  const longName = CONSUME(terminals_exports.pNameLn);
11727
11834
  return ACTION(() => {
11728
11835
  const [prefix, localName] = longName.image.split(":");
11729
- return C.factory.namedNode(C.factory.sourceLocation(longName), localName, prefix);
11836
+ return C.astFactory.namedNode(C.astFactory.sourceLocation(longName), localName, prefix);
11730
11837
  });
11731
11838
  } },
11732
11839
  { ALT: () => {
11733
11840
  const shortName = CONSUME(terminals_exports.pNameNs);
11734
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11841
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
11735
11842
  } }
11736
11843
  ]),
11737
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11738
- factory.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11844
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
11845
+ F3.printFilter(ast, () => PRINT_WORD(ast.prefix, ":", ast.value));
11739
11846
  }
11740
11847
  };
11741
11848
  var canCreateBlankNodes = Symbol("canCreateBlankNodes");
@@ -11745,11 +11852,11 @@ var blankNode = {
11745
11852
  const result = OR([
11746
11853
  { ALT: () => {
11747
11854
  const labelToken = CONSUME(terminals_exports.blankNodeLabel);
11748
- return ACTION(() => C.factory.blankNode(labelToken.image.slice(2), C.factory.sourceLocation(labelToken)));
11855
+ return ACTION(() => C.astFactory.blankNode(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
11749
11856
  } },
11750
11857
  { ALT: () => {
11751
11858
  const anonToken = CONSUME(terminals_exports.anon);
11752
- return ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocation(anonToken)));
11859
+ return ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocation(anonToken)));
11753
11860
  } }
11754
11861
  ]);
11755
11862
  ACTION(() => {
@@ -11759,15 +11866,15 @@ var blankNode = {
11759
11866
  });
11760
11867
  return result;
11761
11868
  },
11762
- gImpl: ({ PRINT_WORD }) => (ast, { factory }) => {
11763
- factory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11869
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory }) => {
11870
+ astFactory.printFilter(ast, () => PRINT_WORD("_:", ast.label.replace(/^e_/u, "")));
11764
11871
  }
11765
11872
  };
11766
11873
  var verbA = {
11767
11874
  name: "VerbA",
11768
11875
  impl: ({ ACTION, CONSUME }) => (C) => {
11769
11876
  const token = CONSUME(a);
11770
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11877
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE, void 0));
11771
11878
  }
11772
11879
  };
11773
11880
 
@@ -11784,7 +11891,7 @@ var prologue = {
11784
11891
  ]));
11785
11892
  return result;
11786
11893
  },
11787
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
11894
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
11788
11895
  for (const context of ast) {
11789
11896
  if (F3.isContextDefinitionBase(context)) {
11790
11897
  SUBRULE(baseDecl2, context);
@@ -11799,11 +11906,12 @@ var baseDecl2 = {
11799
11906
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
11800
11907
  const base = CONSUME(baseDecl);
11801
11908
  const val = SUBRULE(iriFull);
11802
- return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
11909
+ return ACTION(() => C.astFactory.contextDefinitionBase(C.astFactory.sourceLocation(base, val), val));
11803
11910
  },
11804
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
11911
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
11805
11912
  F3.printFilter(ast, () => PRINT_WORD("BASE"));
11806
11913
  SUBRULE(iri2, ast.value);
11914
+ F3.printFilter(ast, () => PRINT_WORD("\n"));
11807
11915
  }
11808
11916
  };
11809
11917
  var prefixDecl2 = {
@@ -11812,13 +11920,14 @@ var prefixDecl2 = {
11812
11920
  const prefix = CONSUME(prefixDecl);
11813
11921
  const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
11814
11922
  const value = SUBRULE(iriFull);
11815
- return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
11923
+ return ACTION(() => C.astFactory.contextDefinitionPrefix(C.astFactory.sourceLocation(prefix, value), name, value));
11816
11924
  },
11817
- gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F3 }) => {
11925
+ gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
11818
11926
  F3.printFilter(ast, () => {
11819
11927
  PRINT_WORDS("PREFIX", `${ast.key}:`);
11820
11928
  });
11821
11929
  SUBRULE(iri2, ast.value);
11930
+ F3.printFilter(ast, () => PRINT_WORDS("\n"));
11822
11931
  }
11823
11932
  };
11824
11933
  var verb = {
@@ -11834,7 +11943,7 @@ var varOrTerm = {
11834
11943
  { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
11835
11944
  { ALT: () => SUBRULE(graphTerm) }
11836
11945
  ]),
11837
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
11946
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
11838
11947
  if (F3.isTermVariable(ast)) {
11839
11948
  return SUBRULE(var_, ast);
11840
11949
  }
@@ -11855,9 +11964,9 @@ var var_ = {
11855
11964
  { ALT: () => CONSUME(terminals_exports.var1) },
11856
11965
  { ALT: () => CONSUME(terminals_exports.var2) }
11857
11966
  ]);
11858
- return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
11967
+ return ACTION(() => C.astFactory.variable(varToken.image.slice(1), C.astFactory.sourceLocation(varToken)));
11859
11968
  },
11860
- gImpl: ({ PRINT_WORD }) => (ast, { factory: F3 }) => {
11969
+ gImpl: ({ PRINT_WORD }) => (ast, { astFactory: F3 }) => {
11861
11970
  F3.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
11862
11971
  }
11863
11972
  };
@@ -11871,10 +11980,10 @@ var graphTerm = {
11871
11980
  { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
11872
11981
  { ALT: () => {
11873
11982
  const tokenNil = CONSUME(terminals_exports.nil);
11874
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
11983
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(tokenNil), CommonIRIs.NIL));
11875
11984
  } }
11876
11985
  ]),
11877
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
11986
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
11878
11987
  if (F3.isTermNamed(ast)) {
11879
11988
  SUBRULE(iri2, ast);
11880
11989
  } else if (F3.isTermLiteral(ast)) {
@@ -11894,14 +12003,14 @@ function datasetClauseUsing(name, token) {
11894
12003
  return OR([
11895
12004
  { ALT: () => {
11896
12005
  const iri3 = SUBRULE(defaultGraphClause);
11897
- return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
12006
+ return ACTION(() => C.astFactory.wrap({ clauseType: "default", value: iri3 }, C.astFactory.sourceLocation(start, iri3)));
11898
12007
  } },
11899
12008
  { ALT: () => {
11900
12009
  const namedClause = SUBRULE(namedGraphClause);
11901
- return ACTION(() => C.factory.wrap({
12010
+ return ACTION(() => C.astFactory.wrap({
11902
12011
  clauseType: "named",
11903
12012
  value: namedClause.val
11904
- }, C.factory.sourceLocation(start, namedClause)));
12013
+ }, C.astFactory.sourceLocation(start, namedClause)));
11905
12014
  } }
11906
12015
  ]);
11907
12016
  }
@@ -11922,9 +12031,9 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
11922
12031
  const clause = SUBRULE(subRule);
11923
12032
  clauses.push(clause);
11924
12033
  });
11925
- return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
12034
+ return ACTION(() => C.astFactory.datasetClauses(clauses.map((clause) => clause.val), C.astFactory.sourceLocation(...clauses)));
11926
12035
  },
11927
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
12036
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
11928
12037
  for (const clause of ast.clauses) {
11929
12038
  F3.printFilter(ast, () => PRINT_WORD(fromUsing));
11930
12039
  if (clause.clauseType === "named") {
@@ -11942,7 +12051,7 @@ var namedGraphClause = {
11942
12051
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
11943
12052
  const named2 = CONSUME(graph_exports.named);
11944
12053
  const iri3 = SUBRULE(sourceSelector);
11945
- return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
12054
+ return ACTION(() => C.astFactory.wrap(iri3, C.astFactory.sourceLocation(named2, iri3)));
11946
12055
  }
11947
12056
  };
11948
12057
  var sourceSelector = {
@@ -11959,7 +12068,7 @@ function funcExpr1(func) {
11959
12068
  CONSUME(symbols_exports.LParen);
11960
12069
  const arg = SUBRULE(expression);
11961
12070
  const close = CONSUME(symbols_exports.RParen);
11962
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12071
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
11963
12072
  }
11964
12073
  };
11965
12074
  }
@@ -11973,7 +12082,7 @@ function funcExpr2(func) {
11973
12082
  CONSUME(symbols_exports.comma);
11974
12083
  const arg2 = SUBRULE2(expression);
11975
12084
  const close = CONSUME(symbols_exports.RParen);
11976
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
12085
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
11977
12086
  }
11978
12087
  };
11979
12088
  }
@@ -11989,7 +12098,7 @@ function funcExpr3(func) {
11989
12098
  CONSUME2(symbols_exports.comma);
11990
12099
  const arg3 = SUBRULE3(expression);
11991
12100
  const close = CONSUME(symbols_exports.RParen);
11992
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
12101
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
11993
12102
  }
11994
12103
  };
11995
12104
  }
@@ -12001,7 +12110,7 @@ function funcVar1(func) {
12001
12110
  CONSUME(symbols_exports.LParen);
12002
12111
  const arg = SUBRULE(var_);
12003
12112
  const close = CONSUME(symbols_exports.RParen);
12004
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12113
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
12005
12114
  }
12006
12115
  };
12007
12116
  }
@@ -12015,11 +12124,11 @@ function funcExprOrNil1(func) {
12015
12124
  CONSUME(symbols_exports.LParen);
12016
12125
  const arg = SUBRULE(expression);
12017
12126
  const close = CONSUME(symbols_exports.RParen);
12018
- return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
12127
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
12019
12128
  } },
12020
12129
  { ALT: () => {
12021
12130
  const nil2 = CONSUME(terminals_exports.nil);
12022
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
12131
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
12023
12132
  } }
12024
12133
  ]);
12025
12134
  }
@@ -12031,7 +12140,7 @@ function funcNil1(func) {
12031
12140
  impl: ({ ACTION, CONSUME }) => (C) => {
12032
12141
  const operator = CONSUME(func);
12033
12142
  const nil2 = CONSUME(terminals_exports.nil);
12034
- return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
12143
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil2)));
12035
12144
  }
12036
12145
  };
12037
12146
  }
@@ -12041,7 +12150,7 @@ function funcExprList1(func) {
12041
12150
  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
12042
12151
  const operator = CONSUME(func);
12043
12152
  const args = SUBRULE(expressionList);
12044
- return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
12153
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, args.val, C.astFactory.sourceLocation(operator, args)));
12045
12154
  }
12046
12155
  };
12047
12156
  }
@@ -12059,7 +12168,7 @@ function funcExpr2or3(func) {
12059
12168
  return SUBRULE3(expression);
12060
12169
  });
12061
12170
  const close = CONSUME(symbols_exports.RParen);
12062
- return ACTION(() => C.factory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.factory.sourceLocation(operator, close)));
12171
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
12063
12172
  }
12064
12173
  };
12065
12174
  }
@@ -12079,7 +12188,7 @@ function funcExpr3or4(func) {
12079
12188
  return SUBRULE4(expression);
12080
12189
  });
12081
12190
  const close = CONSUME(symbols_exports.RParen);
12082
- return ACTION(() => C.factory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
12191
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
12083
12192
  }
12084
12193
  };
12085
12194
  }
@@ -12089,7 +12198,7 @@ function funcGroupGraphPattern(func) {
12089
12198
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12090
12199
  const operator = CONSUME(func);
12091
12200
  const group = SUBRULE(groupGraphPattern);
12092
- return ACTION(() => C.factory.expressionPatternOperation(operator.image, group, C.factory.sourceLocation(operator, group)));
12201
+ return ACTION(() => C.astFactory.expressionPatternOperation(operator.image, group, C.astFactory.sourceLocation(operator, group)));
12093
12202
  }
12094
12203
  };
12095
12204
  }
@@ -12102,7 +12211,7 @@ function baseAggregateFunc(func) {
12102
12211
  const distinct2 = OPTION(() => CONSUME(distinct));
12103
12212
  const expr1 = SUBRULE(expression);
12104
12213
  const close = CONSUME(symbols_exports.RParen);
12105
- return ACTION(() => C.factory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.factory.sourceLocation(operator, close)));
12214
+ return ACTION(() => C.astFactory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.astFactory.sourceLocation(operator, close)));
12106
12215
  }
12107
12216
  };
12108
12217
  }
@@ -12242,17 +12351,17 @@ var aggregateCount = {
12242
12351
  const expressionVal = OR([
12243
12352
  { ALT: () => {
12244
12353
  const starToken = CONSUME(symbols_exports.star);
12245
- return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
12354
+ return ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(starToken)));
12246
12355
  } },
12247
12356
  { ALT: () => SUBRULE(expression) }
12248
12357
  ]);
12249
12358
  const closeToken = CONSUME(symbols_exports.RParen);
12250
12359
  return ACTION(() => {
12251
- const F3 = C.factory;
12252
- if (C.factory.isWildcard(expressionVal)) {
12253
- return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12360
+ const F3 = C.astFactory;
12361
+ if (C.astFactory.isWildcard(expressionVal)) {
12362
+ return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
12254
12363
  }
12255
- return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
12364
+ return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.astFactory.sourceLocation(operatorToken, closeToken));
12256
12365
  });
12257
12366
  }
12258
12367
  };
@@ -12276,7 +12385,7 @@ var aggregateGroup_concat = {
12276
12385
  });
12277
12386
  const closeToken = CONSUME(symbols_exports.RParen);
12278
12387
  return ACTION(() => {
12279
- const F3 = C.factory;
12388
+ const F3 = C.astFactory;
12280
12389
  return F3.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F3.sourceLocation(operatorToken, closeToken));
12281
12390
  });
12282
12391
  }
@@ -12306,7 +12415,7 @@ var aggregate = {
12306
12415
  });
12307
12416
  return result;
12308
12417
  },
12309
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
12418
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12310
12419
  F3.printFilter(ast, () => {
12311
12420
  PRINT_WORD(ast.aggregation.toUpperCase(), "(");
12312
12421
  if (ast.distinct) {
@@ -12333,7 +12442,7 @@ var path = {
12333
12442
  };
12334
12443
  var pathGenerator = {
12335
12444
  name: "path",
12336
- gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F3 }, braces = true) => {
12445
+ gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F3 }, braces = true) => {
12337
12446
  if (F3.isTerm(ast) && F3.isTermNamed(ast)) {
12338
12447
  SUBRULE(iri2, ast);
12339
12448
  } else {
@@ -12382,7 +12491,7 @@ function pathChainHelper(name, SEP, subType, subRule) {
12382
12491
  tailEnd = SUBRULE2(subRule);
12383
12492
  tail.push(tailEnd);
12384
12493
  });
12385
- return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
12494
+ return ACTION(() => tail.length === 0 ? head2 : C.astFactory.path(subType, [head2, ...tail], C.astFactory.sourceLocation(head2, tailEnd)));
12386
12495
  }
12387
12496
  };
12388
12497
  }
@@ -12393,7 +12502,7 @@ var pathEltOrInverse = {
12393
12502
  { ALT: () => {
12394
12503
  const hat2 = CONSUME(symbols_exports.hat);
12395
12504
  const item = SUBRULE2(pathElt);
12396
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12505
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12397
12506
  } }
12398
12507
  ])
12399
12508
  };
@@ -12404,7 +12513,7 @@ var pathElt = {
12404
12513
  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
12405
12514
  const item = SUBRULE(pathPrimary);
12406
12515
  const modification = OPTION(() => SUBRULE(pathMod));
12407
- return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
12516
+ return ACTION(() => modification === void 0 ? item : C.astFactory.path(modification.image, [item], C.astFactory.sourceLocation(item, modification)));
12408
12517
  }
12409
12518
  };
12410
12519
  var pathMod = {
@@ -12436,7 +12545,7 @@ var pathNegatedPropertySet = {
12436
12545
  return OR([
12437
12546
  { ALT: () => {
12438
12547
  const noAlternative = SUBRULE1(pathOneInPropertySet);
12439
- return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
12548
+ return ACTION(() => C.astFactory.path("!", [noAlternative], C.astFactory.sourceLocation(exclamation2, noAlternative)));
12440
12549
  } },
12441
12550
  { ALT: () => {
12442
12551
  const open = CONSUME(symbols_exports.LParen);
@@ -12449,7 +12558,7 @@ var pathNegatedPropertySet = {
12449
12558
  });
12450
12559
  const close = CONSUME(symbols_exports.RParen);
12451
12560
  return ACTION(() => {
12452
- const F3 = C.factory;
12561
+ const F3 = C.astFactory;
12453
12562
  if (tail.length === 0) {
12454
12563
  return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
12455
12564
  }
@@ -12470,7 +12579,7 @@ var pathOneInPropertySet = {
12470
12579
  { ALT: () => SUBRULE2(iri2) },
12471
12580
  { ALT: () => SUBRULE2(verbA) }
12472
12581
  ]);
12473
- return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
12582
+ return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat2, item)));
12474
12583
  } }
12475
12584
  ])
12476
12585
  };
@@ -12495,33 +12604,35 @@ function triplesDotSeperated(triplesSameSubjectSubrule) {
12495
12604
  });
12496
12605
  }
12497
12606
  });
12498
- return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
12607
+ return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
12499
12608
  };
12500
12609
  }
12501
12610
  var triplesBlock = {
12502
12611
  name: "triplesBlock",
12503
12612
  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
12504
- gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
12613
+ gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
12505
12614
  for (const [index, triple] of ast.triples.entries()) {
12506
12615
  HANDLE_LOC(triple, () => {
12507
12616
  const nextTriple = ast.triples.at(index);
12508
12617
  if (F3.isTripleCollection(triple)) {
12509
12618
  SUBRULE(graphNodePath, triple);
12510
- F3.printFilter(triple, () => PRINT_WORD("."));
12619
+ F3.printFilter(triple, () => PRINT_WORD(".\n"));
12511
12620
  } else {
12512
12621
  SUBRULE(graphNodePath, triple.subject);
12622
+ F3.printFilter(triple, () => PRINT_WORD(""));
12513
12623
  if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
12514
12624
  SUBRULE(varOrTerm, triple.predicate);
12515
12625
  } else {
12516
12626
  SUBRULE(pathGenerator, triple.predicate, void 0);
12517
12627
  }
12628
+ F3.printFilter(triple, () => PRINT_WORD(""));
12518
12629
  SUBRULE(graphNodePath, triple.object);
12519
12630
  if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
12520
- F3.printFilter(ast, () => PRINT_WORD("."));
12631
+ F3.printFilter(ast, () => PRINT_WORD(".\n"));
12521
12632
  } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
12522
12633
  F3.printFilter(ast, () => PRINT_WORD(","));
12523
12634
  } else {
12524
- F3.printFilter(ast, () => PRINT_WORD(";"));
12635
+ F3.printFilter(ast, () => PRINT_WORD(";\n"));
12525
12636
  }
12526
12637
  }
12527
12638
  });
@@ -12534,24 +12645,24 @@ function triplesSameSubjectImpl(name, allowPaths) {
12534
12645
  impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
12535
12646
  { ALT: () => {
12536
12647
  const subject = SUBRULE(varOrTerm);
12537
- const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.factory.dematerialized(subject)));
12648
+ const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
12538
12649
  return ACTION(() => {
12539
12650
  if (res.length > 0) {
12540
12651
  res[0].subject = subject;
12541
- res[0].loc = C.factory.sourceLocation(subject, res[0]);
12652
+ res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
12542
12653
  }
12543
12654
  return res;
12544
12655
  });
12545
12656
  } },
12546
12657
  { ALT: () => {
12547
12658
  const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
12548
- const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.factory.graphNodeIdentifier(subjectNode)));
12659
+ const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
12549
12660
  return ACTION(() => {
12550
12661
  if (restNode.length === 0) {
12551
12662
  return [subjectNode];
12552
12663
  }
12553
12664
  restNode[0].subject = subjectNode;
12554
- restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
12665
+ restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
12555
12666
  return restNode;
12556
12667
  });
12557
12668
  } }
@@ -12635,7 +12746,7 @@ function objectImpl(name, allowPaths) {
12635
12746
  name,
12636
12747
  impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
12637
12748
  const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
12638
- return ACTION(() => C.factory.triple(subject, predicate, node));
12749
+ return ACTION(() => C.astFactory.triple(subject, predicate, node));
12639
12750
  }
12640
12751
  };
12641
12752
  }
@@ -12652,7 +12763,7 @@ function collectionImpl(name, allowPaths) {
12652
12763
  });
12653
12764
  const endToken = CONSUME(symbols_exports.RParen);
12654
12765
  return ACTION(() => {
12655
- const F3 = C.factory;
12766
+ const F3 = C.astFactory;
12656
12767
  const triples = [];
12657
12768
  const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
12658
12769
  const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
@@ -12676,7 +12787,7 @@ function collectionImpl(name, allowPaths) {
12676
12787
  return F3.tripleCollectionList(listHead, triples, F3.sourceLocation(startToken, endToken));
12677
12788
  });
12678
12789
  },
12679
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
12790
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12680
12791
  F3.printFilter(ast, () => PRINT_WORD("("));
12681
12792
  for (const [idx, triple] of ast.triples.entries()) {
12682
12793
  if (idx % 2 === 0) {
@@ -12707,13 +12818,17 @@ function blankNodePropertyListImpl(name, allowPaths) {
12707
12818
  name,
12708
12819
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12709
12820
  const startToken = CONSUME(symbols_exports.LSquare);
12710
- const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
12821
+ const blankNode2 = ACTION(() => C.astFactory.blankNode(void 0, C.astFactory.sourceLocationNoMaterialize()));
12711
12822
  const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
12712
12823
  const endToken = CONSUME(symbols_exports.RSquare);
12713
- return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
12824
+ return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.astFactory.sourceLocation(startToken, endToken)));
12714
12825
  },
12715
- gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
12716
- F3.printFilter(ast, () => PRINT("["));
12826
+ gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, c) => {
12827
+ const { astFactory: F3, indentInc } = c;
12828
+ F3.printFilter(ast, () => {
12829
+ c[traqulaIndentation] += indentInc;
12830
+ PRINT("[\n");
12831
+ });
12717
12832
  for (const triple of ast.triples) {
12718
12833
  HANDLE_LOC(triple, () => {
12719
12834
  if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
@@ -12721,11 +12836,15 @@ function blankNodePropertyListImpl(name, allowPaths) {
12721
12836
  } else {
12722
12837
  SUBRULE(pathGenerator, triple.predicate, void 0);
12723
12838
  }
12839
+ F3.printFilter(triple, () => PRINT_WORD(""));
12724
12840
  SUBRULE(graphNodePath, triple.object);
12725
- F3.printFilter(ast, () => PRINT_WORD(";"));
12841
+ F3.printFilter(ast, () => PRINT_WORD(";\n"));
12726
12842
  });
12727
12843
  }
12728
- F3.printFilter(ast, () => PRINT("]"));
12844
+ F3.printFilter(ast, () => {
12845
+ c[traqulaIndentation] -= indentInc;
12846
+ PRINT_ON_EMPTY("]");
12847
+ });
12729
12848
  }
12730
12849
  };
12731
12850
  }
@@ -12742,7 +12861,7 @@ function graphNodeImpl(name, allowPaths) {
12742
12861
  ALT: () => SUBRULE(triplesNodeRule)
12743
12862
  }
12744
12863
  ]),
12745
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
12864
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
12746
12865
  if (F3.isTerm(ast)) {
12747
12866
  SUBRULE(varOrTerm, ast);
12748
12867
  } else {
@@ -12760,9 +12879,9 @@ var whereClause = {
12760
12879
  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
12761
12880
  const where2 = OPTION(() => CONSUME(where));
12762
12881
  const group = SUBRULE(groupGraphPattern);
12763
- return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
12882
+ return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where2, group)));
12764
12883
  },
12765
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
12884
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12766
12885
  F3.printFilter(ast, () => PRINT_WORD("WHERE"));
12767
12886
  SUBRULE(groupGraphPattern, ast.val);
12768
12887
  }
@@ -12776,19 +12895,26 @@ var groupGraphPattern = {
12776
12895
  { ALT: () => SUBRULE(groupGraphPatternSub) }
12777
12896
  ]);
12778
12897
  const close = CONSUME(symbols_exports.RCurly);
12779
- return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
12898
+ return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
12780
12899
  },
12781
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
12782
- F3.printFilter(ast, () => PRINT_WORD("{"));
12900
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
12901
+ const { astFactory: F3, indentInc } = C;
12902
+ F3.printFilter(ast, () => {
12903
+ C[traqulaIndentation] += indentInc;
12904
+ PRINT_WORD("{\n");
12905
+ });
12783
12906
  for (const pattern of ast.patterns) {
12784
12907
  SUBRULE(generatePattern, pattern);
12785
12908
  }
12786
- F3.printFilter(ast, () => PRINT_WORD("}"));
12909
+ F3.printFilter(ast, () => {
12910
+ C[traqulaIndentation] -= indentInc;
12911
+ PRINT_ON_EMPTY("}\n");
12912
+ });
12787
12913
  }
12788
12914
  };
12789
12915
  var generatePattern = {
12790
12916
  name: "generatePattern",
12791
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
12917
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
12792
12918
  if (ast.type === "query") {
12793
12919
  SUBRULE(query, F3.querySelect({
12794
12920
  context: [],
@@ -12877,9 +13003,9 @@ var optionalGraphPattern = {
12877
13003
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12878
13004
  const optional2 = CONSUME(optional);
12879
13005
  const group = SUBRULE(groupGraphPattern);
12880
- return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
13006
+ return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional2, group)));
12881
13007
  },
12882
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13008
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12883
13009
  F3.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
12884
13010
  SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
12885
13011
  }
@@ -12890,9 +13016,9 @@ var graphGraphPattern = {
12890
13016
  const graph2 = CONSUME(graph_exports.graph);
12891
13017
  const name = SUBRULE(varOrIri);
12892
13018
  const group = SUBRULE(groupGraphPattern);
12893
- return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
13019
+ return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph2, group)));
12894
13020
  },
12895
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13021
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12896
13022
  F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
12897
13023
  SUBRULE(varOrTerm, ast.name);
12898
13024
  SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
@@ -12908,9 +13034,9 @@ var serviceGraphPattern = {
12908
13034
  }) ?? false;
12909
13035
  const name = SUBRULE1(varOrIri);
12910
13036
  const group = SUBRULE1(groupGraphPattern);
12911
- return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
13037
+ return ACTION(() => C.astFactory.patternService(name, group.patterns, silent2, C.astFactory.sourceLocation(service2, group)));
12912
13038
  },
12913
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13039
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12914
13040
  F3.printFilter(ast, () => {
12915
13041
  PRINT_WORD("SERVICE");
12916
13042
  if (ast.silent) {
@@ -12930,14 +13056,14 @@ var bind2 = {
12930
13056
  CONSUME(as);
12931
13057
  const variable = SUBRULE(var_);
12932
13058
  const close = CONSUME(symbols_exports.RParen);
12933
- return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
13059
+ return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind3, close)));
12934
13060
  },
12935
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13061
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
12936
13062
  F3.printFilter(ast, () => PRINT_WORD("BIND", "("));
12937
13063
  SUBRULE(expression, ast.expression);
12938
13064
  F3.printFilter(ast, () => PRINT_WORD("AS"));
12939
13065
  SUBRULE(var_, ast.variable);
12940
- F3.printFilter(ast, () => PRINT_WORD(")"));
13066
+ F3.printFilter(ast, () => PRINT_WORD(")\n"));
12941
13067
  }
12942
13068
  };
12943
13069
  var inlineData = {
@@ -12945,16 +13071,19 @@ var inlineData = {
12945
13071
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
12946
13072
  const values3 = CONSUME(values2);
12947
13073
  const datablock = SUBRULE(dataBlock);
12948
- return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
13074
+ return ACTION(() => C.astFactory.patternValues(datablock.val, C.astFactory.sourceLocation(values3, datablock)));
12949
13075
  },
12950
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13076
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
13077
+ const { astFactory: F3, indentInc } = C;
12951
13078
  const variables = Object.keys(ast.values.at(0) ?? {});
12952
13079
  F3.printFilter(ast, () => {
13080
+ PRINT_ON_EMPTY("");
12953
13081
  PRINT_WORD("VALUES", "(");
12954
13082
  for (const variable of variables) {
12955
13083
  PRINT_WORD(`?${variable}`);
12956
13084
  }
12957
- PRINT_WORD(")", "{");
13085
+ C[traqulaIndentation] += indentInc;
13086
+ PRINT_WORD(")", "{\n");
12958
13087
  });
12959
13088
  for (const mapping of ast.values) {
12960
13089
  F3.printFilter(ast, () => PRINT_WORD("("));
@@ -12965,9 +13094,12 @@ var inlineData = {
12965
13094
  SUBRULE(graphNodePath, mapping[variable]);
12966
13095
  }
12967
13096
  }
12968
- F3.printFilter(ast, () => PRINT_WORD(")"));
13097
+ F3.printFilter(ast, () => PRINT_WORD(")\n"));
12969
13098
  }
12970
- F3.printFilter(ast, () => PRINT_WORD("}"));
13099
+ F3.printFilter(ast, () => {
13100
+ C[traqulaIndentation] -= indentInc;
13101
+ PRINT_ON_EMPTY("}\n");
13102
+ });
12971
13103
  }
12972
13104
  };
12973
13105
  var dataBlock = {
@@ -12990,7 +13122,7 @@ var inlineDataOneVar = {
12990
13122
  });
12991
13123
  });
12992
13124
  const close = CONSUME(symbols_exports.RCurly);
12993
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
13125
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(varVal, close)));
12994
13126
  }
12995
13127
  };
12996
13128
  var inlineDataFull = {
@@ -13007,7 +13139,7 @@ var inlineDataFull = {
13007
13139
  res.push({});
13008
13140
  });
13009
13141
  const close = CONSUME1(symbols_exports.RCurly);
13010
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
13142
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(nil2, close)));
13011
13143
  } },
13012
13144
  { ALT: () => {
13013
13145
  const open = CONSUME1(symbols_exports.LParen);
@@ -13039,7 +13171,7 @@ var inlineDataFull = {
13039
13171
  });
13040
13172
  });
13041
13173
  const close = CONSUME2(symbols_exports.RCurly);
13042
- return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
13174
+ return ACTION(() => C.astFactory.wrap(res, C.astFactory.sourceLocation(open, close)));
13043
13175
  } }
13044
13176
  ]);
13045
13177
  }
@@ -13062,9 +13194,9 @@ var minusGraphPattern = {
13062
13194
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13063
13195
  const minus2 = CONSUME(minus);
13064
13196
  const group = SUBRULE(groupGraphPattern);
13065
- return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
13197
+ return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus2, group)));
13066
13198
  },
13067
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13199
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13068
13200
  F3.printFilter(ast, () => PRINT_WORD("MINUS"));
13069
13201
  SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
13070
13202
  }
@@ -13080,9 +13212,9 @@ var groupOrUnionGraphPattern = {
13080
13212
  const group2 = SUBRULE2(groupGraphPattern);
13081
13213
  groups.push(group2);
13082
13214
  });
13083
- return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
13215
+ return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
13084
13216
  },
13085
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13217
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13086
13218
  if (F3.isPatternUnion(ast)) {
13087
13219
  const [head2, ...tail] = ast.patterns;
13088
13220
  SUBRULE(groupGraphPattern, head2);
@@ -13100,12 +13232,12 @@ var filter3 = {
13100
13232
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
13101
13233
  const filterToken = CONSUME(filter2);
13102
13234
  const expression2 = SUBRULE(constraint);
13103
- return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
13235
+ return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
13104
13236
  },
13105
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13237
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13106
13238
  F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
13107
13239
  SUBRULE(expression, ast.expression);
13108
- F3.printFilter(ast, () => PRINT_WORD(")"));
13240
+ F3.printFilter(ast, () => PRINT_WORD(")\n"));
13109
13241
  }
13110
13242
  };
13111
13243
  var constraint = {
@@ -13121,7 +13253,7 @@ var functionCall = {
13121
13253
  impl: ({ ACTION, SUBRULE }) => (C) => {
13122
13254
  const func = SUBRULE(iri2);
13123
13255
  const args = SUBRULE(argList);
13124
- return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
13256
+ return ACTION(() => C.astFactory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.astFactory.sourceLocation(func, args)));
13125
13257
  }
13126
13258
  };
13127
13259
 
@@ -13131,7 +13263,7 @@ var argList = {
13131
13263
  impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
13132
13264
  { ALT: () => {
13133
13265
  const nil2 = CONSUME(terminals_exports.nil);
13134
- return ACTION(() => C.factory.wrap({ args: [], distinct: false }, C.factory.sourceLocation(nil2)));
13266
+ return ACTION(() => C.astFactory.wrap({ args: [], distinct: false }, C.astFactory.sourceLocation(nil2)));
13135
13267
  } },
13136
13268
  { ALT: () => {
13137
13269
  const args = [];
@@ -13148,10 +13280,10 @@ var argList = {
13148
13280
  }
13149
13281
  });
13150
13282
  const close = CONSUME(symbols_exports.RParen);
13151
- return ACTION(() => C.factory.wrap({ args, distinct: distinct2 }, C.factory.sourceLocation(open, close)));
13283
+ return ACTION(() => C.astFactory.wrap({ args, distinct: distinct2 }, C.astFactory.sourceLocation(open, close)));
13152
13284
  } }
13153
13285
  ]),
13154
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13286
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13155
13287
  F3.printFilter(ast, () => {
13156
13288
  PRINT_WORD("(");
13157
13289
  if (ast.val.distinct) {
@@ -13174,7 +13306,7 @@ var expressionList = {
13174
13306
  impl: ({ ACTION, CONSUME, MANY, OR, SUBRULE1, SUBRULE2 }) => (C) => OR([
13175
13307
  { ALT: () => {
13176
13308
  const nil2 = CONSUME(terminals_exports.nil);
13177
- return ACTION(() => C.factory.wrap([], C.factory.sourceLocation(nil2)));
13309
+ return ACTION(() => C.astFactory.wrap([], C.astFactory.sourceLocation(nil2)));
13178
13310
  } },
13179
13311
  { ALT: () => {
13180
13312
  const open = CONSUME(symbols_exports.LParen);
@@ -13186,7 +13318,7 @@ var expressionList = {
13186
13318
  args.push(expr);
13187
13319
  });
13188
13320
  const close = CONSUME(symbols_exports.RParen);
13189
- return ACTION(() => C.factory.wrap(args, C.factory.sourceLocation(open, close)));
13321
+ return ACTION(() => C.astFactory.wrap(args, C.astFactory.sourceLocation(open, close)));
13190
13322
  } }
13191
13323
  ])
13192
13324
  };
@@ -13195,7 +13327,7 @@ var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
13195
13327
  var expression = {
13196
13328
  name: "expression",
13197
13329
  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
13198
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13330
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13199
13331
  if (F3.isTerm(ast)) {
13200
13332
  SUBRULE(varOrTerm, ast);
13201
13333
  } else if (F3.isExpressionOperator(ast)) {
@@ -13260,7 +13392,7 @@ var conditionalOrExpression = {
13260
13392
  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
13261
13393
  CONSUME(symbols_exports.logicOr);
13262
13394
  const args = SUBRULE2(conditionalAndExpression);
13263
- return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
13395
+ return (left) => ACTION(() => C.astFactory.expressionOperation("||", [left, args], C.astFactory.sourceLocation(left, args)));
13264
13396
  }, ACTION, MANY)
13265
13397
  };
13266
13398
  var conditionalAndExpression = {
@@ -13268,7 +13400,7 @@ var conditionalAndExpression = {
13268
13400
  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
13269
13401
  CONSUME(symbols_exports.logicAnd);
13270
13402
  const arg = SUBRULE2(valueLogical);
13271
- return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
13403
+ return (left) => ACTION(() => C.astFactory.expressionOperation("&&", [left, arg], C.astFactory.sourceLocation(left, arg)));
13272
13404
  }, ACTION, MANY)
13273
13405
  };
13274
13406
  var valueLogical = {
@@ -13290,7 +13422,7 @@ var relationalExpression = {
13290
13422
  { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
13291
13423
  ]);
13292
13424
  const expr = SUBRULE2(numericExpression);
13293
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, expr], C.factory.sourceLocation(args1, expr)));
13425
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, expr], C.astFactory.sourceLocation(args1, expr)));
13294
13426
  } },
13295
13427
  { ALT: () => {
13296
13428
  const operator = OR3([
@@ -13298,7 +13430,7 @@ var relationalExpression = {
13298
13430
  { ALT: () => CONSUME(notIn) }
13299
13431
  ]);
13300
13432
  const args = SUBRULE1(expressionList);
13301
- return ACTION(() => C.factory.expressionOperation(operator.image, [args1, ...args.val], C.factory.sourceLocation(args1, args)));
13433
+ return ACTION(() => C.astFactory.expressionOperation(operator.image, [args1, ...args.val], C.astFactory.sourceLocation(args1, args)));
13302
13434
  } }
13303
13435
  ]));
13304
13436
  return expression2 ?? args1;
@@ -13317,7 +13449,7 @@ var additiveExpression = {
13317
13449
  { ALT: () => CONSUME(symbols_exports.opMinus) }
13318
13450
  ]);
13319
13451
  const arg = SUBRULE2(multiplicativeExpression);
13320
- return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
13452
+ return ACTION(() => (left) => C.astFactory.expressionOperation(operator.image, [left, arg], C.astFactory.sourceLocation(left, arg)));
13321
13453
  } },
13322
13454
  { ALT: () => {
13323
13455
  const { operator, startInt } = OR3([
@@ -13348,9 +13480,9 @@ var additiveExpression = {
13348
13480
  { ALT: () => CONSUME(symbols_exports.slash) }
13349
13481
  ]);
13350
13482
  const innerExpr = SUBRULE1(unaryExpression);
13351
- return ACTION(() => (leftInner) => C.factory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.factory.sourceLocation(leftInner, innerExpr)));
13483
+ return ACTION(() => (leftInner) => C.astFactory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.astFactory.sourceLocation(leftInner, innerExpr)));
13352
13484
  }, ACTION, MANY2);
13353
- return (left) => C.factory.expressionOperation(operator, [left, multiplicativeExpr], C.factory.sourceLocation(left, multiplicativeExpr));
13485
+ return (left) => C.astFactory.expressionOperation(operator, [left, multiplicativeExpr], C.astFactory.sourceLocation(left, multiplicativeExpr));
13354
13486
  } }
13355
13487
  ]), ACTION, MANY1)
13356
13488
  };
@@ -13367,7 +13499,7 @@ var multiplicativeExpression = {
13367
13499
  subType: "operation",
13368
13500
  operator: operator.image,
13369
13501
  args: [left, expr],
13370
- loc: C.factory.sourceLocation(left, expr)
13502
+ loc: C.astFactory.sourceLocation(left, expr)
13371
13503
  });
13372
13504
  }, ACTION, MANY)
13373
13505
  };
@@ -13382,7 +13514,7 @@ var unaryExpression = {
13382
13514
  { ALT: () => CONSUME(symbols_exports.opMinus) }
13383
13515
  ]);
13384
13516
  const expr = SUBRULE2(primaryExpression);
13385
- return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
13517
+ return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
13386
13518
  } }
13387
13519
  ])
13388
13520
  };
@@ -13405,7 +13537,7 @@ var brackettedExpression = {
13405
13537
  const expr = SUBRULE(expression);
13406
13538
  const close = CONSUME(symbols_exports.RParen);
13407
13539
  return ACTION(() => {
13408
- expr.loc = C.factory.sourceLocation(open, close);
13540
+ expr.loc = C.astFactory.sourceLocation(open, close);
13409
13541
  return expr;
13410
13542
  });
13411
13543
  }
@@ -13427,13 +13559,13 @@ var iriOrFunction = {
13427
13559
  function: iriVal,
13428
13560
  args: args.val.args,
13429
13561
  distinct: distinct2,
13430
- loc: C.factory.sourceLocation(iriVal, args)
13562
+ loc: C.astFactory.sourceLocation(iriVal, args)
13431
13563
  };
13432
13564
  });
13433
13565
  });
13434
13566
  return functionCall2 ?? iriVal;
13435
13567
  },
13436
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
13568
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
13437
13569
  if (F3.isTermNamed(ast)) {
13438
13570
  SUBRULE(iri2, ast);
13439
13571
  } else {
@@ -13486,11 +13618,14 @@ var groupClause = {
13486
13618
  type: "solutionModifier",
13487
13619
  subType: "group",
13488
13620
  groupings,
13489
- loc: C.factory.sourceLocation(start, groupings.at(-1))
13621
+ loc: C.astFactory.sourceLocation(start, groupings.at(-1))
13490
13622
  }));
13491
13623
  },
13492
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
13493
- F3.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
13624
+ gImpl: ({ PRINT_WORDS, SUBRULE, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
13625
+ F3.printFilter(ast, () => {
13626
+ PRINT_ON_EMPTY("");
13627
+ PRINT_WORDS("GROUP", "BY");
13628
+ });
13494
13629
  for (const grouping of ast.groupings) {
13495
13630
  if (F3.isExpression(grouping)) {
13496
13631
  SUBRULE(expression, grouping);
@@ -13524,7 +13659,7 @@ var groupCondition = {
13524
13659
  return {
13525
13660
  variable,
13526
13661
  value: expressionValue,
13527
- loc: C.factory.sourceLocation(open, close)
13662
+ loc: C.astFactory.sourceLocation(open, close)
13528
13663
  };
13529
13664
  }
13530
13665
  return expressionValue;
@@ -13543,10 +13678,13 @@ var havingClause = {
13543
13678
  expressions.push(SUBRULE(havingCondition));
13544
13679
  });
13545
13680
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13546
- return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
13681
+ return ACTION(() => C.astFactory.solutionModifierHaving(expressions, C.astFactory.sourceLocation(having2, expressions.at(-1))));
13547
13682
  },
13548
- gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F3 }) => {
13549
- F3.printFilter(ast, () => PRINT_WORD("HAVING"));
13683
+ gImpl: ({ PRINT_WORD, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
13684
+ F3.printFilter(ast, () => {
13685
+ PRINT_ON_EMPTY("");
13686
+ PRINT_WORD("HAVING");
13687
+ });
13550
13688
  for (const having2 of ast.having) {
13551
13689
  SUBRULE(expression, having2);
13552
13690
  }
@@ -13567,10 +13705,13 @@ var orderClause = {
13567
13705
  orderings.push(SUBRULE1(orderCondition));
13568
13706
  });
13569
13707
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13570
- return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
13708
+ return ACTION(() => C.astFactory.solutionModifierOrder(orderings, C.astFactory.sourceLocation(order2, orderings.at(-1))));
13571
13709
  },
13572
- gImpl: ({ PRINT_WORDS, SUBRULE }) => (ast, { factory: F3 }) => {
13573
- F3.printFilter(ast, () => PRINT_WORDS("ORDER", "BY"));
13710
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY, SUBRULE }) => (ast, { astFactory: F3 }) => {
13711
+ F3.printFilter(ast, () => {
13712
+ PRINT_ON_EMPTY("");
13713
+ PRINT_WORDS("ORDER", "BY");
13714
+ });
13574
13715
  for (const ordering of ast.orderDefs) {
13575
13716
  if (ordering.descending) {
13576
13717
  F3.printFilter(ast, () => PRINT_WORDS("DESC"));
@@ -13601,7 +13742,7 @@ var orderCondition = {
13601
13742
  return ACTION(() => ({
13602
13743
  expression: expr,
13603
13744
  descending: descending[0],
13604
- loc: C.factory.sourceLocation(descending[1], expr)
13745
+ loc: C.astFactory.sourceLocation(descending[1], expr)
13605
13746
  }));
13606
13747
  } },
13607
13748
  { ALT: () => {
@@ -13620,16 +13761,17 @@ var limitOffsetClauses = {
13620
13761
  { ALT: () => {
13621
13762
  const limit2 = SUBRULE1(limitClause);
13622
13763
  const offset2 = OPTION1(() => SUBRULE1(offsetClause));
13623
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13764
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.astFactory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
13624
13765
  } },
13625
13766
  { ALT: () => {
13626
13767
  const offset2 = SUBRULE2(offsetClause);
13627
13768
  const limit2 = OPTION2(() => SUBRULE2(limitClause));
13628
- return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
13769
+ return ACTION(() => C.astFactory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.astFactory.sourceLocation(offset2, limit2)));
13629
13770
  } }
13630
13771
  ]),
13631
- gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
13772
+ gImpl: ({ PRINT_WORDS, PRINT_ON_EMPTY }) => (ast, { astFactory: F3 }) => {
13632
13773
  F3.printFilter(ast, () => {
13774
+ PRINT_ON_EMPTY("");
13633
13775
  if (ast.limit) {
13634
13776
  PRINT_WORDS("LIMIT", String(ast.limit));
13635
13777
  }
@@ -13645,7 +13787,7 @@ var limitClause = {
13645
13787
  const offset2 = CONSUME(limit);
13646
13788
  const value = CONSUME(terminals_exports.integer);
13647
13789
  const val = Number.parseInt(value.image, 10);
13648
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13790
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13649
13791
  }
13650
13792
  };
13651
13793
  var offsetClause = {
@@ -13654,7 +13796,7 @@ var offsetClause = {
13654
13796
  const offset2 = CONSUME(offset);
13655
13797
  const value = CONSUME(terminals_exports.integer);
13656
13798
  const val = Number.parseInt(value.image, 10);
13657
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(offset2, value)));
13799
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(offset2, value)));
13658
13800
  }
13659
13801
  };
13660
13802
 
@@ -13679,10 +13821,10 @@ var query = {
13679
13821
  ...subType,
13680
13822
  type: "query",
13681
13823
  ...values3 && { values: values3 },
13682
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
13824
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
13683
13825
  }));
13684
13826
  },
13685
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
13827
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
13686
13828
  SUBRULE(prologue, ast.context);
13687
13829
  if (F3.isQuerySelect(ast)) {
13688
13830
  SUBRULE(selectQuery, ast);
@@ -13712,13 +13854,13 @@ var selectQuery = {
13712
13854
  solutionModifiers: modifiers,
13713
13855
  datasets: from2,
13714
13856
  ...selectVal.val,
13715
- loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13857
+ loc: C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13716
13858
  };
13717
13859
  queryIsGood(ret);
13718
13860
  return ret;
13719
13861
  });
13720
13862
  },
13721
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
13863
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
13722
13864
  SUBRULE(selectClause, F3.wrap({
13723
13865
  variables: ast.variables,
13724
13866
  distinct: ast.distinct,
@@ -13736,14 +13878,14 @@ var subSelect = {
13736
13878
  const where2 = SUBRULE(whereClause);
13737
13879
  const modifiers = SUBRULE(solutionModifier);
13738
13880
  const values3 = SUBRULE(valuesClause);
13739
- return ACTION(() => C.factory.querySelect({
13881
+ return ACTION(() => C.astFactory.querySelect({
13740
13882
  where: where2.val,
13741
- datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
13883
+ datasets: C.astFactory.datasetClauses([], C.astFactory.sourceLocation()),
13742
13884
  context: [],
13743
13885
  solutionModifiers: modifiers,
13744
13886
  ...selectVal.val,
13745
13887
  ...values3 && { values: values3 }
13746
- }, C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13888
+ }, C.astFactory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
13747
13889
  }
13748
13890
  };
13749
13891
  var selectClause = {
@@ -13774,7 +13916,7 @@ var selectClause = {
13774
13916
  const star2 = CONSUME(symbols_exports.star);
13775
13917
  return ACTION(() => {
13776
13918
  last2 = star2;
13777
- return { variables: [C.factory.wildcard(C.factory.sourceLocation(star2))], ...distRed };
13919
+ return { variables: [C.astFactory.wildcard(C.astFactory.sourceLocation(star2))], ...distRed };
13778
13920
  });
13779
13921
  } },
13780
13922
  { ALT: () => {
@@ -13804,7 +13946,7 @@ var selectClause = {
13804
13946
  throw new Error(`Variable ${variable.value} used more than once in SELECT clause`);
13805
13947
  }
13806
13948
  usedVars.push(variable);
13807
- variables.push(C.factory.patternBind(expr, variable, C.factory.sourceLocation(open, last2)));
13949
+ variables.push(C.astFactory.patternBind(expr, variable, C.astFactory.sourceLocation(open, last2)));
13808
13950
  });
13809
13951
  } }
13810
13952
  ]));
@@ -13812,9 +13954,9 @@ var selectClause = {
13812
13954
  } }
13813
13955
  ]);
13814
13956
  ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
13815
- return ACTION(() => C.factory.wrap(val, C.factory.sourceLocation(select2, last2)));
13957
+ return ACTION(() => C.astFactory.wrap(val, C.astFactory.sourceLocation(select2, last2)));
13816
13958
  },
13817
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
13959
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13818
13960
  F3.printFilter(ast, () => {
13819
13961
  PRINT_WORD("SELECT");
13820
13962
  if (ast.val.distinct) {
@@ -13854,7 +13996,7 @@ var constructQuery = {
13854
13996
  datasets: from2,
13855
13997
  where: where2.val,
13856
13998
  solutionModifiers: modifiers,
13857
- loc: C.factory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13999
+ loc: C.astFactory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13858
14000
  }));
13859
14001
  } },
13860
14002
  { ALT: () => {
@@ -13866,19 +14008,26 @@ var constructQuery = {
13866
14008
  subType: "construct",
13867
14009
  template: template.val,
13868
14010
  datasets: from2,
13869
- where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
14011
+ where: C.astFactory.patternGroup([template.val], C.astFactory.sourceLocation()),
13870
14012
  solutionModifiers: modifiers,
13871
- loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14013
+ loc: C.astFactory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13872
14014
  }));
13873
14015
  } }
13874
14016
  ]);
13875
14017
  },
13876
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14018
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14019
+ const { astFactory: F3, indentInc } = C;
13877
14020
  F3.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
13878
14021
  if (!F3.isSourceLocationNoMaterialize(ast.where.loc)) {
13879
- F3.printFilter(ast, () => PRINT_WORD("{"));
14022
+ F3.printFilter(ast, () => {
14023
+ C[traqulaIndentation] += indentInc;
14024
+ PRINT_WORD("{\n");
14025
+ });
13880
14026
  SUBRULE(triplesBlock, ast.template);
13881
- F3.printFilter(ast, () => PRINT_WORD("}"));
14027
+ F3.printFilter(ast, () => {
14028
+ C[traqulaIndentation] -= indentInc;
14029
+ PRINT_ON_EMPTY("}\n");
14030
+ });
13882
14031
  }
13883
14032
  SUBRULE(datasetClauseStar, ast.datasets);
13884
14033
  if (F3.isSourceLocationNoMaterialize(ast.where.loc)) {
@@ -13903,7 +14052,7 @@ var describeQuery = {
13903
14052
  } },
13904
14053
  { ALT: () => {
13905
14054
  const star2 = CONSUME(symbols_exports.star);
13906
- return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star2)))];
14055
+ return [ACTION(() => C.astFactory.wildcard(C.astFactory.sourceLocation(star2)))];
13907
14056
  } }
13908
14057
  ]);
13909
14058
  const from2 = SUBRULE1(datasetClauseStar);
@@ -13915,10 +14064,10 @@ var describeQuery = {
13915
14064
  datasets: from2,
13916
14065
  ...where2 && { where: where2.val },
13917
14066
  solutionModifiers: modifiers,
13918
- loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14067
+ loc: C.astFactory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13919
14068
  }));
13920
14069
  },
13921
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14070
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13922
14071
  F3.printFilter(ast, () => PRINT_WORD("DESCRIBE"));
13923
14072
  if (F3.isWildcard(ast.variables[0])) {
13924
14073
  F3.printFilter(ast, () => PRINT_WORD("*"));
@@ -13946,10 +14095,10 @@ var askQuery = {
13946
14095
  datasets: from2,
13947
14096
  where: where2.val,
13948
14097
  solutionModifiers: modifiers,
13949
- loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
14098
+ loc: C.astFactory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
13950
14099
  }));
13951
14100
  },
13952
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14101
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
13953
14102
  F3.printFilter(ast, () => PRINT_WORD("ASK"));
13954
14103
  SUBRULE(datasetClauseStar, ast.datasets);
13955
14104
  SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
@@ -13966,7 +14115,7 @@ var constructTemplate = {
13966
14115
  const open = CONSUME(symbols_exports.LCurly);
13967
14116
  const triples = OPTION(() => SUBRULE1(constructTriples));
13968
14117
  const close = CONSUME(symbols_exports.RCurly);
13969
- return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
14118
+ return ACTION(() => C.astFactory.wrap(triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocation()), C.astFactory.sourceLocation(open, close)));
13970
14119
  }
13971
14120
  };
13972
14121
  var constructTriples = {
@@ -14003,13 +14152,13 @@ var update = {
14003
14152
  const update2 = {
14004
14153
  type: "update",
14005
14154
  updates,
14006
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14155
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14007
14156
  };
14008
14157
  updateNoReuseBlankNodeLabels(update2);
14009
14158
  return update2;
14010
14159
  });
14011
14160
  },
14012
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14161
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14013
14162
  const [head2, ...tail] = ast.updates;
14014
14163
  if (head2) {
14015
14164
  SUBRULE(prologue, head2.context);
@@ -14089,9 +14238,9 @@ var load2 = {
14089
14238
  CONSUME(loadInto);
14090
14239
  return SUBRULE1(graphRef);
14091
14240
  });
14092
- return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
14241
+ return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
14093
14242
  },
14094
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14243
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14095
14244
  F3.printFilter(ast, () => {
14096
14245
  PRINT_WORD("LOAD");
14097
14246
  if (ast.silent) {
@@ -14112,9 +14261,9 @@ function clearOrDrop(operation) {
14112
14261
  const opToken = CONSUME(operation);
14113
14262
  const silent2 = OPTION(() => CONSUME(silent));
14114
14263
  const destination = SUBRULE1(graphRefAll);
14115
- return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
14264
+ return ACTION(() => C.astFactory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.astFactory.sourceLocation(opToken, destination)));
14116
14265
  },
14117
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14266
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14118
14267
  F3.printFilter(ast, () => {
14119
14268
  PRINT_WORD(operation.name.toUpperCase());
14120
14269
  if (ast.silent) {
@@ -14133,9 +14282,9 @@ var create2 = {
14133
14282
  const createToken3 = CONSUME(create);
14134
14283
  const silent2 = OPTION(() => CONSUME(silent));
14135
14284
  const destination = SUBRULE1(graphRef);
14136
- return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
14285
+ return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent2), C.astFactory.sourceLocation(createToken3, destination)));
14137
14286
  },
14138
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14287
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14139
14288
  F3.printFilter(ast, () => {
14140
14289
  PRINT_WORD("CREATE");
14141
14290
  if (ast.silent) {
@@ -14154,9 +14303,9 @@ function copyMoveAddOperation(operation) {
14154
14303
  const source = SUBRULE1(graphOrDefault);
14155
14304
  CONSUME(to);
14156
14305
  const destination = SUBRULE2(graphOrDefault);
14157
- return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
14306
+ return ACTION(() => C.astFactory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.astFactory.sourceLocation(op, destination)));
14158
14307
  },
14159
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14308
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14160
14309
  F3.printFilter(ast, () => {
14161
14310
  PRINT_WORD(operation.name.toUpperCase());
14162
14311
  if (ast.silent) {
@@ -14178,7 +14327,7 @@ var quadPattern = {
14178
14327
  const open = CONSUME(symbols_exports.LCurly);
14179
14328
  const val = SUBRULE1(quads);
14180
14329
  const close = CONSUME(symbols_exports.RCurly);
14181
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
14330
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
14182
14331
  }
14183
14332
  };
14184
14333
  var quadData = {
@@ -14189,7 +14338,7 @@ var quadData = {
14189
14338
  const val = SUBRULE1(quads);
14190
14339
  ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
14191
14340
  const close = CONSUME(symbols_exports.RCurly);
14192
- return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
14341
+ return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
14193
14342
  }
14194
14343
  };
14195
14344
  function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
@@ -14206,12 +14355,26 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
14206
14355
  if (name !== "insertData") {
14207
14356
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
14208
14357
  }
14209
- return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
14358
+ return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
14210
14359
  },
14211
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14212
- F3.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
14360
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14361
+ const { astFactory: F3, indentInc } = C;
14362
+ F3.printFilter(ast, () => {
14363
+ C[traqulaIndentation] += indentInc;
14364
+ if (subType === "insertdata") {
14365
+ PRINT_WORD("INSERT DATA");
14366
+ } else if (subType === "deletedata") {
14367
+ PRINT_WORD("DELETE DATA");
14368
+ } else if (subType === "deletewhere") {
14369
+ PRINT_WORD("DELETE WHERE");
14370
+ }
14371
+ PRINT_WORD("{\n");
14372
+ });
14213
14373
  SUBRULE(quads, F3.wrap(ast.data, ast.loc));
14214
- F3.printFilter(ast, () => PRINT_WORD("}"));
14374
+ F3.printFilter(ast, () => {
14375
+ C[traqulaIndentation] -= indentInc;
14376
+ PRINT_ON_EMPTY("}\n");
14377
+ });
14215
14378
  }
14216
14379
  };
14217
14380
  }
@@ -14240,22 +14403,35 @@ var modify = {
14240
14403
  const using = SUBRULE1(usingClauseStar);
14241
14404
  CONSUME(where);
14242
14405
  const where2 = SUBRULE1(groupGraphPattern);
14243
- return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
14406
+ return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
14244
14407
  },
14245
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14408
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14409
+ const { astFactory: F3, indentInc } = C;
14246
14410
  if (ast.graph) {
14247
14411
  F3.printFilter(ast, () => PRINT_WORD("WITH"));
14248
14412
  SUBRULE(iri2, ast.graph);
14249
14413
  }
14250
14414
  if (ast.delete.length > 0) {
14251
- F3.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
14415
+ F3.printFilter(ast, () => {
14416
+ C[traqulaIndentation] += indentInc;
14417
+ PRINT_WORD("DELETE", "{\n");
14418
+ });
14252
14419
  SUBRULE(quads, F3.wrap(ast.delete, ast.loc));
14253
- F3.printFilter(ast, () => PRINT_WORD("}"));
14420
+ F3.printFilter(ast, () => {
14421
+ C[traqulaIndentation] -= indentInc;
14422
+ PRINT_ON_EMPTY("}\n");
14423
+ });
14254
14424
  }
14255
14425
  if (ast.insert.length > 0) {
14256
- F3.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
14426
+ F3.printFilter(ast, () => {
14427
+ C[traqulaIndentation] += indentInc;
14428
+ PRINT_WORD("INSERT", "{\n");
14429
+ });
14257
14430
  SUBRULE(quads, F3.wrap(ast.insert, ast.loc));
14258
- F3.printFilter(ast, () => PRINT_WORD("}"));
14431
+ F3.printFilter(ast, () => {
14432
+ C[traqulaIndentation] -= indentInc;
14433
+ PRINT_ON_EMPTY("}\n");
14434
+ });
14259
14435
  }
14260
14436
  SUBRULE(usingClauseStar, ast.from);
14261
14437
  F3.printFilter(ast, () => PRINT_WORD("WHERE"));
@@ -14269,7 +14445,7 @@ var deleteClause2 = {
14269
14445
  const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
14270
14446
  const del = SUBRULE(quadPattern);
14271
14447
  ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
14272
- return ACTION(() => C.factory.wrap(del.val, C.factory.sourceLocation(delToken, del)));
14448
+ return ACTION(() => C.astFactory.wrap(del.val, C.astFactory.sourceLocation(delToken, del)));
14273
14449
  }
14274
14450
  };
14275
14451
  var insertClause2 = {
@@ -14277,7 +14453,7 @@ var insertClause2 = {
14277
14453
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
14278
14454
  const insertToken = CONSUME(insertClause);
14279
14455
  const insert = SUBRULE(quadPattern);
14280
- return ACTION(() => C.factory.wrap(insert.val, C.factory.sourceLocation(insertToken, insert)));
14456
+ return ACTION(() => C.astFactory.wrap(insert.val, C.astFactory.sourceLocation(insertToken, insert)));
14281
14457
  }
14282
14458
  };
14283
14459
  var graphOrDefault = {
@@ -14285,12 +14461,12 @@ var graphOrDefault = {
14285
14461
  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => OR([
14286
14462
  { ALT: () => {
14287
14463
  const def = CONSUME(graph_exports.default_);
14288
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14464
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
14289
14465
  } },
14290
14466
  { ALT: () => {
14291
14467
  const graph2 = OPTION(() => CONSUME(graph_exports.graph));
14292
14468
  const name = SUBRULE1(iri2);
14293
- return ACTION(() => C.factory.graphRefSpecific(name, C.factory.sourceLocation(graph2, name)));
14469
+ return ACTION(() => C.astFactory.graphRefSpecific(name, C.astFactory.sourceLocation(graph2, name)));
14294
14470
  } }
14295
14471
  ])
14296
14472
  };
@@ -14299,9 +14475,9 @@ var graphRef = {
14299
14475
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
14300
14476
  const graph2 = CONSUME(graph_exports.graph);
14301
14477
  const val = SUBRULE(iri2);
14302
- return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
14478
+ return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph2, val)));
14303
14479
  },
14304
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14480
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14305
14481
  F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
14306
14482
  SUBRULE(iri2, ast.graph);
14307
14483
  }
@@ -14312,18 +14488,18 @@ var graphRefAll = {
14312
14488
  { ALT: () => SUBRULE(graphRef) },
14313
14489
  { ALT: () => {
14314
14490
  const def = CONSUME(graph_exports.default_);
14315
- return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
14491
+ return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
14316
14492
  } },
14317
14493
  { ALT: () => {
14318
14494
  const named2 = CONSUME(graph_exports.named);
14319
- return ACTION(() => C.factory.graphRefNamed(C.factory.sourceLocation(named2)));
14495
+ return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named2)));
14320
14496
  } },
14321
14497
  { ALT: () => {
14322
14498
  const graphAll2 = CONSUME(graph_exports.graphAll);
14323
- return ACTION(() => C.factory.graphRefAll(C.factory.sourceLocation(graphAll2)));
14499
+ return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll2)));
14324
14500
  } }
14325
14501
  ]),
14326
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14502
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14327
14503
  if (F3.isGraphRefSpecific(ast)) {
14328
14504
  SUBRULE(graphRef, ast);
14329
14505
  } else if (F3.isGraphRefDefault(ast)) {
@@ -14360,9 +14536,9 @@ var quads = {
14360
14536
  ACTION(() => quads2.push(triples));
14361
14537
  });
14362
14538
  });
14363
- return ACTION(() => C.factory.wrap(quads2, C.factory.sourceLocation(quads2.at(0), last2)));
14539
+ return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last2)));
14364
14540
  },
14365
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
14541
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
14366
14542
  for (const quad of ast.val) {
14367
14543
  if (F3.isPattern(quad)) {
14368
14544
  SUBRULE(triplesBlock, quad);
@@ -14380,14 +14556,21 @@ var quadsNotTriples = {
14380
14556
  CONSUME(symbols_exports.LCurly);
14381
14557
  const triples = OPTION(() => SUBRULE1(triplesTemplate));
14382
14558
  const close = CONSUME(symbols_exports.RCurly);
14383
- return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
14559
+ return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph2, close)));
14384
14560
  },
14385
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
14561
+ gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, C) => {
14562
+ const { astFactory: F3, indentInc } = C;
14386
14563
  F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
14387
14564
  SUBRULE(varOrTerm, ast.graph);
14388
- F3.printFilter(ast, () => PRINT_WORD("{"));
14565
+ F3.printFilter(ast, () => {
14566
+ C[traqulaIndentation] += indentInc;
14567
+ PRINT_WORD("{\n");
14568
+ });
14389
14569
  SUBRULE(triplesBlock, ast.triples);
14390
- F3.printFilter(ast, () => PRINT_WORD("}"));
14570
+ F3.printFilter(ast, () => {
14571
+ C[traqulaIndentation] -= indentInc;
14572
+ PRINT_ON_EMPTY("}\n");
14573
+ });
14391
14574
  }
14392
14575
  };
14393
14576
 
@@ -14410,7 +14593,7 @@ var queryOrUpdate = {
14410
14593
  ...subType,
14411
14594
  type: "query",
14412
14595
  ...values3 && { values: values3 },
14413
- loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
14596
+ loc: C.astFactory.sourceLocation(prologueValues.at(0), subType, values3)
14414
14597
  }));
14415
14598
  } },
14416
14599
  { ALT: () => {
@@ -14434,7 +14617,7 @@ var queryOrUpdate = {
14434
14617
  const update2 = {
14435
14618
  type: "update",
14436
14619
  updates,
14437
- loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14620
+ loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
14438
14621
  };
14439
14622
  updateNoReuseBlankNodeLabels(update2);
14440
14623
  return update2;
@@ -14442,7 +14625,7 @@ var queryOrUpdate = {
14442
14625
  } }
14443
14626
  ]);
14444
14627
  },
14445
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
14628
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
14446
14629
  if (F3.isQuery(ast)) {
14447
14630
  SUBRULE(query, ast);
14448
14631
  } else {
@@ -14797,8 +14980,78 @@ var LANG_DIR = createToken2({
14797
14980
  });
14798
14981
  var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(lexer_exports.symbols.logicAnd, tilde, annotationOpen, annotationClose, tripleTermOpen, tripleTermClose, reificationOpen, reificationClose, version).addBefore(lexer_exports.builtIn.langmatches, buildInLangDir, buildInStrLangDir, buildInHasLangDir, buildInHasLang, buildInIsTRIPLE, buildInTRIPLE, buildInSUBJECT, buildInPREDICATE, buildInOBJECT).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
14799
14982
 
14983
+ // ../../packages/rules-sparql-1-2/lib/AstFactory.js
14984
+ var AstFactory2 = class extends AstFactory {
14985
+ termTriple(subject, predicate, object3, loc) {
14986
+ return {
14987
+ type: "term",
14988
+ subType: "triple",
14989
+ subject,
14990
+ predicate,
14991
+ object: object3,
14992
+ loc
14993
+ };
14994
+ }
14995
+ isTermTriple(obj) {
14996
+ return this.isOfSubType(obj, "term", "triple");
14997
+ }
14998
+ tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
14999
+ return {
15000
+ type: "tripleCollection",
15001
+ subType: "reifiedTriple",
15002
+ triples: [this.triple(subject, predicate, object3)],
15003
+ identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
15004
+ loc
15005
+ };
15006
+ }
15007
+ isTripleCollectionReifiedTriple(obj) {
15008
+ return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
15009
+ }
15010
+ tripleCollectionBlankNodeProperties(identifier, triples, loc) {
15011
+ return {
15012
+ type: "tripleCollection",
15013
+ subType: "blankNodeProperties",
15014
+ triples,
15015
+ identifier,
15016
+ loc
15017
+ };
15018
+ }
15019
+ /**
15020
+ * Overwritten triple constructor to always contain an empty annotations list
15021
+ */
15022
+ triple = (subject, predicate, object3, loc) => ({
15023
+ type: "triple",
15024
+ subject,
15025
+ predicate,
15026
+ object: object3,
15027
+ annotations: [],
15028
+ loc: loc ?? this.sourceLocation(subject, predicate, object3)
15029
+ });
15030
+ annotatedTriple(subject, predicate, object3, annotations, loc) {
15031
+ return {
15032
+ type: "triple",
15033
+ subject,
15034
+ predicate,
15035
+ object: object3,
15036
+ annotations: annotations ?? [],
15037
+ loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
15038
+ };
15039
+ }
15040
+ contextDefinitionVersion(version2, loc) {
15041
+ return {
15042
+ type: "contextDef",
15043
+ subType: "version",
15044
+ version: version2,
15045
+ loc
15046
+ };
15047
+ }
15048
+ isContextDefinitionVersion(obj) {
15049
+ return this.isOfSubType(obj, "contextDef", "version");
15050
+ }
15051
+ };
15052
+
14800
15053
  // ../../packages/rules-sparql-1-2/lib/validators.js
14801
- var F2 = new Factory();
15054
+ var F2 = new AstFactory2();
14802
15055
  function isLangDir(dir) {
14803
15056
  return dir === "ltr" || dir === "rtl";
14804
15057
  }
@@ -14820,11 +15073,11 @@ var versionDecl = {
14820
15073
  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
14821
15074
  const versionToken = CONSUME(version);
14822
15075
  const identifier = SUBRULE(versionSpecifier);
14823
- return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
15076
+ return ACTION(() => C.astFactory.contextDefinitionVersion(identifier.val, C.astFactory.sourceLocation(versionToken, identifier)));
14824
15077
  },
14825
- gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
15078
+ gImpl: ({ PRINT_WORDS }) => (ast, { astFactory: F3 }) => {
14826
15079
  F3.printFilter(ast, () => {
14827
- PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`);
15080
+ PRINT_WORDS("VERSION", `${grammar_exports.stringEscapedLexical(ast.version)}`, "\n");
14828
15081
  });
14829
15082
  }
14830
15083
  };
@@ -14835,7 +15088,7 @@ var versionSpecifier = {
14835
15088
  { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral1) },
14836
15089
  { ALT: () => CONSUME(lexer_exports.terminals.stringLiteral2) }
14837
15090
  ]);
14838
- return ACTION(() => C.factory.wrap(token.image.slice(1, -1), C.factory.sourceLocation(token)));
15091
+ return ACTION(() => C.astFactory.wrap(token.image.slice(1, -1), C.astFactory.sourceLocation(token)));
14839
15092
  }
14840
15093
  };
14841
15094
  var prologue2 = {
@@ -14851,7 +15104,7 @@ var prologue2 = {
14851
15104
  ]));
14852
15105
  return result;
14853
15106
  },
14854
- gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
15107
+ gImpl: ({ SUBRULE }) => (ast, { astFactory: F3 }) => {
14855
15108
  for (const context of ast) {
14856
15109
  if (F3.isContextDefinitionBase(context)) {
14857
15110
  SUBRULE(grammar_exports.baseDecl, context);
@@ -14868,7 +15121,7 @@ function reifiedTripleBlockImpl(name, allowPath) {
14868
15121
  name,
14869
15122
  impl: ({ ACTION, SUBRULE }) => (C) => {
14870
15123
  const triple = SUBRULE(reifiedTriple);
14871
- const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.factory.dematerialized(triple.identifier)));
15124
+ const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.astFactory.dematerialized(triple.identifier)));
14872
15125
  return ACTION(() => [triple, ...properties]);
14873
15126
  }
14874
15127
  };
@@ -14891,7 +15144,7 @@ var reifier = {
14891
15144
  if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
14892
15145
  throw new Error("Cannot create blanknodes in current parse mode");
14893
15146
  }
14894
- return C.factory.wrap(reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()), C.factory.sourceLocation(tildeToken, reifier2));
15147
+ return C.astFactory.wrap(reifier2 ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation()), C.astFactory.sourceLocation(tildeToken, reifier2));
14895
15148
  });
14896
15149
  }
14897
15150
  };
@@ -14921,7 +15174,7 @@ function objectImpl2(name, allowPaths) {
14921
15174
  const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2);
14922
15175
  const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
14923
15176
  return ACTION(() => {
14924
- const F3 = C.factory;
15177
+ const F3 = C.astFactory;
14925
15178
  if (F3.isPathPure(predicate) && annotationVal.length > 0) {
14926
15179
  throw new Error("Note 17 violation");
14927
15180
  }
@@ -14950,7 +15203,7 @@ function annotationImpl(name, allowPaths) {
14950
15203
  if (!currentReifier && !C.parseMode.has("canCreateBlankNodes")) {
14951
15204
  throw new Error("Cannot create blanknodes in current parse mode");
14952
15205
  }
14953
- currentReifier = currentReifier ?? C.factory.blankNode(void 0, C.factory.sourceLocation());
15206
+ currentReifier = currentReifier ?? C.astFactory.blankNode(void 0, C.astFactory.sourceLocation());
14954
15207
  });
14955
15208
  const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
14956
15209
  ACTION(() => {
@@ -14962,7 +15215,7 @@ function annotationImpl(name, allowPaths) {
14962
15215
  });
14963
15216
  return annotations;
14964
15217
  },
14965
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
15218
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
14966
15219
  for (const annotation2 of ast) {
14967
15220
  if (F3.isTripleCollectionBlankNodeProperties(annotation2)) {
14968
15221
  SUBRULE(annotationBlockPath, annotation2);
@@ -14983,11 +15236,18 @@ function annotationBlockImpl(name, allowPaths) {
14983
15236
  const open = CONSUME(annotationOpen);
14984
15237
  const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, arg);
14985
15238
  const close = CONSUME(annotationClose);
14986
- return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
15239
+ return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(arg, res, C.astFactory.sourceLocation(open, close)));
14987
15240
  },
14988
- gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
14989
- F3.printFilter(ast, () => PRINT_WORD("{|"));
14990
- for (const triple of ast.triples) {
15241
+ gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY }) => (ast, C) => {
15242
+ const { astFactory: F3, indentInc } = C;
15243
+ F3.printFilter(ast, () => {
15244
+ PRINT_WORD("{|");
15245
+ if (ast.triples.length > 1) {
15246
+ C[traqulaIndentation] += indentInc;
15247
+ PRINT_WORD("\n");
15248
+ }
15249
+ });
15250
+ function printTriple(triple) {
14991
15251
  HANDLE_LOC(triple, () => {
14992
15252
  if (F3.isTerm(triple.predicate)) {
14993
15253
  SUBRULE(graphNodePath2, triple.predicate);
@@ -14995,10 +15255,21 @@ function annotationBlockImpl(name, allowPaths) {
14995
15255
  SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
14996
15256
  }
14997
15257
  SUBRULE(graphNodePath2, triple.object);
14998
- F3.printFilter(ast, () => PRINT_WORD(";"));
14999
15258
  });
15000
15259
  }
15001
- F3.printFilter(ast, () => PRINT_WORD("|}"));
15260
+ const [head2, ...tail] = ast.triples;
15261
+ printTriple(head2);
15262
+ for (const triple of tail) {
15263
+ F3.printFilter(ast, () => PRINT_WORD(";\n"));
15264
+ printTriple(triple);
15265
+ }
15266
+ F3.printFilter(ast, () => {
15267
+ if (ast.triples.length > 1) {
15268
+ PRINT_ON_EMPTY("|}\n");
15269
+ } else {
15270
+ PRINT_WORD("|}");
15271
+ }
15272
+ });
15002
15273
  }
15003
15274
  };
15004
15275
  }
@@ -15018,7 +15289,7 @@ var graphNodePath2 = {
15018
15289
  { ALT: () => $.SUBRULE(reifiedTriple) }
15019
15290
  ]),
15020
15291
  gImpl: ($) => (ast, C) => {
15021
- if (C.factory.isTripleCollectionReifiedTriple(ast)) {
15292
+ if (C.astFactory.isTripleCollectionReifiedTriple(ast)) {
15022
15293
  $.SUBRULE(reifiedTriple, ast);
15023
15294
  } else {
15024
15295
  grammar_exports.graphNodePath.gImpl($)(ast, C);
@@ -15036,7 +15307,7 @@ var varOrTerm2 = {
15036
15307
  { ALT: () => SUBRULE(grammar_exports.blankNode) },
15037
15308
  { ALT: () => {
15038
15309
  const token = CONSUME(lexer_exports.terminals.nil);
15039
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
15310
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.NIL));
15040
15311
  } },
15041
15312
  { ALT: () => SUBRULE(tripleTerm) }
15042
15313
  ])
@@ -15055,10 +15326,10 @@ var reifiedTriple = {
15055
15326
  if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
15056
15327
  throw new Error("Cannot create blanknodes in current parse mode");
15057
15328
  }
15058
- return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
15329
+ return C.astFactory.tripleCollectionReifiedTriple(C.astFactory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
15059
15330
  });
15060
15331
  },
15061
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
15332
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
15062
15333
  F3.printFilter(ast, () => PRINT_WORD("<<"));
15063
15334
  const triple = ast.triples[0];
15064
15335
  SUBRULE(graphNodePath2, triple.subject);
@@ -15097,9 +15368,9 @@ var tripleTerm = {
15097
15368
  const predicate = SUBRULE(grammar_exports.verb);
15098
15369
  const object3 = SUBRULE(tripleTermObject);
15099
15370
  const close = CONSUME(tripleTermClose);
15100
- return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
15371
+ return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
15101
15372
  },
15102
- gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
15373
+ gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F3 }) => {
15103
15374
  F3.printFilter(ast, () => PRINT_WORD("<<("));
15104
15375
  SUBRULE(graphNodePath2, ast.subject);
15105
15376
  SUBRULE(graphNodePath2, ast.predicate);
@@ -15132,12 +15403,12 @@ var tripleTermData = {
15132
15403
  { ALT: () => SUBRULE(grammar_exports.iri) },
15133
15404
  { ALT: () => {
15134
15405
  const token = CONSUME(lexer_exports.a);
15135
- return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
15406
+ return ACTION(() => C.astFactory.namedNode(C.astFactory.sourceLocation(token), CommonIRIs.TYPE));
15136
15407
  } }
15137
15408
  ]);
15138
15409
  const object3 = SUBRULE(tripleTermDataObject);
15139
15410
  const close = CONSUME(tripleTermClose);
15140
- return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
15411
+ return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
15141
15412
  }
15142
15413
  };
15143
15414
  var tripleTermDataSubject = {
@@ -15169,7 +15440,7 @@ var exprTripleTerm = {
15169
15440
  const predicate = SUBRULE(grammar_exports.verb);
15170
15441
  const object3 = SUBRULE(exprTripleTermObject);
15171
15442
  const close = CONSUME(tripleTermClose);
15172
- return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
15443
+ return ACTION(() => C.astFactory.termTriple(subject, predicate, object3, C.astFactory.sourceLocation(open, close)));
15173
15444
  }
15174
15445
  };
15175
15446
  var exprTripleTermSubject = {
@@ -15219,7 +15490,7 @@ var rdfLiteral2 = {
15219
15490
  { ALT: () => {
15220
15491
  const langTag2 = CONSUME(LANG_DIR);
15221
15492
  return ACTION(() => {
15222
- const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
15493
+ const literal = C.astFactory.literalTerm(C.astFactory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
15223
15494
  langTagHasCorrectRange(literal);
15224
15495
  return literal;
15225
15496
  });
@@ -15227,7 +15498,7 @@ var rdfLiteral2 = {
15227
15498
  { ALT: () => {
15228
15499
  CONSUME(lexer_exports.symbols.hathat);
15229
15500
  const iriVal = SUBRULE(grammar_exports.iri);
15230
- return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
15501
+ return ACTION(() => C.astFactory.literalTerm(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
15231
15502
  } }
15232
15503
  ])) ?? value;
15233
15504
  }
@@ -15239,7 +15510,7 @@ var unaryExpression2 = {
15239
15510
  { ALT: () => {
15240
15511
  const operator = CONSUME(lexer_exports.symbols.exclamation);
15241
15512
  const expr = SUBRULE1(unaryExpression2);
15242
- return ACTION(() => C.factory.expressionOperation("!", [expr], C.factory.sourceLocation(operator, expr)));
15513
+ return ACTION(() => C.astFactory.expressionOperation("!", [expr], C.astFactory.sourceLocation(operator, expr)));
15243
15514
  } },
15244
15515
  { ALT: () => {
15245
15516
  const operator = OR2([
@@ -15247,34 +15518,36 @@ var unaryExpression2 = {
15247
15518
  { ALT: () => CONSUME(lexer_exports.symbols.opMinus) }
15248
15519
  ]);
15249
15520
  const expr = SUBRULE2(primaryExpression2);
15250
- return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
15521
+ return ACTION(() => C.astFactory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.astFactory.sourceLocation(operator, expr)));
15251
15522
  } }
15252
15523
  ])
15253
15524
  };
15254
15525
  var generateTriplesBlock = {
15255
15526
  name: "triplesBlock",
15256
- gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
15527
+ gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { astFactory: F3 }) => {
15257
15528
  for (const [index, triple] of ast.triples.entries()) {
15258
15529
  HANDLE_LOC(triple, () => {
15259
15530
  const nextTriple = ast.triples.at(index);
15260
15531
  if (F3.isTripleCollection(triple)) {
15261
15532
  SUBRULE(graphNodePath2, triple);
15262
- F3.printFilter(triple, () => PRINT_WORD("."));
15533
+ F3.printFilter(triple, () => PRINT_WORD(".\n"));
15263
15534
  } else {
15264
15535
  SUBRULE(graphNodePath2, triple.subject);
15536
+ F3.printFilter(ast, () => PRINT_WORD(""));
15265
15537
  if (F3.isPathPure(triple.predicate)) {
15266
15538
  SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
15267
15539
  } else {
15268
15540
  SUBRULE(graphNodePath2, triple.predicate);
15269
15541
  }
15542
+ F3.printFilter(ast, () => PRINT_WORD(""));
15270
15543
  SUBRULE(graphNodePath2, triple.object);
15271
15544
  SUBRULE(annotationPath, triple.annotations ?? []);
15272
15545
  if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
15273
- F3.printFilter(ast, () => PRINT_WORD("."));
15546
+ F3.printFilter(ast, () => PRINT_WORD(".\n"));
15274
15547
  } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
15275
15548
  F3.printFilter(ast, () => PRINT_WORD(","));
15276
15549
  } else {
15277
- F3.printFilter(ast, () => PRINT_WORD(";"));
15550
+ F3.printFilter(ast, () => PRINT_WORD(";\n"));
15278
15551
  }
15279
15552
  }
15280
15553
  });
@@ -15284,7 +15557,7 @@ var generateTriplesBlock = {
15284
15557
  var generateGraphTerm = {
15285
15558
  name: "graphTerm",
15286
15559
  gImpl: ($) => (ast, C) => {
15287
- if (C.factory.isTermTriple(ast)) {
15560
+ if (C.astFactory.isTermTriple(ast)) {
15288
15561
  $.SUBRULE(tripleTerm, ast);
15289
15562
  } else {
15290
15563
  grammar_exports.graphTerm.gImpl($)(ast, C);
@@ -15292,86 +15565,18 @@ var generateGraphTerm = {
15292
15565
  }
15293
15566
  };
15294
15567
 
15295
- // ../../packages/rules-sparql-1-2/lib/Factory.js
15296
- var Factory2 = class extends Factory {
15297
- termTriple(subject, predicate, object3, loc) {
15298
- return {
15299
- type: "term",
15300
- subType: "triple",
15301
- subject,
15302
- predicate,
15303
- object: object3,
15304
- loc
15305
- };
15306
- }
15307
- isTermTriple(obj) {
15308
- return this.isOfSubType(obj, "term", "triple");
15309
- }
15310
- tripleCollectionReifiedTriple(loc, subject, predicate, object3, reifier2) {
15311
- return {
15312
- type: "tripleCollection",
15313
- subType: "reifiedTriple",
15314
- triples: [this.triple(subject, predicate, object3)],
15315
- identifier: reifier2 ?? this.blankNode(void 0, this.sourceLocationNoMaterialize()),
15316
- loc
15317
- };
15318
- }
15319
- isTripleCollectionReifiedTriple(obj) {
15320
- return this.isOfSubType(obj, "tripleCollection", "reifiedTriple");
15321
- }
15322
- tripleCollectionBlankNodeProperties(identifier, triples, loc) {
15323
- return {
15324
- type: "tripleCollection",
15325
- subType: "blankNodeProperties",
15326
- triples,
15327
- identifier,
15328
- loc
15329
- };
15330
- }
15331
- /**
15332
- * Overwritten triple constructor to always contain an empty annotations list
15333
- */
15334
- triple = (subject, predicate, object3, loc) => ({
15335
- type: "triple",
15336
- subject,
15337
- predicate,
15338
- object: object3,
15339
- annotations: [],
15340
- loc: loc ?? this.sourceLocation(subject, predicate, object3)
15341
- });
15342
- annotatedTriple(subject, predicate, object3, annotations, loc) {
15343
- return {
15344
- type: "triple",
15345
- subject,
15346
- predicate,
15347
- object: object3,
15348
- annotations: annotations ?? [],
15349
- loc: loc ?? this.sourceLocation(subject, predicate, object3, ...annotations ?? [])
15350
- };
15351
- }
15352
- contextDefinitionVersion(version2, loc) {
15353
- return {
15354
- type: "contextDef",
15355
- subType: "version",
15356
- version: version2,
15357
- loc
15358
- };
15359
- }
15360
- isContextDefinitionVersion(obj) {
15361
- return this.isOfSubType(obj, "contextDef", "version");
15362
- }
15363
- };
15364
-
15365
15568
  // ../../packages/rules-sparql-1-2/lib/parserUtils.js
15366
15569
  function completeParseContext(context) {
15367
15570
  return {
15368
- factory: context.factory ?? new Factory2(),
15571
+ astFactory: context.astFactory ?? new AstFactory2(),
15369
15572
  baseIRI: context.baseIRI,
15370
15573
  prefixes: { ...context.prefixes },
15371
15574
  origSource: context.origSource ?? "",
15372
15575
  offset: context.offset,
15373
15576
  parseMode: context.parseMode ? new Set(context.parseMode) : /* @__PURE__ */ new Set(["canParseVars", "canCreateBlankNodes"]),
15374
- skipValidation: context.skipValidation ?? false
15577
+ skipValidation: context.skipValidation ?? false,
15578
+ indentInc: context.indentInc ?? 2,
15579
+ [traqulaIndentation]: context[traqulaIndentation] ?? 0
15375
15580
  };
15376
15581
  }
15377
15582
 
@@ -15379,7 +15584,7 @@ function completeParseContext(context) {
15379
15584
  var sparql12ParserBuilder = ParserBuilder.create(sparql11ParserBuilder).widenContext().typePatch().addMany(grammar_exports2.reifiedTripleBlock, grammar_exports2.reifiedTripleBlockPath, grammar_exports2.reifier, grammar_exports2.varOrReifierId, grammar_exports2.annotation, grammar_exports2.annotationPath, grammar_exports2.annotationBlockPath, grammar_exports2.annotationBlock, grammar_exports2.reifiedTriple, grammar_exports2.reifiedTripleSubject, grammar_exports2.reifiedTripleObject, grammar_exports2.tripleTerm, grammar_exports2.tripleTermSubject, grammar_exports2.tripleTermObject, grammar_exports2.tripleTermData, grammar_exports2.tripleTermDataSubject, grammar_exports2.tripleTermDataObject, grammar_exports2.exprTripleTerm, grammar_exports2.exprTripleTermSubject, grammar_exports2.exprTripleTermObject).addMany(grammar_exports2.versionDecl, grammar_exports2.versionSpecifier).addMany(grammar_exports2.buildInLangDir, grammar_exports2.buildInLangStrDir, grammar_exports2.buildInHasLang, grammar_exports2.buildInHasLangDir, grammar_exports2.buildInIsTriple, grammar_exports2.buildInTriple, grammar_exports2.buildInSubject, grammar_exports2.buildInPredicate, grammar_exports2.buildInObject).patchRule(grammar_exports2.dataBlockValue).patchRule(grammar_exports2.triplesSameSubject).patchRule(grammar_exports2.triplesSameSubjectPath).patchRule(grammar_exports2.object).patchRule(grammar_exports2.objectPath).patchRule(grammar_exports2.graphNode).patchRule(grammar_exports2.graphNodePath).patchRule(grammar_exports2.varOrTerm).deleteRule(grammar_exports.graphTerm.name).patchRule(grammar_exports2.primaryExpression).patchRule(grammar_exports2.builtInCall).patchRule(grammar_exports2.rdfLiteral).patchRule(grammar_exports2.unaryExpression).patchRule(grammar_exports2.prologue);
15380
15585
  var Parser2 = class {
15381
15586
  parser;
15382
- F = new Factory2();
15587
+ F = new AstFactory2();
15383
15588
  constructor() {
15384
15589
  this.parser = sparql12ParserBuilder.build({
15385
15590
  queryPreProcessor: sparqlCodepointEscape,