@nfdi4plants/arctrl 3.0.3 → 3.1.0

package/dist/ts/ts/fable_modules/YAMLicious.1.0.0-alpha.7/Writer.fs.js

@@ -0,0 +1,659 @@
+import { value, defaultArg, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { PreprocessorElement_Line, PreprocessorElement_Level, YAMLContent, ScalarStyle_Plain, PreprocessorElement_Intendation, PreprocessorElement_Nil, WriterOptions_get_Default } from './YAMLiciousTypes.fs.js';
+import { forAll, toList, delay, collect, singleton, map as map$2 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { map as map$1, ofArray, isEmpty, empty, head, tail, cons, reverse, singleton as singleton$1 } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { replace, join, trimEnd, substring, split } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { int32ToString } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { write as write$1 } from './Preprocessing.fs.js';
+
+function StyleVerifier_isInlineSimpleScalar(v) {
+  if (!(v.Value.indexOf("\n") >= 0) && v.Comment == null) {
+    const matchValue = v.Style;
+    let matchResult;
+    if (matchValue != null) {
+      switch (value(matchValue).tag) {
+        case /* Block */
+        3: {
+          matchResult = 1;
+          break;
+        }
+        default:
+          matchResult = 0;
+      }
+    } else {
+      matchResult = 0;
+    }
+    switch (matchResult) {
+      case 0:
+        return true;
+      default:
+        return false;
+    }
+  } else {
+    return false;
+  }
+}
+function StyleVerifier_checkInlineSequence(ele) {
+  return forAll((x) => {
+    if (x.tag === /* Value */
+    1) {
+      return StyleVerifier_isInlineSimpleScalar(x.fields[0]);
+    } else {
+      return false;
+    }
+  }, ele);
+}
+function Formatting_mkComment(comment) {
+  return "#" + comment;
+}
+function Formatting_mkKey(key) {
+  return key + ":";
+}
+function Formatting_mkMinusLine(c) {
+  return "- " + c;
+}
+const Formatting_continuationPrefix = "  ";
+function Formatting_mkTag(tag) {
+  let s;
+  if (tag != null) {
+    if (value(tag) === "!") {
+      return "! ";
+    } else if (s = value(tag), s.startsWith("!") && !s.startsWith("!!")) {
+      const s_1 = value(tag);
+      return s_1 + " ";
+    } else {
+      const s_2 = value(tag);
+      return "!<" + s_2 + "> ";
+    }
+  } else {
+    return "";
+  }
+}
+function Formatting_mkAnchor(anchor) {
+  return defaultArg(map((s) => "&" + s + " ", anchor), "");
+}
+function Formatting_mkNodePrefix(content) {
+  return Formatting_mkTag(content.Tag) + Formatting_mkAnchor(content.Anchor);
+}
+function Formatting_appendOptionalComment(comment, s) {
+  return s + defaultArg(map((c) => " " + Formatting_mkComment(c), comment), "");
+}
+function Formatting_appendComment(content, s) {
+  return Formatting_appendOptionalComment(content.Comment, s);
+}
+function Formatting_escapeSingleQuoted(s) {
+  return replace(s, "'", "''");
+}
+function Formatting_escapeDoubleQuoted(s) {
+  return replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(s, "\\", "\\\\"), '"', '\\"'), "\0", "\\0"), "\x07", "\\a"), "\b", "\\b"), "	", "\\t"), "\v", "\\v"), "\f", "\\f"), "\r", "\\r"), "\x1B", "\\e"), "…", "\\N"), " ", "\\_"), "\u2028", "\\L"), "\u2029", "\\P"), "\n", "\\n");
+}
+function Formatting_normalizeNewlines(s) {
+  return replace(s, "\r\n", "\n");
+}
+function Formatting_resolveBlockStyle(options, content) {
+  const matchValue_1 = content.Style;
+  let matchResult, chomp, indent, style;
+  if (options.PreserveScalarStyle) {
+    if (matchValue_1 != null) {
+      if (value(matchValue_1).tag === /* Block */
+      3) {
+        matchResult = 0;
+        chomp = value(matchValue_1).fields[1];
+        indent = value(matchValue_1).fields[2];
+        style = value(matchValue_1).fields[0];
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return [style, chomp, indent];
+    default:
+      return [options.MultilineFallbackStyle, options.MultilineFallbackChomping, void 0];
+  }
+}
+function Formatting_scalarToInlineText(options, content) {
+  const v = content.Value;
+  if (options.PreserveScalarStyle) {
+    const matchValue = content.Style;
+    let matchResult;
+    if (matchValue != null) {
+      switch (value(matchValue).tag) {
+        case /* SingleQuoted */
+        1: {
+          matchResult = 0;
+          break;
+        }
+        case /* DoubleQuoted */
+        2: {
+          matchResult = 1;
+          break;
+        }
+        default:
+          matchResult = 2;
+      }
+    } else {
+      matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0:
+        return "'" + Formatting_escapeSingleQuoted(v) + "'";
+      case 1:
+        return '"' + Formatting_escapeDoubleQuoted(v) + '"';
+      default:
+        return v;
+    }
+  } else {
+    return v;
+  }
+}
+function Formatting_mkKeyContent(options, content) {
+  return Formatting_mkNodePrefix(content) + Formatting_scalarToInlineText(options, content);
+}
+function Formatting_mkMappingKey(options, key) {
+  return Formatting_mkKey(Formatting_mkKeyContent(options, key));
+}
+function Formatting_shouldEmitBlockScalar(options, content) {
+  const hasMultiline = content.Value.indexOf("\n") >= 0;
+  const matchValue_1 = content.Style;
+  let matchResult;
+  if (options.PreserveScalarStyle) {
+    if (matchValue_1 != null) {
+      switch (value(matchValue_1).tag) {
+        case /* Plain */
+        0: {
+          matchResult = 0;
+          break;
+        }
+        case /* Block */
+        3: {
+          matchResult = 1;
+          break;
+        }
+        default:
+          matchResult = 2;
+      }
+    } else {
+      matchResult = 2;
+    }
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return false;
+    case 1:
+      return true;
+    default:
+      return hasMultiline;
+  }
+}
+function Formatting_shouldEmitPlainMultilineScalar(options, content) {
+  if (options.PreserveScalarStyle && content.Value.indexOf("\n") >= 0) {
+    const matchValue = content.Style;
+    let matchResult;
+    if (matchValue != null) {
+      if (value(matchValue).tag === /* Plain */
+      0) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return true;
+      default:
+        return false;
+    }
+  } else {
+    return false;
+  }
+}
+function Formatting_mkInlineContent(options, content) {
+  const inlineScalar = Formatting_scalarToInlineText(options, content);
+  return Formatting_appendComment(content, Formatting_mkNodePrefix(content) + inlineScalar);
+}
+function Formatting_mkInlineSequence(options, seq) {
+  return "[" + join(", ", map$1((x) => {
+    if (x.tag === /* Value */
+    1) {
+      const v = x.fields[0];
+      return Formatting_mkNodePrefix(v) + Formatting_scalarToInlineText(options, v);
+    } else {
+      throw new Error("Invalid sequence element");
+    }
+  }, seq)) + "]";
+}
+function Formatting_mkBlockHeader(style, chomp, indent) {
+  return (style.tag === /* Folded */
+  1 ? ">" : "|") + defaultArg(map(int32ToString, indent), "") + (chomp.tag === /* Clip */
+  1 ? "" : chomp.tag === /* Keep */
+  2 ? "+" : "-");
+}
+function Formatting_bodyTextForChomping(chomp, value) {
+  const normalized = Formatting_normalizeNewlines(value);
+  switch (chomp.tag) {
+    case /* Clip */
+    1:
+    case /* Keep */
+    2:
+      if (normalized.endsWith("\n")) {
+        return substring(normalized, 0, normalized.length - 1);
+      } else {
+        return normalized;
+      }
+    default:
+      return trimEnd(normalized, "\n");
+  }
+}
+function Formatting_splitPreservingEmpty(s) {
+  return ofArray(split(s, ["\n"], void 0, 0));
+}
+function Formatting_plainMultilineLines(content) {
+  return Formatting_splitPreservingEmpty(Formatting_normalizeNewlines(content.Value));
+}
+function Formatting_mkPlainMultilineNode(mkHeader, lines) {
+  const patternInput = isEmpty(lines) ? ["", empty()] : [head(lines), tail(lines)];
+  const continuationLines = map$1((line) => PreprocessorElement_Line(Formatting_continuationPrefix + line), patternInput[1]);
+  return PreprocessorElement_Level(cons(PreprocessorElement_Line(mkHeader(patternInput[0])), continuationLines));
+}
+function Formatting_mkPlainMultilineMapping(options, key, content) {
+  return Formatting_mkPlainMultilineNode((firstLine) => Formatting_appendComment(content, Formatting_mkMappingKey(options, key) + " " + Formatting_mkNodePrefix(content) + firstLine), Formatting_plainMultilineLines(content));
+}
+function Formatting_mkPlainMultilineSequenceItem(options, content) {
+  return Formatting_mkPlainMultilineNode((firstLine) => Formatting_appendComment(content, "- " + Formatting_mkNodePrefix(content) + firstLine), Formatting_plainMultilineLines(content));
+}
+function Formatting_mkPlainMultilineRoot(options, content) {
+  return Formatting_mkPlainMultilineNode((firstLine) => Formatting_appendComment(content, Formatting_mkNodePrefix(content) + firstLine), Formatting_plainMultilineLines(content));
+}
+function Formatting_tryLegacyPlainMultilineContent(items) {
+  const loop = (allowMetadata_1_mut, remaining_mut, acc_mut) => {
+    let content, matchValue;
+    loop:
+      while (true) {
+        const allowMetadata_1 = allowMetadata_1_mut, remaining = remaining_mut, acc = acc_mut;
+        let matchResult, content_2, rest_1;
+        if (!isEmpty(remaining)) {
+          if (head(remaining).tag === /* Value */
+          1) {
+            if (content = head(remaining).fields[0], (matchValue = content.Style, matchValue != null ? value(matchValue).tag === /* Plain */
+            0 : true) && (allowMetadata_1 ? true : content.Comment == null && content.Anchor == null && content.Tag == null)) {
+              matchResult = 1;
+              content_2 = head(remaining).fields[0];
+              rest_1 = tail(remaining);
+            } else {
+              matchResult = 2;
+            }
+          } else {
+            matchResult = 2;
+          }
+        } else {
+          matchResult = 0;
+        }
+        switch (matchResult) {
+          case 0:
+            return reverse(acc);
+          case 1: {
+            allowMetadata_1_mut = false;
+            remaining_mut = rest_1;
+            acc_mut = cons(content_2, acc);
+            continue loop;
+          }
+          default:
+            return void 0;
+        }
+        break;
+      }
+  };
+  const matchValue_1 = loop(true, items, empty());
+  let matchResult_1, firstSegment, segments;
+  if (matchValue_1 != null) {
+    if (!isEmpty(value(matchValue_1))) {
+      if (!isEmpty(tail(value(matchValue_1)))) {
+        matchResult_1 = 0;
+        firstSegment = head(value(matchValue_1));
+        segments = value(matchValue_1);
+      } else {
+        matchResult_1 = 1;
+      }
+    } else {
+      matchResult_1 = 1;
+    }
+  } else {
+    matchResult_1 = 1;
+  }
+  switch (matchResult_1) {
+    case 0:
+      return new YAMLContent(join("\n", map$1((segment) => segment.Value, segments)), firstSegment.Comment, firstSegment.Anchor, firstSegment.Tag, ScalarStyle_Plain());
+    default:
+      return void 0;
+  }
+}
+function Formatting_mkBlockScalarMapping(options, key, content) {
+  const patternInput = Formatting_resolveBlockStyle(options, content);
+  const chomp = patternInput[1];
+  const header = Formatting_mkBlockHeader(patternInput[0], chomp, patternInput[2]);
+  const lines = Formatting_splitPreservingEmpty(Formatting_bodyTextForChomping(chomp, content.Value));
+  return PreprocessorElement_Level(ofArray([PreprocessorElement_Line(Formatting_appendComment(content, Formatting_mkMappingKey(options, key) + " " + Formatting_mkNodePrefix(content) + header)), PreprocessorElement_Intendation(map$1(PreprocessorElement_Line, lines))]));
+}
+function Formatting_mkBlockScalarSequenceItem(options, content) {
+  const patternInput = Formatting_resolveBlockStyle(options, content);
+  const chomp = patternInput[1];
+  const header = Formatting_mkBlockHeader(patternInput[0], chomp, patternInput[2]);
+  const lines = Formatting_splitPreservingEmpty(Formatting_bodyTextForChomping(chomp, content.Value));
+  return PreprocessorElement_Level(ofArray([PreprocessorElement_Line(Formatting_appendComment(content, "- " + Formatting_mkNodePrefix(content) + header)), PreprocessorElement_Intendation(map$1(PreprocessorElement_Line, lines))]));
+}
+function Formatting_mkBlockScalarRoot(options, content) {
+  const patternInput = Formatting_resolveBlockStyle(options, content);
+  const chomp = patternInput[1];
+  const header = Formatting_mkBlockHeader(patternInput[0], chomp, patternInput[2]);
+  const lines = Formatting_splitPreservingEmpty(Formatting_bodyTextForChomping(chomp, content.Value));
+  return PreprocessorElement_Level(ofArray([PreprocessorElement_Line(Formatting_appendComment(content, Formatting_mkNodePrefix(content) + header)), PreprocessorElement_Intendation(map$1(PreprocessorElement_Line, lines))]));
+}
+function detokenizeWithOptions(options, ele) {
+  const loop = (ele_1) => {
+    switch (ele_1.tag) {
+      case /* Mapping */
+      0: {
+        const key = ele_1.fields[0];
+        const v = ele_1.fields[1];
+        let matchResult, value_6, value_7, value_8, a, items_5, value_10, value_11, value_12, seq_1, anyElse;
+        if (key.Comment != null) {
+          matchResult = 0;
+        } else {
+          switch (v.tag) {
+            case /* Object */
+            3: {
+              if (!isEmpty(v.fields[0])) {
+                switch (head(v.fields[0]).tag) {
+                  case /* Value */
+                  1: {
+                    if (isEmpty(tail(v.fields[0]))) {
+                      if (Formatting_shouldEmitPlainMultilineScalar(options, head(v.fields[0]).fields[0])) {
+                        matchResult = 1;
+                        value_6 = head(v.fields[0]).fields[0];
+                      } else if (Formatting_shouldEmitBlockScalar(options, head(v.fields[0]).fields[0])) {
+                        matchResult = 2;
+                        value_7 = head(v.fields[0]).fields[0];
+                      } else {
+                        matchResult = 3;
+                        value_8 = head(v.fields[0]).fields[0];
+                      }
+                    } else if (Formatting_tryLegacyPlainMultilineContent(v.fields[0]) != null) {
+                      matchResult = 5;
+                      items_5 = v.fields[0];
+                    } else {
+                      matchResult = 10;
+                      anyElse = v;
+                    }
+                    break;
+                  }
+                  case /* Alias */
+                  7: {
+                    if (isEmpty(tail(v.fields[0]))) {
+                      matchResult = 4;
+                      a = head(v.fields[0]).fields[0];
+                    } else if (Formatting_tryLegacyPlainMultilineContent(v.fields[0]) != null) {
+                      matchResult = 5;
+                      items_5 = v.fields[0];
+                    } else {
+                      matchResult = 10;
+                      anyElse = v;
+                    }
+                    break;
+                  }
+                  default:
+                    if (Formatting_tryLegacyPlainMultilineContent(v.fields[0]) != null) {
+                      matchResult = 5;
+                      items_5 = v.fields[0];
+                    } else {
+                      matchResult = 10;
+                      anyElse = v;
+                    }
+                }
+              } else if (Formatting_tryLegacyPlainMultilineContent(v.fields[0]) != null) {
+                matchResult = 5;
+                items_5 = v.fields[0];
+              } else {
+                matchResult = 10;
+                anyElse = v;
+              }
+              break;
+            }
+            case /* Value */
+            1: {
+              if (Formatting_shouldEmitBlockScalar(options, v.fields[0])) {
+                matchResult = 6;
+                value_10 = v.fields[0];
+              } else if (Formatting_shouldEmitPlainMultilineScalar(options, v.fields[0])) {
+                matchResult = 7;
+                value_11 = v.fields[0];
+              } else {
+                matchResult = 8;
+                value_12 = v.fields[0];
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (StyleVerifier_checkInlineSequence(v.fields[0])) {
+                matchResult = 9;
+                seq_1 = v.fields[0];
+              } else {
+                matchResult = 10;
+                anyElse = v;
+              }
+              break;
+            }
+            default: {
+              matchResult = 10;
+              anyElse = v;
+            }
+          }
+        }
+        switch (matchResult) {
+          case 0:
+            return PreprocessorElement_Level(ofArray([PreprocessorElement_Line(Formatting_appendOptionalComment(key.Comment, Formatting_mkMappingKey(options, key))), PreprocessorElement_Intendation(singleton$1(loop(v)))]));
+          case 1:
+            return Formatting_mkPlainMultilineMapping(options, key, value_6);
+          case 2:
+            return Formatting_mkBlockScalarMapping(options, key, value_7);
+          case 3:
+            return PreprocessorElement_Line(Formatting_mkMappingKey(options, key) + " " + Formatting_mkInlineContent(options, value_8));
+          case 4:
+            return PreprocessorElement_Line(Formatting_mkMappingKey(options, key) + " *" + a);
+          case 5:
+            return Formatting_mkPlainMultilineMapping(options, key, value(Formatting_tryLegacyPlainMultilineContent(items_5)));
+          case 6:
+            return Formatting_mkBlockScalarMapping(options, key, value_10);
+          case 7:
+            return Formatting_mkPlainMultilineMapping(options, key, value_11);
+          case 8:
+            return PreprocessorElement_Line(Formatting_mkMappingKey(options, key) + " " + Formatting_mkInlineContent(options, value_12));
+          case 9:
+            return PreprocessorElement_Line(Formatting_mkMappingKey(options, key) + " " + Formatting_mkInlineSequence(options, seq_1));
+          default:
+            return PreprocessorElement_Level(ofArray([PreprocessorElement_Line(Formatting_mkMappingKey(options, key)), PreprocessorElement_Intendation(singleton$1(loop(anyElse)))]));
+        }
+      }
+      case /* Object */
+      3:
+        if (Formatting_tryLegacyPlainMultilineContent(ele_1.fields[0]) != null) {
+          const items_6 = ele_1.fields[0];
+          return Formatting_mkPlainMultilineRoot(options, value(Formatting_tryLegacyPlainMultilineContent(items_6)));
+        } else {
+          const seq_2 = ele_1.fields[0];
+          return PreprocessorElement_Level(toList(delay(() => map$2(loop, seq_2))));
+        }
+      case /* Value */
+      1:
+        if (Formatting_shouldEmitPlainMultilineScalar(options, ele_1.fields[0])) {
+          const value_14 = ele_1.fields[0];
+          return Formatting_mkPlainMultilineRoot(options, value_14);
+        } else if (Formatting_shouldEmitBlockScalar(options, ele_1.fields[0])) {
+          const value_15 = ele_1.fields[0];
+          return Formatting_mkBlockScalarRoot(options, value_15);
+        } else {
+          const value_16 = ele_1.fields[0];
+          return PreprocessorElement_Line(Formatting_mkInlineContent(options, value_16));
+        }
+      case /* Sequence */
+      2: {
+        const seq_3 = ele_1.fields[0];
+        return PreprocessorElement_Level(toList(delay(() => collect((element_1) => {
+          const matchValue = element_1;
+          let matchResult_1, value_21, value_22, value_23, a_1, items_11, value_25, value_26, value_27, nested_1, anyElse_1;
+          switch (matchValue.tag) {
+            case /* Object */
+            3: {
+              if (!isEmpty(matchValue.fields[0])) {
+                switch (head(matchValue.fields[0]).tag) {
+                  case /* Value */
+                  1: {
+                    if (isEmpty(tail(matchValue.fields[0]))) {
+                      if (Formatting_shouldEmitPlainMultilineScalar(options, head(matchValue.fields[0]).fields[0])) {
+                        matchResult_1 = 0;
+                        value_21 = head(matchValue.fields[0]).fields[0];
+                      } else if (Formatting_shouldEmitBlockScalar(options, head(matchValue.fields[0]).fields[0])) {
+                        matchResult_1 = 1;
+                        value_22 = head(matchValue.fields[0]).fields[0];
+                      } else {
+                        matchResult_1 = 2;
+                        value_23 = head(matchValue.fields[0]).fields[0];
+                      }
+                    } else if (Formatting_tryLegacyPlainMultilineContent(matchValue.fields[0]) != null) {
+                      matchResult_1 = 4;
+                      items_11 = matchValue.fields[0];
+                    } else {
+                      matchResult_1 = 9;
+                      anyElse_1 = matchValue;
+                    }
+                    break;
+                  }
+                  case /* Alias */
+                  7: {
+                    if (isEmpty(tail(matchValue.fields[0]))) {
+                      matchResult_1 = 3;
+                      a_1 = head(matchValue.fields[0]).fields[0];
+                    } else if (Formatting_tryLegacyPlainMultilineContent(matchValue.fields[0]) != null) {
+                      matchResult_1 = 4;
+                      items_11 = matchValue.fields[0];
+                    } else {
+                      matchResult_1 = 9;
+                      anyElse_1 = matchValue;
+                    }
+                    break;
+                  }
+                  default:
+                    if (Formatting_tryLegacyPlainMultilineContent(matchValue.fields[0]) != null) {
+                      matchResult_1 = 4;
+                      items_11 = matchValue.fields[0];
+                    } else {
+                      matchResult_1 = 9;
+                      anyElse_1 = matchValue;
+                    }
+                }
+              } else if (Formatting_tryLegacyPlainMultilineContent(matchValue.fields[0]) != null) {
+                matchResult_1 = 4;
+                items_11 = matchValue.fields[0];
+              } else {
+                matchResult_1 = 9;
+                anyElse_1 = matchValue;
+              }
+              break;
+            }
+            case /* Value */
+            1: {
+              if (Formatting_shouldEmitPlainMultilineScalar(options, matchValue.fields[0])) {
+                matchResult_1 = 5;
+                value_25 = matchValue.fields[0];
+              } else if (Formatting_shouldEmitBlockScalar(options, matchValue.fields[0])) {
+                matchResult_1 = 6;
+                value_26 = matchValue.fields[0];
+              } else {
+                matchResult_1 = 7;
+                value_27 = matchValue.fields[0];
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (StyleVerifier_checkInlineSequence(matchValue.fields[0])) {
+                matchResult_1 = 8;
+                nested_1 = matchValue.fields[0];
+              } else {
+                matchResult_1 = 9;
+                anyElse_1 = matchValue;
+              }
+              break;
+            }
+            default: {
+              matchResult_1 = 9;
+              anyElse_1 = matchValue;
+            }
+          }
+          switch (matchResult_1) {
+            case 0:
+              return singleton(Formatting_mkPlainMultilineSequenceItem(options, value_21));
+            case 1:
+              return singleton(Formatting_mkBlockScalarSequenceItem(options, value_22));
+            case 2:
+              return singleton(PreprocessorElement_Line(Formatting_mkMinusLine(Formatting_mkInlineContent(options, value_23))));
+            case 3:
+              return singleton(PreprocessorElement_Line("- *" + a_1));
+            case 4:
+              return singleton(Formatting_mkPlainMultilineSequenceItem(options, value(Formatting_tryLegacyPlainMultilineContent(items_11))));
+            case 5:
+              return singleton(Formatting_mkPlainMultilineSequenceItem(options, value_25));
+            case 6:
+              return singleton(Formatting_mkBlockScalarSequenceItem(options, value_26));
+            case 7:
+              return singleton(PreprocessorElement_Line(Formatting_mkMinusLine(Formatting_mkInlineContent(options, value_27))));
+            case 8:
+              return singleton(PreprocessorElement_Line(Formatting_mkMinusLine(Formatting_mkInlineSequence(options, nested_1))));
+            default:
+              return singleton(PreprocessorElement_Level(ofArray([PreprocessorElement_Line("-"), PreprocessorElement_Intendation(singleton$1(loop(anyElse_1)))])));
+          }
+        }, seq_3))));
+      }
+      case /* Comment */
+      4: {
+        const c = ele_1.fields[0];
+        return PreprocessorElement_Line(Formatting_mkComment(c));
+      }
+      case /* DocumentStart */
+      5:
+        return PreprocessorElement_Line("---");
+      case /* DocumentEnd */
+      6:
+        return PreprocessorElement_Line("...");
+      case /* Alias */
+      7: {
+        const a_2 = ele_1.fields[0];
+        return PreprocessorElement_Line("*" + a_2);
+      }
+      default:
+        return PreprocessorElement_Nil();
+    }
+  };
+  return loop(ele);
+}
+function detokenize(ele) {
+  return detokenizeWithOptions(WriterOptions_get_Default(), ele);
+}
+function writeWithOptions(ele, writerOptions, fconfig) {
+  return write$1(detokenizeWithOptions(writerOptions, ele), fconfig);
+}
+function write(ele, fconfig) {
+  return writeWithOptions(ele, WriterOptions_get_Default(), fconfig);
+}
+
+export { Formatting_appendOptionalComment, Formatting_mkBlockScalarMapping, Formatting_mkBlockScalarRoot, Formatting_mkBlockScalarSequenceItem, Formatting_mkComment, Formatting_mkInlineContent, Formatting_mkInlineSequence, Formatting_mkKey, Formatting_mkKeyContent, Formatting_mkMappingKey, Formatting_mkMinusLine, Formatting_mkNodePrefix, Formatting_mkPlainMultilineMapping, Formatting_mkPlainMultilineRoot, Formatting_mkPlainMultilineSequenceItem, Formatting_resolveBlockStyle, Formatting_shouldEmitBlockScalar, Formatting_shouldEmitPlainMultilineScalar, Formatting_tryLegacyPlainMultilineContent, StyleVerifier_checkInlineSequence, detokenize, detokenizeWithOptions, write, writeWithOptions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@nfdi4plants/arctrl",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Top level ARC DataModel and API function descriptions.",
   "repository": {
     "type": "git",