@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.1

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

@@ -0,0 +1,391 @@
+import { value, defaultArg, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { PreprocessorElement_Level, PreprocessorElement_Line, 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, 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;
+}
+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) {
+      if (value(matchValue_1).tag === /* Block */
+      3) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return hasMultiline;
+  }
+}
+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_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_2, value_3, seq_1, anyElse;
+        if (key.Comment != null) {
+          matchResult = 0;
+        } else {
+          switch (v.tag) {
+            case /* Value */
+            1: {
+              if (Formatting_shouldEmitBlockScalar(options, v.fields[0])) {
+                matchResult = 1;
+                value_2 = v.fields[0];
+              } else {
+                matchResult = 2;
+                value_3 = v.fields[0];
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (StyleVerifier_checkInlineSequence(v.fields[0])) {
+                matchResult = 3;
+                seq_1 = v.fields[0];
+              } else {
+                matchResult = 4;
+                anyElse = v;
+              }
+              break;
+            }
+            default: {
+              matchResult = 4;
+              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_mkBlockScalarMapping(options, key, value_2);
+          case 2:
+            return PreprocessorElement_Line(Formatting_mkMappingKey(options, key) + " " + Formatting_mkInlineContent(options, value_3));
+          case 3:
+            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 /* Value */
+      1:
+        if (Formatting_shouldEmitBlockScalar(options, ele_1.fields[0])) {
+          const value_4 = ele_1.fields[0];
+          return Formatting_mkBlockScalarRoot(options, value_4);
+        } else {
+          const value_5 = ele_1.fields[0];
+          return PreprocessorElement_Line(Formatting_mkInlineContent(options, value_5));
+        }
+      case /* Object */
+      3: {
+        const seq_2 = ele_1.fields[0];
+        return PreprocessorElement_Level(toList(delay(() => map$2(loop, seq_2))));
+      }
+      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_7, value_8, nested_1, anyElse_1;
+          switch (matchValue.tag) {
+            case /* Value */
+            1: {
+              if (Formatting_shouldEmitBlockScalar(options, matchValue.fields[0])) {
+                matchResult_1 = 0;
+                value_7 = matchValue.fields[0];
+              } else {
+                matchResult_1 = 1;
+                value_8 = matchValue.fields[0];
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (StyleVerifier_checkInlineSequence(matchValue.fields[0])) {
+                matchResult_1 = 2;
+                nested_1 = matchValue.fields[0];
+              } else {
+                matchResult_1 = 3;
+                anyElse_1 = matchValue;
+              }
+              break;
+            }
+            default: {
+              matchResult_1 = 3;
+              anyElse_1 = matchValue;
+            }
+          }
+          switch (matchResult_1) {
+            case 0:
+              return singleton(Formatting_mkBlockScalarSequenceItem(options, value_7));
+            case 1:
+              return singleton(PreprocessorElement_Line(Formatting_mkMinusLine(Formatting_mkInlineContent(options, value_8))));
+            case 2:
+              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 = ele_1.fields[0];
+        return PreprocessorElement_Line("*" + a);
+      }
+      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_resolveBlockStyle, Formatting_shouldEmitBlockScalar, StyleVerifier_checkInlineSequence, detokenize, detokenizeWithOptions, write, writeWithOptions };