@nfdi4plants/arctrl 3.2.3 → 3.3.0

package/dist/ts/ts/fable_modules/YAMLicious.2.0.0/Compare.fs.js

@@ -0,0 +1,857 @@
+import { BlockScalarStyle, YamlNode_$reflection } from './Model.fs.js';
+import { length, forAll2, isEmpty, FSharpList__get_Head, FSharpList__get_Tail, map, reverse } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { equals, int32ToString, getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { YamlTagModule_identifier } from './Tag.fs.js';
+import { item } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { replicate, replace, join } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { StringBuilder_$ctor, StringBuilder__Append_Z721C83C5, StringBuilder__Append_244C7CD6 } from '../../../node_modules/@fable-org/fable-library-ts/System.Text.js';
+import { toString, Union } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { union_type, int32_type, string_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+
+function commentsEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0;
+  if (a != null) {
+    if (b != null) {
+      matchResult = 1;
+      x = a;
+      y = b;
+    } else {
+      matchResult = 2;
+    }
+  } else if (b == null) {
+    matchResult = 0;
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    case 1:
+      return x.Text === y.Text;
+    default:
+      return false;
+  }
+}
+function triviaEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0;
+  if (a.tag === /* BlankLine */
+  1) {
+    if (b.tag === /* BlankLine */
+    1) {
+      matchResult = 1;
+    } else {
+      matchResult = 2;
+    }
+  } else if (b.tag === /* FullLineComment */
+  0) {
+    matchResult = 0;
+    x = a.fields[0];
+    y = b.fields[0];
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return x.Text === y.Text;
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+function triviaListEqual(a, b) {
+  if (length(a) === length(b)) {
+    return forAll2(triviaEqual, a, b);
+  } else {
+    return false;
+  }
+}
+function separationEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0;
+  if (a.tag === /* NewLine */
+  1) {
+    if (b.tag === /* NewLine */
+    1) {
+      matchResult = 1;
+      x = a.fields[0];
+      y = b.fields[0];
+    } else {
+      matchResult = 2;
+    }
+  } else if (b.tag === /* Inline */
+  0) {
+    matchResult = 0;
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    case 1:
+      if (commentsEqual(x.Comment, y.Comment)) {
+        return triviaListEqual(x.Following, y.Following);
+      } else {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function separationOptionEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0;
+  if (a != null) {
+    if (b != null) {
+      matchResult = 1;
+      x = a;
+      y = b;
+    } else {
+      matchResult = 2;
+    }
+  } else if (b == null) {
+    matchResult = 0;
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    case 1:
+      return separationEqual(x, y);
+    default:
+      return false;
+  }
+}
+function propertiesEqual(a, b) {
+  if (equals(a.Anchor, b.Anchor)) {
+    const matchValue = a.Tag;
+    const matchValue_1 = b.Tag;
+    let matchResult = void 0, x = void 0, y = void 0;
+    if (matchValue != null) {
+      if (matchValue_1 != null) {
+        matchResult = 1;
+        x = matchValue;
+        y = matchValue_1;
+      } else {
+        matchResult = 2;
+      }
+    } else if (matchValue_1 == null) {
+      matchResult = 0;
+    } else {
+      matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0:
+        return true;
+      case 1:
+        return YamlTagModule_identifier(x) === YamlTagModule_identifier(y);
+      default:
+        return false;
+    }
+  } else {
+    return false;
+  }
+}
+function placementEqual(a, b) {
+  if (equals(a.Property, b.Property)) {
+    return separationEqual(a.After, b.After);
+  } else {
+    return false;
+  }
+}
+function scalarEqual(a, b) {
+  if (a.Value === b.Value && equals(a.Style, b.Style) && commentsEqual(a.HeaderComment, b.HeaderComment)) {
+    return equals(a.Layout, b.Layout);
+  } else {
+    return false;
+  }
+}
+function collectionEqual(a, b) {
+  if (equals(a.Style, b.Style) && commentsEqual(a.OpeningComment, b.OpeningComment) && triviaListEqual(a.End, b.End)) {
+    return length(a.Items) === length(b.Items);
+  } else {
+    return false;
+  }
+}
+function entryEqual(a, b) {
+  if (triviaListEqual(a.Before, b.Before) && separationOptionEqual(a.Question, b.Question) && triviaListEqual(a.BeforeColon, b.BeforeColon)) {
+    return separationOptionEqual(a.Colon, b.Colon);
+  } else {
+    return false;
+  }
+}
+function itemEqual(a, b) {
+  if (triviaListEqual(a.Before, b.Before)) {
+    return separationOptionEqual(a.Dash, b.Dash);
+  } else {
+    return false;
+  }
+}
+function nodesEqualIgnoringSpans(left, right) {
+  const pending = [];
+  void pending.push([left, right]);
+  let equal = true;
+  while (equal && pending.length > 0) {
+    const last = pending.length - 1 | 0;
+    const patternInput = item(last, pending);
+    const b = patternInput[1];
+    const a = patternInput[0];
+    pending.splice(last, 1);
+    if (!(propertiesEqual(a.Properties, b.Properties) && length(a.PropertyLayout) === length(b.PropertyLayout) && forAll2(placementEqual, a.PropertyLayout, b.PropertyLayout) && commentsEqual(a.TrailingComment, b.TrailingComment))) {
+      equal = false;
+    } else {
+      const matchValue = a.Kind;
+      const matchValue_1 = b.Kind;
+      let matchResult = void 0, x = void 0, y = void 0, x_1 = void 0, y_1 = void 0, x_2 = void 0, y_2 = void 0, x_3 = void 0, y_3 = void 0;
+      switch (matchValue.tag) {
+        case /* Alias */
+        3: {
+          if (matchValue_1.tag === /* Alias */
+          3) {
+            matchResult = 1;
+            x_1 = matchValue.fields[0];
+            y_1 = matchValue_1.fields[0];
+          } else {
+            matchResult = 4;
+          }
+          break;
+        }
+        case /* Mapping */
+        1: {
+          if (matchValue_1.tag === /* Mapping */
+          1) {
+            matchResult = 2;
+            x_2 = matchValue.fields[0];
+            y_2 = matchValue_1.fields[0];
+          } else {
+            matchResult = 4;
+          }
+          break;
+        }
+        case /* Sequence */
+        2: {
+          if (matchValue_1.tag === /* Sequence */
+          2) {
+            matchResult = 3;
+            x_3 = matchValue.fields[0];
+            y_3 = matchValue_1.fields[0];
+          } else {
+            matchResult = 4;
+          }
+          break;
+        }
+        default:
+          if (matchValue_1.tag === /* Scalar */
+          0) {
+            matchResult = 0;
+            x = matchValue.fields[0];
+            y = matchValue_1.fields[0];
+          } else {
+            matchResult = 4;
+          }
+      }
+      switch (matchResult) {
+        case 0: {
+          if (!scalarEqual(x, y)) {
+            equal = false;
+          }
+          break;
+        }
+        case 1: {
+          if (x_1 !== y_1) {
+            equal = false;
+          }
+          break;
+        }
+        case 2: {
+          if (!collectionEqual(x_2, y_2)) {
+            equal = false;
+          } else {
+            let xs = x_2.Items;
+            let ys = y_2.Items;
+            while (equal && !isEmpty(xs)) {
+              const ex = FSharpList__get_Head(xs);
+              const ey = FSharpList__get_Head(ys);
+              if (!entryEqual(ex, ey)) {
+                equal = false;
+              } else {
+                void pending.push([ex.Value, ey.Value]);
+                void pending.push([ex.Key, ey.Key]);
+              }
+              xs = FSharpList__get_Tail(xs);
+              ys = FSharpList__get_Tail(ys);
+            }
+          }
+          break;
+        }
+        case 3: {
+          if (!collectionEqual(x_3, y_3)) {
+            equal = false;
+          } else {
+            let xs_1 = x_3.Items;
+            let ys_1 = y_3.Items;
+            while (equal && !isEmpty(xs_1)) {
+              const ix = FSharpList__get_Head(xs_1);
+              const iy = FSharpList__get_Head(ys_1);
+              if (!itemEqual(ix, iy)) {
+                equal = false;
+              } else {
+                void pending.push([ix.Node, iy.Node]);
+              }
+              xs_1 = FSharpList__get_Tail(xs_1);
+              ys_1 = FSharpList__get_Tail(ys_1);
+            }
+          }
+          break;
+        }
+        case 4: {
+          equal = false;
+          break;
+        }
+      }
+    }
+  }
+  return equal;
+}
+function markerEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0;
+  if (a != null) {
+    if (b != null) {
+      matchResult = 1;
+      x = a;
+      y = b;
+    } else {
+      matchResult = 2;
+    }
+  } else if (b == null) {
+    matchResult = 0;
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    case 1:
+      return commentsEqual(x.TrailingComment, y.TrailingComment);
+    default:
+      return false;
+  }
+}
+function preludeItemEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0, x_1 = void 0, y_1 = void 0;
+  if (a.tag === /* PreludeTrivia */
+  1) {
+    if (b.tag === /* PreludeTrivia */
+    1) {
+      matchResult = 1;
+      x_1 = a.fields[0];
+      y_1 = b.fields[0];
+    } else {
+      matchResult = 2;
+    }
+  } else if (b.tag === /* Directive */
+  0) {
+    matchResult = 0;
+    x = a.fields[0];
+    y = b.fields[0];
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      if (equals(x.Kind, y.Kind)) {
+        return commentsEqual(x.TrailingComment, y.TrailingComment);
+      } else {
+        return false;
+      }
+    case 1:
+      return triviaEqual(x_1, y_1);
+    default:
+      return false;
+  }
+}
+function documentsEqualIgnoringSpans(left, right) {
+  if (length(left.Prelude) === length(right.Prelude) && forAll2(preludeItemEqual, left.Prelude, right.Prelude) && markerEqual(left.StartMarker, right.StartMarker) && triviaListEqual(left.BeforeRoot, right.BeforeRoot) && triviaListEqual(left.AfterRoot, right.AfterRoot) && markerEqual(left.EndMarker, right.EndMarker) && triviaListEqual(left.AfterEndMarker, right.AfterEndMarker)) {
+    return nodesEqualIgnoringSpans(left.Root, right.Root);
+  } else {
+    return false;
+  }
+}
+function partEqual(a, b) {
+  let matchResult = void 0, x = void 0, y = void 0, x_1 = void 0, y_1 = void 0, x_2 = void 0, y_2 = void 0;
+  switch (a.tag) {
+    case /* Trivia */
+    1: {
+      if (b.tag === /* Trivia */
+      1) {
+        matchResult = 1;
+        x_1 = a.fields[0];
+        y_1 = b.fields[0];
+      } else {
+        matchResult = 3;
+      }
+      break;
+    }
+    case /* ExtraEndMarker */
+    2: {
+      if (b.tag === /* ExtraEndMarker */
+      2) {
+        matchResult = 2;
+        x_2 = a.fields[0];
+        y_2 = b.fields[0];
+      } else {
+        matchResult = 3;
+      }
+      break;
+    }
+    default:
+      if (b.tag === /* Document */
+      0) {
+        matchResult = 0;
+        x = a.fields[0];
+        y = b.fields[0];
+      } else {
+        matchResult = 3;
+      }
+  }
+  switch (matchResult) {
+    case 0:
+      return documentsEqualIgnoringSpans(x, y);
+    case 1:
+      return triviaEqual(x_1, y_1);
+    case 2:
+      return markerEqual(x_2, y_2);
+    default:
+      return false;
+  }
+}
+function streamsEqualIgnoringSpans(left, right) {
+  if (length(left.Parts) === length(right.Parts)) {
+    return forAll2(partEqual, left.Parts, right.Parts);
+  } else {
+    return false;
+  }
+}
+const maxIndentedDepth = 24;
+function indent(depth) {
+  if (depth <= maxIndentedDepth) {
+    return replicate(2 * depth, " ");
+  } else {
+    return replicate(2 * maxIndentedDepth, " ") + "[" + int32ToString(depth) + "] ";
+  }
+}
+function escape(text) {
+  return replace(replace(replace(replace(replace(text, "\\", "\\\\"), '"', '\\"'), "\n", "\\n"), "\r", "\\r"), "	", "\\t");
+}
+function quoted(text) {
+  return '"' + escape(text) + '"';
+}
+function showComment(comment) {
+  return "#" + quoted(comment.Text);
+}
+function showTrivia(trivia) {
+  if (trivia.tag === /* BlankLine */
+  1) {
+    return "blank";
+  } else {
+    return showComment(trivia.fields[0]);
+  }
+}
+function showTriviaList(items) {
+  return "[" + join("; ", map(showTrivia, items)) + "]";
+}
+function showBreaks(layout) {
+  return "[" + join("; ", map((boundary) => {
+    const matchValue = boundary.Kind;
+    if (matchValue.tag === /* EscapedBreak */
+    1) {
+      if (matchValue.fields[0] === 0) {
+        return "e@" + int32ToString(boundary.At);
+      } else {
+        const lines_1 = matchValue.fields[0] | 0;
+        return "e" + int32ToString(lines_1) + "@" + int32ToString(boundary.At);
+      }
+    } else if (matchValue.fields[0] === 0) {
+      return "f@" + int32ToString(boundary.At);
+    } else {
+      const lines = matchValue.fields[0] | 0;
+      return "f" + int32ToString(lines) + "@" + int32ToString(boundary.At);
+    }
+  }, layout.Boundaries)) + "]";
+}
+function showSeparation(separation) {
+  let matchValue = void 0;
+  if (separation.tag === /* NewLine */
+  1) {
+    const lineBreak = separation.fields[0];
+    return "newline(" + (matchValue = lineBreak.Comment, matchValue == null ? "" : showComment(matchValue) + " ") + showTriviaList(lineBreak.Following) + ")";
+  } else {
+    return "inline";
+  }
+}
+function showTag(tag) {
+  if (tag.tag === /* Named */
+  1) {
+    return escape(YamlTagModule_identifier(tag));
+  } else {
+    return "!";
+  }
+}
+function showStyle(style) {
+  switch (style.tag) {
+    case /* SingleQuoted */
+    1:
+      return "single";
+    case /* DoubleQuoted */
+    2:
+      return "double";
+    case /* Block */
+    3: {
+      const indentation = style.fields[2];
+      const chomping = style.fields[1];
+      return "block(" + (equals(style.fields[0], BlockScalarStyle.Literal) ? "|" : ">") + (indentation == null ? "" : int32ToString(indentation)) + (chomping.tag === /* Clip */
+      1 ? "" : chomping.tag === /* Keep */
+      2 ? "+" : "-") + ")";
+    }
+    default:
+      return "plain";
+  }
+}
+function showCollectionStyle(style) {
+  if (style.tag === /* Flow */
+  1) {
+    return "flow";
+  } else {
+    return "block";
+  }
+}
+function showLayout(placement) {
+  return (placement.Property.tag === /* Anchor */
+  1 ? "anchor" : "tag") + ":" + showSeparation(placement.After);
+}
+function nodeLine(role, node) {
+  const sb = StringBuilder_$ctor();
+  StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, role), ": ");
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1: {
+      const collection = matchValue.fields[0];
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, "mapping "), showCollectionStyle(collection.Style));
+      break;
+    }
+    case /* Sequence */
+    2: {
+      const collection_1 = matchValue.fields[0];
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, "sequence "), showCollectionStyle(collection_1.Style));
+      break;
+    }
+    case /* Alias */
+    3: {
+      const name = matchValue.fields[0];
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, "alias *"), escape(name));
+      break;
+    }
+    default: {
+      const scalar = matchValue.fields[0];
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, "scalar "), showStyle(scalar.Style)), " "), quoted(scalar.Value));
+    }
+  }
+  const matchValue_1 = node.Properties.Tag;
+  if (matchValue_1 == null) {
+  } else {
+    const tag = matchValue_1;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " tag="), showTag(tag));
+  }
+  const matchValue_2 = node.Properties.Anchor;
+  if (matchValue_2 == null) {
+  } else {
+    const anchor = matchValue_2;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " anchor=&"), escape(anchor));
+  }
+  if (!isEmpty(node.PropertyLayout)) {
+    StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " layout=["), join("; ", map(showLayout, node.PropertyLayout))), "]");
+  }
+  const matchValue_3 = node.Kind;
+  switch (matchValue_3.tag) {
+    case /* Mapping */
+    1: {
+      const matchValue_6 = matchValue_3.fields[0].OpeningComment;
+      if (matchValue_6 == null) {
+      } else {
+        const comment_1 = matchValue_6;
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " opening="), showComment(comment_1));
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      const matchValue_7 = matchValue_3.fields[0].OpeningComment;
+      if (matchValue_7 == null) {
+      } else {
+        const comment_2 = matchValue_7;
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " opening="), showComment(comment_2));
+      }
+      break;
+    }
+    case /* Alias */
+    3: {
+      break;
+    }
+    default: {
+      const scalar_1 = matchValue_3.fields[0];
+      const matchValue_4 = scalar_1.Layout;
+      if (matchValue_4 == null) {
+      } else {
+        const breaks = matchValue_4;
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " breaks="), showBreaks(breaks));
+      }
+      const matchValue_5 = scalar_1.HeaderComment;
+      if (matchValue_5 == null) {
+      } else {
+        const comment = matchValue_5;
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " header="), showComment(comment));
+      }
+    }
+  }
+  const matchValue_8 = node.TrailingComment;
+  if (matchValue_8 == null) {
+  } else {
+    const comment_3 = matchValue_8;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " comment="), showComment(comment_3));
+  }
+  return toString(sb);
+}
+function entryLine(entry) {
+  const sb = StringBuilder_$ctor();
+  StringBuilder__Append_Z721C83C5(sb, "entry");
+  if (!isEmpty(entry.Before)) {
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " before="), showTriviaList(entry.Before));
+  }
+  const matchValue = entry.Question;
+  if (matchValue == null) {
+  } else {
+    const separation = matchValue;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " question="), showSeparation(separation));
+  }
+  if (!isEmpty(entry.BeforeColon)) {
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " before-colon="), showTriviaList(entry.BeforeColon));
+  }
+  const matchValue_1 = entry.Colon;
+  if (matchValue_1 == null) {
+    StringBuilder__Append_Z721C83C5(sb, " colon=omitted");
+  } else if (matchValue_1.tag === /* Inline */
+  0) {
+  } else {
+    const separation_1 = matchValue_1;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " colon="), showSeparation(separation_1));
+  }
+  return toString(sb);
+}
+function itemLine(item) {
+  const sb = StringBuilder_$ctor();
+  StringBuilder__Append_Z721C83C5(sb, "item");
+  if (!isEmpty(item.Before)) {
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " before="), showTriviaList(item.Before));
+  }
+  const matchValue = item.Dash;
+  if (matchValue == null) {
+  } else if (matchValue.tag === /* Inline */
+  0) {
+  } else {
+    const separation = matchValue;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, " dash="), showSeparation(separation));
+  }
+  return toString(sb);
+}
+function Work_Line(depth, text) {
+  return new Work(0, [depth, text]);
+}
+function Work_Node$(depth, role, node) {
+  return new Work(1, [depth, role, node]);
+}
+class Work extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Line", "Node"];
+  }
+}
+function Work_$reflection() {
+  return union_type("YAMLicious.NodeComparison.Work", [], Work, () => [[["depth", int32_type], ["text", string_type]], [["depth", int32_type], ["role", string_type], ["node", YamlNode_$reflection()]]]);
+}
+function render(output, startDepth, role, node) {
+  const stack = [];
+  void stack.push(Work_Node$(startDepth, role, node));
+  while (stack.length > 0) {
+    const last = stack.length - 1 | 0;
+    const work = item(last, stack);
+    stack.splice(last, 1);
+    if (work.tag === /* Node */
+    1) {
+      const nodeRole = work.fields[1];
+      const depth_1 = work.fields[0] | 0;
+      const current = work.fields[2];
+      StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, indent(depth_1)), nodeLine(nodeRole, current)), "\n");
+      const matchValue = current.Kind;
+      switch (matchValue.tag) {
+        case /* Sequence */
+        2: {
+          const collection_1 = matchValue.fields[0];
+          if (!isEmpty(collection_1.End)) {
+            void stack.push(Work_Line(depth_1 + 1, "end=" + showTriviaList(collection_1.End)));
+          }
+          const enumerator_1 = getEnumerator(reverse(collection_1.Items));
+          try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+              const item = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              void stack.push(Work_Node$(depth_1 + 2, "node", item.Node));
+              void stack.push(Work_Line(depth_1 + 1, itemLine(item)));
+            }
+          } finally {
+            disposeSafe(enumerator_1);
+          }
+          break;
+        }
+        case /* Scalar */
+        0:
+        case /* Alias */
+        3: {
+          break;
+        }
+        default: {
+          const collection = matchValue.fields[0];
+          if (!isEmpty(collection.End)) {
+            void stack.push(Work_Line(depth_1 + 1, "end=" + showTriviaList(collection.End)));
+          }
+          const enumerator = getEnumerator(reverse(collection.Items));
+          try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+              const entry = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              void stack.push(Work_Node$(depth_1 + 2, "value", entry.Value));
+              void stack.push(Work_Node$(depth_1 + 2, "key", entry.Key));
+              void stack.push(Work_Line(depth_1 + 1, entryLine(entry)));
+            }
+          } finally {
+            disposeSafe(enumerator);
+          }
+        }
+      }
+    } else {
+      const text = work.fields[1];
+      StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, indent(work.fields[0])), text), "\n");
+    }
+  }
+}
+function showNode(node) {
+  const output = StringBuilder_$ctor();
+  render(output, 0, "root", node);
+  return toString(output);
+}
+function showDirective(directive) {
+  let kind;
+  const matchValue = directive.Kind;
+  switch (matchValue.tag) {
+    case /* TagDirective */
+    1: {
+      kind = "tag " + matchValue.fields[0] + " " + matchValue.fields[1];
+      break;
+    }
+    case /* ReservedDirective */
+    2: {
+      kind = "reserved " + matchValue.fields[0] + " [" + join(" ", matchValue.fields[1]) + "]";
+      break;
+    }
+    default: {
+      const minor = matchValue.fields[1] | 0;
+      kind = "version " + int32ToString(matchValue.fields[0]) + "." + int32ToString(minor);
+    }
+  }
+  const matchValue_1 = directive.TrailingComment;
+  if (matchValue_1 == null) {
+    return kind;
+  } else {
+    return kind + " comment=" + showComment(matchValue_1);
+  }
+}
+function appendMarker(output, indentation, name, marker) {
+  if (marker != null) {
+    const m = marker;
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, indentation), name);
+    const matchValue = m.TrailingComment;
+    if (matchValue == null) {
+    } else {
+      const comment = matchValue;
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, " comment="), showComment(comment));
+    }
+    StringBuilder__Append_244C7CD6(output, "\n");
+  }
+}
+function appendDocument(output, document$) {
+  StringBuilder__Append_Z721C83C5(output, "document\n");
+  const enumerator = getEnumerator(document$.Prelude);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (item.tag === /* PreludeTrivia */
+      1) {
+        const trivia = item.fields[0];
+        StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "  prelude: "), showTrivia(trivia)), "\n");
+      } else {
+        const directive = item.fields[0];
+        StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "  prelude: directive "), showDirective(directive)), "\n");
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  appendMarker(output, "  ", "start-marker", document$.StartMarker);
+  if (!isEmpty(document$.BeforeRoot)) {
+    StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "  before-root="), showTriviaList(document$.BeforeRoot)), "\n");
+  }
+  render(output, 1, "root", document$.Root);
+  if (!isEmpty(document$.AfterRoot)) {
+    StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "  after-root="), showTriviaList(document$.AfterRoot)), "\n");
+  }
+  appendMarker(output, "  ", "end-marker", document$.EndMarker);
+  if (!isEmpty(document$.AfterEndMarker)) {
+    StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "  after-end-marker="), showTriviaList(document$.AfterEndMarker)), "\n");
+  }
+}
+function showDocument(document$) {
+  const output = StringBuilder_$ctor();
+  appendDocument(output, document$);
+  return toString(output);
+}
+function showStream(stream) {
+  const output = StringBuilder_$ctor();
+  StringBuilder__Append_Z721C83C5(output, "stream\n");
+  const enumerator = getEnumerator(stream.Parts);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const part = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      switch (part.tag) {
+        case /* Trivia */
+        1: {
+          const trivia = part.fields[0];
+          StringBuilder__Append_244C7CD6(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(output, "trivia: "), showTrivia(trivia)), "\n");
+          break;
+        }
+        case /* ExtraEndMarker */
+        2: {
+          appendMarker(output, "", "extra-end-marker", part.fields[0]);
+          break;
+        }
+        default:
+          appendDocument(output, part.fields[0]);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return toString(output);
+}
+
+export { documentsEqualIgnoringSpans, nodesEqualIgnoringSpans, showDocument, showNode, showStream, streamsEqualIgnoringSpans };