@nfdi4plants/arctrl 3.0.0 → 3.0.1

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

@@ -0,0 +1,1314 @@
+import { unescapeDoubleQuoted } from './Escapes.fs.js';
+import { BlockScalarStyle_Folded, BlockScalarStyle_Literal, ChompingMode_Clip, ChompingMode_Strip, ChompingMode_Keep, PreprocessorElement_Line, YAMLElement_Object, ScalarStyle_DoubleQuoted, ScalarStyle_SingleQuoted, YAMLElement_Value, YAMLContent_create_Z1C3A29C9, ScalarStyle_Block, YAMLElement_Comment, YAMLElement_Mapping, YAMLElement_Sequence, YAMLElement_Nil, YAMLElement_Alias } from './YAMLiciousTypes.fs.js';
+import { match, create, replace } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { value, map as map$1, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { getItemFromDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { equals, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { isNullOrWhiteSpace, trimEnd, substring, join, toFail, printf, trimStart, split, replace as replace$1 } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { length, takeWhile, toList, delay, append, singleton, skipWhile, map as map$2, collect as collect$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { min } from '../../../node_modules/@fable-org/fable-library-js/Double.js';
+import { toArray, map, filter, min as min$1, isEmpty, head, tail, empty, singleton as singleton$1, cons, collect, reverse, append as append$1, ofArrayWithTail, exists, forAll, ofArray } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { StringBuffer_$ctor, StringBuffer__Append_244C7CD6, StringBuffer__Append_Z721C83C5 } from './StringBuffer.fs.js';
+import { item, tryHead } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { $007CSequenceMinusOpener$007C_$007C, $007CYamlComment$007C_$007C, $007CAliasNode$007C_$007C, $007CDocumentEnd$007C_$007C, $007CSchemaNamespace$007C_$007C, $007CInlineSequence$007C_$007C, $007CSequenceSquareOpener$007C_$007C, $007CSequenceSquareCloser$007C_$007C, $007CInlineJSON$007C_$007C, $007CJSONKeyOpener$007C_$007C, $007CJSONCloser$007C_$007C, $007CExplicitKey$007C_$007C, $007CKey$007C_$007C, $007CKeyValue$007C_$007C, $007CYamlValue$007C_$007C, $007CExplicitValue$007C_$007C } from './RegexActivePatterns.fs.js';
+import { defaultContext, transformElements, TransformContext } from './FlowToBlock.fs.js';
+import { VerbatimTagPattern, AnchorPattern } from './Regex.fs.js';
+import { tryFind } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { read as read$1, isDocumentStart, isDocumentEnd } from './Preprocessing.fs.js';
+
+function restoreScalarPlaceholderValue(entry) {
+  if (entry.Kind.tag === /* DoubleQuotedString */
+  1) {
+    return unescapeDoubleQuoted(entry.Value);
+  } else {
+    return entry.Value;
+  }
+}
+function restoreBlockScalarPlaceholderValue(entry) {
+  if (entry.Kind.tag === /* DoubleQuotedString */
+  1) {
+    return '"' + entry.Value + '"';
+  } else {
+    return "'" + entry.Value + "'";
+  }
+}
+function tryParseExactPlaceholderIndex(v) {
+  const m = match(create(`^${"<s f=(?<index>\\d+)\\/>"}$`), v.trim());
+  if (m != null) {
+    return parse(m.groups && m.groups.index || "", 511, false, 32);
+  } else {
+    return void 0;
+  }
+}
+function restoreStringReplace(stringDict, v) {
+  return replace(v, "<s f=(?<index>\\d+)\\/>", (m) => restoreScalarPlaceholderValue(getItemFromDict(stringDict, parse(m.groups && m.groups.index || "", 511, false, 32))));
+}
+function parseBlockScalarHeader(header) {
+  let c;
+  const h = header.trim();
+  if (isNullOrWhiteSpace(h)) {
+    return void 0;
+  } else {
+    let styleOpt;
+    const matchValue = h[0];
+    styleOpt = matchValue === ">" ? BlockScalarStyle_Folded() : matchValue === "|" ? BlockScalarStyle_Literal() : void 0;
+    if (styleOpt != null) {
+      const style = value(styleOpt);
+      let indent = void 0;
+      let chomp = ChompingMode_Clip();
+      let isValid = true;
+      for (let i = 1; i <= h.length - 1; i++) {
+        const matchValue_1 = h[i];
+        if (c = matchValue_1, c >= "1" && c <= "9") {
+          if (indent != null) {
+            isValid = false;
+          } else {
+            indent = parse(matchValue_1, 511, false, 32);
+          }
+        } else {
+          switch (matchValue_1) {
+            case "+": {
+              if (!equals(chomp, ChompingMode_Clip())) {
+                isValid = false;
+              } else {
+                chomp = ChompingMode_Keep();
+              }
+              break;
+            }
+            case "-": {
+              if (!equals(chomp, ChompingMode_Clip())) {
+                isValid = false;
+              } else {
+                chomp = ChompingMode_Strip();
+              }
+              break;
+            }
+            default:
+              isValid = false;
+          }
+        }
+      }
+      if (isValid) {
+        return [style, indent, chomp];
+      } else {
+        return void 0;
+      }
+    } else {
+      return void 0;
+    }
+  }
+}
+function applyChomping(chomp, content) {
+  switch (chomp.tag) {
+    case /* Keep */
+    2:
+      return content;
+    case /* Clip */
+    1: {
+      const trimmed = trimEnd(content, "\r", "\n");
+      if (content.length > trimmed.length) {
+        return trimmed + "\n";
+      } else {
+        return trimmed;
+      }
+    }
+    default:
+      return trimEnd(content, "\r", "\n");
+  }
+}
+function countLeadingSpaces(line) {
+  return length(takeWhile((c) => c === " ", line.split("")));
+}
+function splitTrailingCommentPlaceholder(s) {
+  const m = match(create(`^(?<header>.*?)\\s*(?:${"<c f=(?<comment>\\d+)\\/>"})\\s*$`), s);
+  if (m != null) {
+    const header = trimEnd(m.groups && m.groups.header || "");
+    const commentGroup = m.groups && m.groups.comment;
+    return [header, commentGroup != null && (commentGroup || "") !== "" ? parse(commentGroup || "", 511, false, 32) : void 0];
+  } else {
+    return [trimEnd(s), void 0];
+  }
+}
+function stripBlockIndent(indent, line) {
+  if (line.trim() === "") {
+    return "";
+  } else {
+    return substring(line, min(indent, countLeadingSpaces(line)));
+  }
+}
+function foldLines(lines) {
+  const isMoreIndented = (line) => {
+    if (line.startsWith(" ")) {
+      return true;
+    } else {
+      return line.startsWith("	");
+    }
+  };
+  const arr = toArray(lines);
+  const sb = StringBuffer_$ctor();
+  for (let i = 0; i <= arr.length - 1; i++) {
+    const line_1 = item(i, arr);
+    if (line_1.trim() === "") {
+      StringBuffer__Append_244C7CD6(sb, "\n");
+    } else {
+      StringBuffer__Append_Z721C83C5(sb, line_1);
+      if (i < arr.length - 1) {
+        const next = item(i + 1, arr);
+        if (next.trim() === "") {
+          StringBuffer__Append_244C7CD6(sb, "\n");
+        } else if (isMoreIndented(line_1) ? true : isMoreIndented(next)) {
+          StringBuffer__Append_244C7CD6(sb, "\n");
+        } else {
+          StringBuffer__Append_244C7CD6(sb, " ");
+        }
+      }
+    }
+  }
+  return toString(sb);
+}
+function deindentBlockLines(headerIndent, explicitIndent, lines) {
+  let contentIndent;
+  if (explicitIndent == null) {
+    const _arg = map(countLeadingSpaces, filter((l) => l.trim() !== "", lines));
+    contentIndent = isEmpty(_arg) ? headerIndent : min$1(_arg, {
+      Compare: comparePrimitives
+    });
+  } else {
+    contentIndent = headerIndent + value(explicitIndent);
+  }
+  return map((line_1) => stripBlockIndent(contentIndent, line_1), lines);
+}
+function buildBlockScalarContent(style, chomp, headerIndent, explicitIndent, lines) {
+  let folded;
+  const deindentedLines = deindentBlockLines(headerIndent, explicitIndent, lines);
+  return applyChomping(chomp, style.tag === /* Folded */
+  1 ? (folded = foldLines(deindentedLines), folded.endsWith("\n") ? folded : folded + "\n") : isEmpty(deindentedLines) ? "" : join("\n", deindentedLines) + "\n");
+}
+function restoreCommentReplace(commentDict, commentId) {
+  return map$1((id) => getItemFromDict(commentDict, id), commentId);
+}
+function collectSequenceElements(eles) {
+  let matchResult, rest, v, yamlAstList;
+  if (!isEmpty(eles)) {
+    const activePatternResult = $007CSequenceMinusOpener$007C_$007C(head(eles));
+    if (activePatternResult != null) {
+      if (!isEmpty(tail(eles))) {
+        if (head(tail(eles)).tag === /* Intendation */
+        1) {
+          matchResult = 0;
+          rest = tail(tail(eles));
+          v = value(activePatternResult);
+          yamlAstList = head(tail(eles)).fields[0];
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return toList(delay(() => append(v.Value != null ? singleton(cons(PreprocessorElement_Line(value(v.Value)), yamlAstList)) : singleton(yamlAstList), delay(() => collectSequenceElements(rest)))));
+    default:
+      if (isEmpty(eles)) {
+        return empty();
+      } else {
+        const activePatternResult_1 = $007CSequenceMinusOpener$007C_$007C(head(eles));
+        if (activePatternResult_1 != null) {
+          const v_1 = value(activePatternResult_1);
+          return toList(delay(() => append(v_1.Value != null ? singleton(singleton$1(PreprocessorElement_Line(value(v_1.Value)))) : singleton(empty()), delay(() => collectSequenceElements(tail(eles))))));
+        } else if ($007CYamlComment$007C_$007C(head(eles)) != null) {
+          return toList(delay(() => append(singleton(singleton$1(head(eles))), delay(() => collectSequenceElements(tail(eles))))));
+        } else {
+          return toFail(printf("Unknown pattern for sequence elements: %A"))(eles);
+        }
+      }
+  }
+}
+function isSequenceElement(e) {
+  let matchResult;
+  if (e.tag === /* Intendation */
+  1) {
+    matchResult = 0;
+  } else if ($007CSequenceMinusOpener$007C_$007C(e) != null) {
+    matchResult = 0;
+  } else if ($007CYamlComment$007C_$007C(e) != null) {
+    matchResult = 0;
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+function tokenize(yamlList, stringDict, commentDict, handles) {
+  const ctx = defaultContext(stringDict);
+  const restoreInlinePlaceholders = (line) => replace(replace(line, "<s f=(?<index>\\d+)\\/>", (m) => restoreBlockScalarPlaceholderValue(getItemFromDict(stringDict, parse(m.groups && m.groups.index || "", 511, false, 32)))), "<c f=(?<comment>\\d+)\\/>", (m_1) => "#" + getItemFromDict(commentDict, parse(m_1.groups && m_1.groups.comment || "", 511, false, 32)));
+  const flattenBlockScalarWithDepth = (depth, eles) => collect((_arg) => {
+    switch (_arg.tag) {
+      case /* Line */
+      2: {
+        const s = _arg.fields[0];
+        return singleton$1((s === "" ? "" : Array(depth * 2 + 1).join(" ")) + restoreInlinePlaceholders(s));
+      }
+      case /* Intendation */
+      1:
+        return flattenBlockScalarWithDepth(depth + 1, _arg.fields[0]);
+      default:
+        return empty();
+    }
+  }, eles);
+  const flattenBlockScalar = (eles_1) => flattenBlockScalarWithDepth(0, eles_1);
+  const flattenBlockScalarContentWithDepth = (depth_1, eles_2) => collect((_arg_1) => {
+    switch (_arg_1.tag) {
+      case /* Line */
+      2: {
+        const s_1 = _arg_1.fields[0];
+        return singleton$1((s_1 === "" ? "" : Array((depth_1 + 1) * 2 + 1).join(" ")) + restoreInlinePlaceholders(s_1));
+      }
+      case /* Intendation */
+      1:
+        return flattenBlockScalarContentWithDepth(depth_1 + 1, _arg_1.fields[0]);
+      default:
+        return empty();
+    }
+  }, eles_2);
+  const extractProperties = (handles_2, v) => {
+    let shorthand, m_2, handle, suffix, matchValue_2;
+    let current = v.trim();
+    let tag = void 0;
+    let anchor = void 0;
+    let changed = true;
+    while (changed) {
+      changed = false;
+      const mTag = match(create(VerbatimTagPattern), current);
+      if (mTag != null) {
+        tag = mTag.groups && mTag.groups.tag || "";
+        current = substring(current, mTag[0].length).trim();
+        changed = true;
+      } else {
+        const mShort = match(/^(!\S*)/gu, current);
+        if (mShort != null) {
+          const raw_1 = mShort[1] || "";
+          tag = (shorthand = raw_1, shorthand === "!" ? "!" : (m_2 = match(/^(![\w-]+!|!!|!)(.*)/gu, shorthand), m_2 != null ? (handle = m_2[1] || "", suffix = m_2[2] || "", matchValue_2 = tryFind(handle, handles_2), matchValue_2 == null ? shorthand : value(matchValue_2) + suffix) : shorthand));
+          current = substring(current, mShort[0].length).trim();
+          changed = true;
+        }
+      }
+      const mAnchor = match(create(AnchorPattern), current);
+      if (mAnchor != null && current.startsWith("&")) {
+        anchor = mAnchor.groups && mAnchor.groups.anchor || "";
+        current = substring(current, mAnchor[0].length).trim();
+        changed = true;
+      }
+    }
+    return {
+      Anchor: unwrap(anchor),
+      Tag: unwrap(tag),
+      Value: current
+    };
+  };
+  const isBlockScalarHeaderCandidate = (rawHeader) => {
+    const props = extractProperties(handles, splitTrailingCommentPlaceholder(rawHeader)[0]);
+    if (props.Value.startsWith("|")) {
+      return true;
+    } else {
+      return props.Value.startsWith(">");
+    }
+  };
+  const tryReadBlockScalar = (rawHeader_1, headerIndent, baseCommentId, block) => {
+    const patternInput_1 = splitTrailingCommentPlaceholder(rawHeader_1);
+    const props_1 = extractProperties(handles, patternInput_1[0]);
+    const commentId = baseCommentId == null ? patternInput_1[1] : baseCommentId;
+    const matchValue_3 = parseBlockScalarHeader(props_1.Value);
+    if (matchValue_3 == null) {
+      return void 0;
+    } else {
+      const style_1 = value(matchValue_3)[0];
+      const indent = value(matchValue_3)[1];
+      const chomp = value(matchValue_3)[2];
+      const value_4 = buildBlockScalarContent(style_1, chomp, headerIndent, indent, flattenBlockScalarContentWithDepth(0, block));
+      return {
+        Chomp: chomp,
+        Comment: unwrap(restoreCommentReplace(commentDict, commentId)),
+        Indent: unwrap(indent),
+        Props: props_1,
+        Style: style_1,
+        Value: value_4
+      };
+    }
+  };
+  const loopRead = (handles_3_mut, restlist_mut, acc_mut) => {
+    let c2_2, c1_2, c1_1, c2_1, s_3, s_4, v_25, block_3, block_1, v_10, v_8, yamlAstList_1, v_2;
+    loopRead:
+      while (true) {
+        const handles_3 = handles_3_mut, restlist = restlist_mut, acc = acc_mut;
+        let matchResult, alias, rest;
+        if (!isEmpty(restlist)) {
+          const activePatternResult = $007CAliasNode$007C_$007C(head(restlist));
+          if (activePatternResult != null) {
+            matchResult = 0;
+            alias = value(activePatternResult);
+            rest = tail(restlist);
+          } else if ($007CDocumentEnd$007C_$007C(head(restlist)) != null) {
+            matchResult = 1;
+          } else {
+            matchResult = 2;
+          }
+        } else {
+          matchResult = 2;
+        }
+        switch (matchResult) {
+          case 0: {
+            handles_3_mut = handles_3;
+            restlist_mut = rest;
+            acc_mut = cons(YAMLElement_Alias(alias), acc);
+            continue loopRead;
+          }
+          case 1:
+            return YAMLElement_Object(reverse(acc));
+          default: {
+            let matchResult_1, rest0, v_1, yamlAstList;
+            if (!isEmpty(restlist)) {
+              const activePatternResult_2 = $007CSchemaNamespace$007C_$007C(head(restlist));
+              if (activePatternResult_2 != null) {
+                if (!isEmpty(tail(restlist))) {
+                  if (head(tail(restlist)).tag === /* Intendation */
+                  1) {
+                    matchResult_1 = 0;
+                    rest0 = tail(tail(restlist));
+                    v_1 = value(activePatternResult_2);
+                    yamlAstList = head(tail(restlist)).fields[0];
+                  } else {
+                    matchResult_1 = 1;
+                  }
+                } else {
+                  matchResult_1 = 1;
+                }
+              } else {
+                matchResult_1 = 1;
+              }
+            } else {
+              matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+              case 0: {
+                const sequenceElements = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0)));
+                handles_3_mut = handles_3;
+                restlist_mut = toList(skipWhile(isSequenceElement, rest0));
+                acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, cons(PreprocessorElement_Line(v_1.Key), yamlAstList), empty())), delay(() => map$2((i) => loopRead(handles_3, i, empty()), sequenceElements)))))), acc);
+                continue loopRead;
+              }
+              default: {
+                let matchResult_2, rest0_2, v_3, rest0_3, v_4, yamlAstList_2;
+                if (!isEmpty(restlist)) {
+                  const activePatternResult_3 = $007CSchemaNamespace$007C_$007C(head(restlist));
+                  if (activePatternResult_3 != null) {
+                    matchResult_2 = 0;
+                    rest0_2 = tail(restlist);
+                    v_3 = value(activePatternResult_3);
+                  } else {
+                    const activePatternResult_4 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                    if (activePatternResult_4 != null) {
+                      if (!isEmpty(tail(restlist))) {
+                        if (head(tail(restlist)).tag === /* Intendation */
+                        1) {
+                          if (yamlAstList_1 = head(tail(restlist)).fields[0], v_2 = value(activePatternResult_4), v_2.Value != null && isBlockScalarHeaderCandidate(value(v_2.Value))) {
+                            matchResult_2 = 1;
+                            rest0_3 = tail(tail(restlist));
+                            v_4 = value(activePatternResult_4);
+                            yamlAstList_2 = head(tail(restlist)).fields[0];
+                          } else {
+                            matchResult_2 = 2;
+                          }
+                        } else {
+                          matchResult_2 = 2;
+                        }
+                      } else {
+                        matchResult_2 = 2;
+                      }
+                    } else {
+                      matchResult_2 = 2;
+                    }
+                  }
+                } else {
+                  matchResult_2 = 2;
+                }
+                switch (matchResult_2) {
+                  case 0: {
+                    const sequenceElements_1 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_2)));
+                    handles_3_mut = handles_3;
+                    restlist_mut = toList(skipWhile(isSequenceElement, rest0_2));
+                    acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, singleton$1(PreprocessorElement_Line(v_3.Key)), empty())), delay(() => map$2((i_1) => loopRead(handles_3, i_1, empty()), sequenceElements_1)))))), acc);
+                    continue loopRead;
+                  }
+                  case 1: {
+                    const matchValue_4 = tryReadBlockScalar(value(v_4.Value), v_4.Indent, void 0, yamlAstList_2);
+                    if (matchValue_4 == null) {
+                      const arg = value(v_4.Value);
+                      return toFail(printf("Invalid sequence block scalar header: %s"))(arg);
+                    } else {
+                      const blockScalar = value(matchValue_4);
+                      const sequenceElements_2 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_3)));
+                      const rest_3 = toList(skipWhile(isSequenceElement, rest0_3));
+                      const firstItem = YAMLElement_Object(singleton$1(YAMLElement_Value(YAMLContent_create_Z1C3A29C9(blockScalar.Value, unwrap(blockScalar.Comment), unwrap(blockScalar.Props.Anchor), unwrap(blockScalar.Props.Tag), ScalarStyle_Block(blockScalar.Style, blockScalar.Chomp, blockScalar.Indent)))));
+                      handles_3_mut = handles_3;
+                      restlist_mut = rest_3;
+                      acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append(singleton(firstItem), delay(() => map$2((i_2) => loopRead(handles_3, i_2, empty()), sequenceElements_2)))))), acc);
+                      continue loopRead;
+                    }
+                  }
+                  default: {
+                    let matchResult_3, rest0_4, v_5, yamlAstList_3;
+                    if (!isEmpty(restlist)) {
+                      const activePatternResult_5 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                      if (activePatternResult_5 != null) {
+                        if (!isEmpty(tail(restlist))) {
+                          if (head(tail(restlist)).tag === /* Intendation */
+                          1) {
+                            matchResult_3 = 0;
+                            rest0_4 = tail(tail(restlist));
+                            v_5 = value(activePatternResult_5);
+                            yamlAstList_3 = head(tail(restlist)).fields[0];
+                          } else {
+                            matchResult_3 = 1;
+                          }
+                        } else {
+                          matchResult_3 = 1;
+                        }
+                      } else {
+                        matchResult_3 = 1;
+                      }
+                    } else {
+                      matchResult_3 = 1;
+                    }
+                    switch (matchResult_3) {
+                      case 0: {
+                        const objectList_1 = v_5.Value != null ? cons(PreprocessorElement_Line(value(v_5.Value)), yamlAstList_3) : yamlAstList_3;
+                        const sequenceElements_3 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_4)));
+                        handles_3_mut = handles_3;
+                        restlist_mut = toList(skipWhile(isSequenceElement, rest0_4));
+                        acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, objectList_1, empty())), delay(() => map$2((i_3) => loopRead(handles_3, i_3, empty()), sequenceElements_3)))))), acc);
+                        continue loopRead;
+                      }
+                      default: {
+                        let matchResult_4, rest0_5, v_6, rest_6, v_7, closer, iList, opener, rest_7;
+                        if (!isEmpty(restlist)) {
+                          const activePatternResult_6 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                          if (activePatternResult_6 != null) {
+                            matchResult_4 = 0;
+                            rest0_5 = tail(restlist);
+                            v_6 = value(activePatternResult_6);
+                          } else {
+                            const activePatternResult_7 = $007CInlineSequence$007C_$007C(head(restlist));
+                            if (activePatternResult_7 != null) {
+                              matchResult_4 = 1;
+                              rest_6 = tail(restlist);
+                              v_7 = value(activePatternResult_7);
+                            } else {
+                              const activePatternResult_8 = $007CSequenceSquareOpener$007C_$007C(head(restlist));
+                              if (activePatternResult_8 != null) {
+                                if (!isEmpty(tail(restlist))) {
+                                  if (head(tail(restlist)).tag === /* Intendation */
+                                  1) {
+                                    if (!isEmpty(tail(tail(restlist)))) {
+                                      const activePatternResult_9 = $007CSequenceSquareCloser$007C_$007C(head(tail(tail(restlist))));
+                                      if (activePatternResult_9 != null) {
+                                        matchResult_4 = 2;
+                                        closer = value(activePatternResult_9);
+                                        iList = head(tail(restlist)).fields[0];
+                                        opener = value(activePatternResult_8);
+                                        rest_7 = tail(tail(tail(restlist)));
+                                      } else {
+                                        matchResult_4 = 3;
+                                      }
+                                    } else {
+                                      matchResult_4 = 3;
+                                    }
+                                  } else {
+                                    matchResult_4 = 3;
+                                  }
+                                } else {
+                                  matchResult_4 = 3;
+                                }
+                              } else {
+                                matchResult_4 = 3;
+                              }
+                            }
+                          }
+                        } else {
+                          matchResult_4 = 3;
+                        }
+                        switch (matchResult_4) {
+                          case 0: {
+                            const sequenceElements_4 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_5)));
+                            const rest_5 = toList(skipWhile(isSequenceElement, rest0_5));
+                            const objectList_2 = v_6.Value != null ? singleton$1(PreprocessorElement_Line(value(v_6.Value))) : empty();
+                            handles_3_mut = handles_3;
+                            restlist_mut = rest_5;
+                            acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, objectList_2, empty())), delay(() => map$2((i_4) => loopRead(handles_3, i_4, empty()), sequenceElements_4)))))), acc);
+                            continue loopRead;
+                          }
+                          case 1: {
+                            const c = restoreCommentReplace(commentDict, v_7.Comment);
+                            const split$1 = split(v_7.Value, [","], void 0, 1);
+                            const current_6 = YAMLElement_Sequence(toList(delay(() => map$2((value_5) => loopRead(handles_3, singleton$1(PreprocessorElement_Line(value_5.trim())), empty()), split$1))));
+                            handles_3_mut = handles_3;
+                            restlist_mut = rest_6;
+                            acc_mut = c != null ? ofArrayWithTail([current_6, YAMLElement_Comment(value(c))], acc) : cons(current_6, acc);
+                            continue loopRead;
+                          }
+                          case 2: {
+                            const c1 = restoreCommentReplace(commentDict, opener.Comment);
+                            const c2 = restoreCommentReplace(commentDict, closer.Comment);
+                            const current_7 = YAMLElement_Sequence(toList(delay(() => collect$1((i_5) => singleton(loopRead(handles_3, singleton$1(i_5.tag === /* Line */
+                            2 ? PreprocessorElement_Line(trimEnd(i_5.fields[0], ",")) : toFail(printf("Unexpected element in MultiLineSquareBrackets: %A"))(i_5)), empty())), iList))));
+                            handles_3_mut = handles_3;
+                            restlist_mut = rest_7;
+                            acc_mut = c1 == null ? c2 == null ? cons(current_7, acc) : (c2_2 = value(c2), ofArrayWithTail([YAMLElement_Comment(c2_2), current_7], acc)) : c2 == null ? (c1_2 = value(c1), ofArrayWithTail([current_7, YAMLElement_Comment(c1_2)], acc)) : (c1_1 = value(c1), c2_1 = value(c2), ofArrayWithTail([YAMLElement_Comment(c2_1), current_7, YAMLElement_Comment(c1_1)], acc));
+                            continue loopRead;
+                          }
+                          default: {
+                            let matchResult_5, rest_9, v_9;
+                            if (!isEmpty(restlist)) {
+                              const activePatternResult_10 = $007CInlineJSON$007C_$007C(head(restlist));
+                              if (activePatternResult_10 != null) {
+                                if (v_8 = value(activePatternResult_10), v_8.Value.trim() === "") {
+                                  matchResult_5 = 0;
+                                  rest_9 = tail(restlist);
+                                  v_9 = value(activePatternResult_10);
+                                } else {
+                                  matchResult_5 = 1;
+                                }
+                              } else {
+                                matchResult_5 = 1;
+                              }
+                            } else {
+                              matchResult_5 = 1;
+                            }
+                            switch (matchResult_5) {
+                              case 0: {
+                                const c_1 = restoreCommentReplace(commentDict, v_9.Comment);
+                                const current_8 = empty();
+                                handles_3_mut = handles_3;
+                                restlist_mut = rest_9;
+                                acc_mut = c_1 != null ? append$1(current_8, cons(YAMLElement_Comment(value(c_1)), acc)) : append$1(current_8, acc);
+                                continue loopRead;
+                              }
+                              default: {
+                                let matchResult_6, opener_1;
+                                if (!isEmpty(restlist)) {
+                                  const activePatternResult_11 = $007CJSONKeyOpener$007C_$007C(head(restlist));
+                                  if (activePatternResult_11 != null) {
+                                    if (!isEmpty(tail(restlist))) {
+                                      if (head(tail(restlist)).tag === /* Intendation */
+                                      1) {
+                                        if (!isEmpty(tail(tail(restlist)))) {
+                                          if ($007CJSONCloser$007C_$007C(head(tail(tail(restlist)))) != null) {
+                                            matchResult_6 = 0;
+                                            opener_1 = value(activePatternResult_11);
+                                          } else {
+                                            matchResult_6 = 1;
+                                          }
+                                        } else {
+                                          matchResult_6 = 1;
+                                        }
+                                      } else {
+                                        matchResult_6 = 1;
+                                      }
+                                    } else {
+                                      matchResult_6 = 1;
+                                    }
+                                  } else {
+                                    matchResult_6 = 1;
+                                  }
+                                } else {
+                                  matchResult_6 = 1;
+                                }
+                                switch (matchResult_6) {
+                                  case 0:
+                                    return toFail(printf("Untransformed flow-style object detected. This is a bug in FlowToBlock transformation. Pattern: %A"))(opener_1);
+                                  default: {
+                                    let matchResult_7, v_11;
+                                    if (!isEmpty(restlist)) {
+                                      const activePatternResult_13 = $007CInlineJSON$007C_$007C(head(restlist));
+                                      if (activePatternResult_13 != null) {
+                                        if (v_10 = value(activePatternResult_13), v_10.Value.trim() !== "") {
+                                          matchResult_7 = 0;
+                                          v_11 = value(activePatternResult_13);
+                                        } else {
+                                          matchResult_7 = 1;
+                                        }
+                                      } else {
+                                        matchResult_7 = 1;
+                                      }
+                                    } else {
+                                      matchResult_7 = 1;
+                                    }
+                                    switch (matchResult_7) {
+                                      case 0:
+                                        return toFail(printf("Untransformed non-empty flow-style object detected: {%s}. This is a bug in FlowToBlock transformation."))(v_11.Value);
+                                      default: {
+                                        let matchResult_8, k, rest_10, rest_11, v_16, yamlAstList_4;
+                                        if (!isEmpty(restlist)) {
+                                          const activePatternResult_14 = $007CExplicitKey$007C_$007C(head(restlist));
+                                          if (activePatternResult_14 != null) {
+                                            matchResult_8 = 0;
+                                            k = value(activePatternResult_14);
+                                            rest_10 = tail(restlist);
+                                          } else {
+                                            const activePatternResult_15 = $007CKey$007C_$007C(head(restlist));
+                                            if (activePatternResult_15 != null) {
+                                              if (!isEmpty(tail(restlist))) {
+                                                if (head(tail(restlist)).tag === /* Intendation */
+                                                1) {
+                                                  matchResult_8 = 1;
+                                                  rest_11 = tail(tail(restlist));
+                                                  v_16 = value(activePatternResult_15);
+                                                  yamlAstList_4 = head(tail(restlist)).fields[0];
+                                                } else {
+                                                  matchResult_8 = 2;
+                                                }
+                                              } else {
+                                                matchResult_8 = 2;
+                                              }
+                                            } else {
+                                              matchResult_8 = 2;
+                                            }
+                                          }
+                                        } else {
+                                          matchResult_8 = 2;
+                                        }
+                                        switch (matchResult_8) {
+                                          case 0: {
+                                            const parseValue = (vStr) => {
+                                              let matchValue_6;
+                                              return loopRead(handles_3, transformElements(new TransformContext(0, ctx.IndentStep, ctx.StringDict), (matchValue_6 = read$1(vStr).AST, matchValue_6.tag === /* Level */
+                                              0 ? matchValue_6.fields[0] : empty())), empty());
+                                            };
+                                            let matchResult_9, iList_1, keyBody, tail$1, v_12;
+                                            if (!isEmpty(rest_10)) {
+                                              if (head(rest_10).tag === /* Intendation */
+                                              1) {
+                                                if (!isEmpty(tail(rest_10))) {
+                                                  const activePatternResult_16 = $007CExplicitValue$007C_$007C(head(tail(rest_10)));
+                                                  if (activePatternResult_16 != null) {
+                                                    if (!isEmpty(tail(tail(rest_10)))) {
+                                                      if (head(tail(tail(rest_10))).tag === /* Intendation */
+                                                      1) {
+                                                        matchResult_9 = 0;
+                                                        iList_1 = head(tail(tail(rest_10))).fields[0];
+                                                        keyBody = head(rest_10).fields[0];
+                                                        tail$1 = tail(tail(tail(rest_10)));
+                                                        v_12 = value(activePatternResult_16);
+                                                      } else {
+                                                        matchResult_9 = 1;
+                                                      }
+                                                    } else {
+                                                      matchResult_9 = 1;
+                                                    }
+                                                  } else {
+                                                    matchResult_9 = 1;
+                                                  }
+                                                } else {
+                                                  matchResult_9 = 1;
+                                                }
+                                              } else {
+                                                matchResult_9 = 1;
+                                              }
+                                            } else {
+                                              matchResult_9 = 1;
+                                            }
+                                            switch (matchResult_9) {
+                                              case 0: {
+                                                const simplifiedKey = join("\n", flattenBlockScalar(keyBody));
+                                                const kp = extractProperties(handles_3, k == null ? simplifiedKey : (s_3 = value(k), s_3 + (s_3 !== "" ? "\n" : "") + simplifiedKey));
+                                                const separator = (trimStart(v_12).startsWith("[") ? true : trimStart(v_12).startsWith("{")) ? " " : "\n";
+                                                const valueElement = parseValue(v_12 + separator + join(separator, flattenBlockScalar(iList_1)));
+                                                handles_3_mut = handles_3;
+                                                restlist_mut = tail$1;
+                                                acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(kp.Value, void 0, unwrap(kp.Anchor), unwrap(kp.Tag)), valueElement), acc);
+                                                continue loopRead;
+                                              }
+                                              default: {
+                                                let matchResult_10, keyBody_1, tail_1, v_13, iList_2, tail_2, v_14;
+                                                if (!isEmpty(rest_10)) {
+                                                  if (head(rest_10).tag === /* Intendation */
+                                                  1) {
+                                                    if (!isEmpty(tail(rest_10))) {
+                                                      const activePatternResult_17 = $007CExplicitValue$007C_$007C(head(tail(rest_10)));
+                                                      if (activePatternResult_17 != null) {
+                                                        matchResult_10 = 0;
+                                                        keyBody_1 = head(rest_10).fields[0];
+                                                        tail_1 = tail(tail(rest_10));
+                                                        v_13 = value(activePatternResult_17);
+                                                      } else if (head(tail(rest_10)).tag === /* Intendation */
+                                                      1) {
+                                                        const activePatternResult_18 = $007CExplicitValue$007C_$007C(head(rest_10));
+                                                        if (activePatternResult_18 != null) {
+                                                          matchResult_10 = 1;
+                                                          iList_2 = head(tail(rest_10)).fields[0];
+                                                          tail_2 = tail(tail(rest_10));
+                                                          v_14 = value(activePatternResult_18);
+                                                        } else {
+                                                          matchResult_10 = 2;
+                                                        }
+                                                      } else {
+                                                        matchResult_10 = 2;
+                                                      }
+                                                    } else {
+                                                      matchResult_10 = 2;
+                                                    }
+                                                  } else {
+                                                    const activePatternResult_19 = $007CExplicitValue$007C_$007C(head(rest_10));
+                                                    if (activePatternResult_19 != null) {
+                                                      if (!isEmpty(tail(rest_10))) {
+                                                        if (head(tail(rest_10)).tag === /* Intendation */
+                                                        1) {
+                                                          matchResult_10 = 1;
+                                                          iList_2 = head(tail(rest_10)).fields[0];
+                                                          tail_2 = tail(tail(rest_10));
+                                                          v_14 = value(activePatternResult_19);
+                                                        } else {
+                                                          matchResult_10 = 2;
+                                                        }
+                                                      } else {
+                                                        matchResult_10 = 2;
+                                                      }
+                                                    } else {
+                                                      matchResult_10 = 2;
+                                                    }
+                                                  }
+                                                } else {
+                                                  matchResult_10 = 2;
+                                                }
+                                                switch (matchResult_10) {
+                                                  case 0: {
+                                                    const simplifiedKey_1 = join("\n", flattenBlockScalar(keyBody_1));
+                                                    const kp_1 = extractProperties(handles_3, k == null ? simplifiedKey_1 : (s_4 = value(k), s_4 + (s_4 !== "" ? "\n" : "") + simplifiedKey_1));
+                                                    const valueElement_1 = parseValue(v_13);
+                                                    handles_3_mut = handles_3;
+                                                    restlist_mut = tail_1;
+                                                    acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(kp_1.Value, void 0, unwrap(kp_1.Anchor), unwrap(kp_1.Tag)), valueElement_1), acc);
+                                                    continue loopRead;
+                                                  }
+                                                  case 1: {
+                                                    const kp_2 = k == null ? {
+                                                      Value: ""
+                                                    } : extractProperties(handles_3, value(k));
+                                                    const valueElement_2 = parseValue(v_14 + "\n" + join("\n", flattenBlockScalar(iList_2)));
+                                                    handles_3_mut = handles_3;
+                                                    restlist_mut = tail_2;
+                                                    acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(kp_2.Value, void 0, unwrap(kp_2.Anchor), unwrap(kp_2.Tag)), valueElement_2), acc);
+                                                    continue loopRead;
+                                                  }
+                                                  default: {
+                                                    let matchResult_11, tail_3, v_15;
+                                                    if (!isEmpty(rest_10)) {
+                                                      const activePatternResult_20 = $007CExplicitValue$007C_$007C(head(rest_10));
+                                                      if (activePatternResult_20 != null) {
+                                                        matchResult_11 = 0;
+                                                        tail_3 = tail(rest_10);
+                                                        v_15 = value(activePatternResult_20);
+                                                      } else {
+                                                        matchResult_11 = 1;
+                                                      }
+                                                    } else {
+                                                      matchResult_11 = 1;
+                                                    }
+                                                    switch (matchResult_11) {
+                                                      case 0: {
+                                                        const kp_3 = k == null ? {
+                                                          Value: ""
+                                                        } : extractProperties(handles_3, value(k));
+                                                        const valueElement_3 = parseValue(v_15);
+                                                        handles_3_mut = handles_3;
+                                                        restlist_mut = tail_3;
+                                                        acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(kp_3.Value, void 0, unwrap(kp_3.Anchor), unwrap(kp_3.Tag)), valueElement_3), acc);
+                                                        continue loopRead;
+                                                      }
+                                                      default: {
+                                                        const kp_4 = k == null ? {
+                                                          Value: ""
+                                                        } : extractProperties(handles_3, value(k));
+                                                        handles_3_mut = handles_3;
+                                                        restlist_mut = rest_10;
+                                                        acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(kp_4.Value, void 0, unwrap(kp_4.Anchor), unwrap(kp_4.Tag)), YAMLElement_Nil()), acc);
+                                                        continue loopRead;
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                          case 1: {
+                                            const c_2 = restoreCommentReplace(commentDict, v_16.Comment);
+                                            const props_2 = extractProperties(handles_3, v_16.Key);
+                                            handles_3_mut = handles_3;
+                                            restlist_mut = rest_11;
+                                            acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(props_2.Value, unwrap(c_2), unwrap(props_2.Anchor), unwrap(props_2.Tag)), loopRead(handles_3, yamlAstList_4, empty())), acc);
+                                            continue loopRead;
+                                          }
+                                          default: {
+                                            let matchResult_12, rest0_6, v_17, w, yamlAstList_5;
+                                            if (!isEmpty(restlist)) {
+                                              const activePatternResult_21 = $007CKey$007C_$007C(head(restlist));
+                                              if (activePatternResult_21 != null) {
+                                                if (!isEmpty(tail(restlist))) {
+                                                  const activePatternResult_22 = $007CSequenceMinusOpener$007C_$007C(head(tail(restlist)));
+                                                  if (activePatternResult_22 != null) {
+                                                    if (!isEmpty(tail(tail(restlist)))) {
+                                                      if (head(tail(tail(restlist))).tag === /* Intendation */
+                                                      1) {
+                                                        matchResult_12 = 0;
+                                                        rest0_6 = tail(tail(tail(restlist)));
+                                                        v_17 = value(activePatternResult_21);
+                                                        w = value(activePatternResult_22);
+                                                        yamlAstList_5 = head(tail(tail(restlist))).fields[0];
+                                                      } else {
+                                                        matchResult_12 = 1;
+                                                      }
+                                                    } else {
+                                                      matchResult_12 = 1;
+                                                    }
+                                                  } else {
+                                                    matchResult_12 = 1;
+                                                  }
+                                                } else {
+                                                  matchResult_12 = 1;
+                                                }
+                                              } else {
+                                                matchResult_12 = 1;
+                                              }
+                                            } else {
+                                              matchResult_12 = 1;
+                                            }
+                                            switch (matchResult_12) {
+                                              case 0: {
+                                                const c_3 = restoreCommentReplace(commentDict, v_17.Comment);
+                                                const props_3 = extractProperties(handles_3, v_17.Key);
+                                                const objectList_3 = w.Value != null ? cons(PreprocessorElement_Line(value(w.Value)), yamlAstList_5) : yamlAstList_5;
+                                                const sequenceElements_5 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_6)));
+                                                const rest_12 = toList(skipWhile(isSequenceElement, rest0_6));
+                                                const seq = YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, objectList_3, empty())), delay(() => map$2((i_6) => loopRead(handles_3, i_6, empty()), sequenceElements_5))))));
+                                                handles_3_mut = handles_3;
+                                                restlist_mut = rest_12;
+                                                acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(props_3.Value, unwrap(c_3), unwrap(props_3.Anchor), unwrap(props_3.Tag)), YAMLElement_Object(singleton$1(seq))), acc);
+                                                continue loopRead;
+                                              }
+                                              default: {
+                                                let matchResult_13, rest0_7, v_18, w_1;
+                                                if (!isEmpty(restlist)) {
+                                                  const activePatternResult_23 = $007CKey$007C_$007C(head(restlist));
+                                                  if (activePatternResult_23 != null) {
+                                                    if (!isEmpty(tail(restlist))) {
+                                                      const activePatternResult_24 = $007CSequenceMinusOpener$007C_$007C(head(tail(restlist)));
+                                                      if (activePatternResult_24 != null) {
+                                                        matchResult_13 = 0;
+                                                        rest0_7 = tail(tail(restlist));
+                                                        v_18 = value(activePatternResult_23);
+                                                        w_1 = value(activePatternResult_24);
+                                                      } else {
+                                                        matchResult_13 = 1;
+                                                      }
+                                                    } else {
+                                                      matchResult_13 = 1;
+                                                    }
+                                                  } else {
+                                                    matchResult_13 = 1;
+                                                  }
+                                                } else {
+                                                  matchResult_13 = 1;
+                                                }
+                                                switch (matchResult_13) {
+                                                  case 0: {
+                                                    const c_4 = restoreCommentReplace(commentDict, v_18.Comment);
+                                                    const props_4 = extractProperties(handles_3, v_18.Key);
+                                                    const sequenceElements_6 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_7)));
+                                                    const rest_13 = toList(skipWhile(isSequenceElement, rest0_7));
+                                                    const seq_1 = YAMLElement_Sequence(toList(delay(() => append(singleton(loopRead(handles_3, singleton$1(PreprocessorElement_Line(value(w_1.Value))), empty())), delay(() => map$2((i_7) => loopRead(handles_3, i_7, empty()), sequenceElements_6))))));
+                                                    handles_3_mut = handles_3;
+                                                    restlist_mut = rest_13;
+                                                    acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(props_4.Value, unwrap(c_4), unwrap(props_4.Anchor), unwrap(props_4.Tag)), YAMLElement_Object(singleton$1(seq_1))), acc);
+                                                    continue loopRead;
+                                                  }
+                                                  default: {
+                                                    let matchResult_14, block_2, rest_15, v_20;
+                                                    if (!isEmpty(restlist)) {
+                                                      const activePatternResult_25 = $007CKeyValue$007C_$007C(head(restlist));
+                                                      if (activePatternResult_25 != null) {
+                                                        if (!isEmpty(tail(restlist))) {
+                                                          if (head(tail(restlist)).tag === /* Intendation */
+                                                          1) {
+                                                            if (block_1 = head(tail(restlist)).fields[0], isBlockScalarHeaderCandidate(value(activePatternResult_25).Value)) {
+                                                              matchResult_14 = 0;
+                                                              block_2 = head(tail(restlist)).fields[0];
+                                                              rest_15 = tail(tail(restlist));
+                                                              v_20 = value(activePatternResult_25);
+                                                            } else {
+                                                              matchResult_14 = 1;
+                                                            }
+                                                          } else {
+                                                            matchResult_14 = 1;
+                                                          }
+                                                        } else {
+                                                          matchResult_14 = 1;
+                                                        }
+                                                      } else {
+                                                        matchResult_14 = 1;
+                                                      }
+                                                    } else {
+                                                      matchResult_14 = 1;
+                                                    }
+                                                    switch (matchResult_14) {
+                                                      case 0: {
+                                                        const matchValue_7 = tryReadBlockScalar(v_20.Value, v_20.Indent, void 0, block_2);
+                                                        if (matchValue_7 == null) {
+                                                          return toFail(printf("Invalid block scalar header: %s"))(v_20.Value);
+                                                        } else {
+                                                          const blockScalar_1 = value(matchValue_7);
+                                                          const keyProps = extractProperties(handles_3, v_20.Key);
+                                                          handles_3_mut = handles_3;
+                                                          restlist_mut = rest_15;
+                                                          acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(keyProps.Value, void 0, unwrap(keyProps.Anchor), unwrap(keyProps.Tag)), YAMLElement_Value(YAMLContent_create_Z1C3A29C9(blockScalar_1.Value, unwrap(blockScalar_1.Comment), unwrap(blockScalar_1.Props.Anchor), unwrap(blockScalar_1.Props.Tag), ScalarStyle_Block(blockScalar_1.Style, blockScalar_1.Chomp, blockScalar_1.Indent)))), acc);
+                                                          continue loopRead;
+                                                        }
+                                                      }
+                                                      default: {
+                                                        let matchResult_15, rest_17, v_22, rest_18, v_23, block_4, rest_19, v_24;
+                                                        if (!isEmpty(restlist)) {
+                                                          const activePatternResult_26 = $007CKeyValue$007C_$007C(head(restlist));
+                                                          if (activePatternResult_26 != null) {
+                                                            matchResult_15 = 0;
+                                                            rest_17 = tail(restlist);
+                                                            v_22 = value(activePatternResult_26);
+                                                          } else {
+                                                            const activePatternResult_27 = $007CYamlComment$007C_$007C(head(restlist));
+                                                            if (activePatternResult_27 != null) {
+                                                              matchResult_15 = 1;
+                                                              rest_18 = tail(restlist);
+                                                              v_23 = value(activePatternResult_27);
+                                                            } else {
+                                                              const activePatternResult_28 = $007CYamlValue$007C_$007C(head(restlist));
+                                                              if (activePatternResult_28 != null) {
+                                                                if (!isEmpty(tail(restlist))) {
+                                                                  if (head(tail(restlist)).tag === /* Intendation */
+                                                                  1) {
+                                                                    if (block_3 = head(tail(restlist)).fields[0], isBlockScalarHeaderCandidate(value(activePatternResult_28).Value)) {
+                                                                      matchResult_15 = 2;
+                                                                      block_4 = head(tail(restlist)).fields[0];
+                                                                      rest_19 = tail(tail(restlist));
+                                                                      v_24 = value(activePatternResult_28);
+                                                                    } else {
+                                                                      matchResult_15 = 3;
+                                                                    }
+                                                                  } else {
+                                                                    matchResult_15 = 3;
+                                                                  }
+                                                                } else {
+                                                                  matchResult_15 = 3;
+                                                                }
+                                                              } else {
+                                                                matchResult_15 = 3;
+                                                              }
+                                                            }
+                                                          }
+                                                        } else {
+                                                          matchResult_15 = 3;
+                                                        }
+                                                        switch (matchResult_15) {
+                                                          case 0: {
+                                                            const props_5 = extractProperties(handles_3, v_22.Key);
+                                                            handles_3_mut = handles_3;
+                                                            restlist_mut = rest_17;
+                                                            acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_Z1C3A29C9(props_5.Value, void 0, unwrap(props_5.Anchor), unwrap(props_5.Tag)), loopRead(handles_3, singleton$1(PreprocessorElement_Line(v_22.Value)), empty())), acc);
+                                                            continue loopRead;
+                                                          }
+                                                          case 1: {
+                                                            handles_3_mut = handles_3;
+                                                            restlist_mut = rest_18;
+                                                            acc_mut = cons(YAMLElement_Comment(getItemFromDict(commentDict, v_23.Comment)), acc);
+                                                            continue loopRead;
+                                                          }
+                                                          case 2: {
+                                                            const matchValue_8 = tryReadBlockScalar(v_24.Value, v_24.Indent, v_24.Comment, block_4);
+                                                            if (matchValue_8 == null) {
+                                                              return toFail(printf("Invalid block scalar header: %s"))(v_24.Value);
+                                                            } else {
+                                                              const blockScalar_2 = value(matchValue_8);
+                                                              handles_3_mut = handles_3;
+                                                              restlist_mut = rest_19;
+                                                              acc_mut = cons(YAMLElement_Value(YAMLContent_create_Z1C3A29C9(blockScalar_2.Value, unwrap(blockScalar_2.Comment), unwrap(blockScalar_2.Props.Anchor), unwrap(blockScalar_2.Props.Tag), ScalarStyle_Block(blockScalar_2.Style, blockScalar_2.Chomp, blockScalar_2.Indent))), acc);
+                                                              continue loopRead;
+                                                            }
+                                                          }
+                                                          default: {
+                                                            let matchResult_16, rest_21, v_26;
+                                                            if (!isEmpty(restlist)) {
+                                                              const activePatternResult_29 = $007CYamlValue$007C_$007C(head(restlist));
+                                                              if (activePatternResult_29 != null) {
+                                                                if (v_25 = value(activePatternResult_29), v_25.Value === "" && v_25.Comment == null) {
+                                                                  matchResult_16 = 0;
+                                                                  rest_21 = tail(restlist);
+                                                                  v_26 = value(activePatternResult_29);
+                                                                } else {
+                                                                  matchResult_16 = 1;
+                                                                }
+                                                              } else {
+                                                                matchResult_16 = 1;
+                                                              }
+                                                            } else {
+                                                              matchResult_16 = 1;
+                                                            }
+                                                            switch (matchResult_16) {
+                                                              case 0: {
+                                                                handles_3_mut = handles_3;
+                                                                restlist_mut = rest_21;
+                                                                acc_mut = acc;
+                                                                continue loopRead;
+                                                              }
+                                                              default:
+                                                                if (isEmpty(restlist)) {
+                                                                  return YAMLElement_Object(reverse(acc));
+                                                                } else {
+                                                                  const activePatternResult_30 = $007CYamlValue$007C_$007C(head(restlist));
+                                                                  if (activePatternResult_30 != null) {
+                                                                    const v_27 = value(activePatternResult_30);
+                                                                    const c_6 = restoreCommentReplace(commentDict, v_27.Comment);
+                                                                    const props_6 = extractProperties(handles_3, v_27.Value);
+                                                                    let patternInput_2;
+                                                                    const raw = props_6.Value;
+                                                                    const matchValue = tryParseExactPlaceholderIndex(raw);
+                                                                    if (matchValue == null) {
+                                                                      patternInput_2 = [restoreStringReplace(stringDict, raw), void 0];
+                                                                    } else {
+                                                                      const entry = getItemFromDict(stringDict, value(matchValue));
+                                                                      patternInput_2 = [restoreScalarPlaceholderValue(entry), entry.Kind.tag === /* DoubleQuotedString */
+                                                                      1 ? ScalarStyle_DoubleQuoted() : ScalarStyle_SingleQuoted()];
+                                                                    }
+                                                                    handles_3_mut = handles_3;
+                                                                    restlist_mut = tail(restlist);
+                                                                    acc_mut = cons(YAMLElement_Value(YAMLContent_create_Z1C3A29C9(patternInput_2[0], unwrap(c_6), unwrap(props_6.Anchor), unwrap(props_6.Tag), unwrap(patternInput_2[1]))), acc);
+                                                                    continue loopRead;
+                                                                  } else {
+                                                                    return toFail(printf("Unknown pattern: %A"))(restlist);
+                                                                  }
+                                                                }
+                                                            }
+                                                          }
+                                                        }
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+  };
+  return loopRead(handles, transformElements(ctx, yamlList), empty());
+}
+function read(yaml) {
+  const ast = read$1(yaml);
+  const matchValue = ast.AST;
+  if (matchValue.tag === /* Level */
+  0) {
+    return tokenize(matchValue.fields[0], ast.StringMap, ast.CommentMap, ast.TagHandles);
+  } else {
+    throw new Error("Not a root!");
+  }
+}
+function isStreamDocumentMarker(markerCheck, line) {
+  if (countLeadingSpaces(line) === 0) {
+    return markerCheck(line);
+  } else {
+    return false;
+  }
+}
+function tryInlineContentAfterStartMarker(line) {
+  const trimmed = trimStart(line);
+  if (!trimmed.startsWith("---")) {
+    return void 0;
+  } else {
+    const rest = trimStart(substring(trimmed, 3));
+    if (isNullOrWhiteSpace(rest) ? true : rest.startsWith("#")) {
+      return void 0;
+    } else {
+      return rest;
+    }
+  }
+}
+function isDirectivePreludeLine(line) {
+  const t = trimStart(line);
+  if (t === "" ? true : t.startsWith("%")) {
+    return true;
+  } else {
+    return t.startsWith("#");
+  }
+}
+function isDirectivePreludeOnly(lines) {
+  if (exists((line) => trimStart(line).startsWith("%"), lines)) {
+    return forAll(isDirectivePreludeLine, lines);
+  } else {
+    return false;
+  }
+}
+function tryDetectBlockScalarHeaderIndent(line) {
+  let loop, idx_3;
+  const trimmed = trimStart(line);
+  const afterDash = trimmed.startsWith("- ") ? trimStart(substring(trimmed, 2)) : trimmed;
+  const headerToken = tryHead(split((loop = (current_mut) => {
+    loop:
+      while (true) {
+        const current = current_mut;
+        const c = trimStart(current);
+        if (c.startsWith("&")) {
+          const idx = c.indexOf(" ") | 0;
+          if (idx < 0) {
+            return "";
+          } else {
+            current_mut = substring(c, idx + 1);
+            continue loop;
+          }
+        } else if (c.startsWith("!<")) {
+          const idx_1 = c.indexOf(">") | 0;
+          if (idx_1 < 0) {
+            return c;
+          } else {
+            current_mut = substring(c, idx_1 + 1);
+            continue loop;
+          }
+        } else if (c.startsWith("!") && !c.startsWith("|") && !c.startsWith(">")) {
+          const idx_2 = c.indexOf(" ") | 0;
+          if (idx_2 < 0) {
+            return "";
+          } else {
+            current_mut = substring(c, idx_2 + 1);
+            continue loop;
+          }
+        } else {
+          return c;
+        }
+        break;
+      }
+  }, loop((idx_3 = afterDash.indexOf(":") | 0, idx_3 >= 0 ? trimStart(substring(afterDash, idx_3 + 1)) : afterDash))), [" ", "	"], void 0, 1));
+  let matchResult, token_1;
+  if (headerToken != null) {
+    if (parseBlockScalarHeader(value(headerToken)) != null) {
+      matchResult = 0;
+      token_1 = value(headerToken);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return countLeadingSpaces(line);
+    default:
+      return void 0;
+  }
+}
+function readDocuments(yaml) {
+  const appendCurrentDocument = (currentDoc, docs) => {
+    if (isEmpty(currentDoc)) {
+      return docs;
+    } else {
+      return cons(reverse(currentDoc), docs);
+    }
+  };
+  const splitDocuments = (remaining_mut, currentDoc_1_mut, docs_1_mut, blockHeaderIndent_mut) => {
+    let matchValue;
+    splitDocuments:
+      while (true) {
+        const remaining = remaining_mut, currentDoc_1 = currentDoc_1_mut, docs_1 = docs_1_mut, blockHeaderIndent = blockHeaderIndent_mut;
+        if (!isEmpty(remaining)) {
+          const rest = tail(remaining);
+          const line = head(remaining);
+          if (blockHeaderIndent == null) {
+            if (isStreamDocumentMarker(isDocumentStart, line)) {
+              const inlineContent = tryInlineContentAfterStartMarker(line);
+              if (isEmpty(currentDoc_1) ? true : isDirectivePreludeOnly(currentDoc_1)) {
+                const preludeDirectives = filter((l) => trimStart(l).startsWith("%"), currentDoc_1);
+                remaining_mut = rest;
+                currentDoc_1_mut = inlineContent == null ? preludeDirectives : cons(value(inlineContent), preludeDirectives);
+                docs_1_mut = docs_1;
+                blockHeaderIndent_mut = void 0;
+                continue splitDocuments;
+              } else {
+                const docs$0027 = appendCurrentDocument(currentDoc_1, docs_1);
+                remaining_mut = rest;
+                currentDoc_1_mut = inlineContent == null ? empty() : singleton$1(value(inlineContent));
+                docs_1_mut = docs$0027;
+                blockHeaderIndent_mut = void 0;
+                continue splitDocuments;
+              }
+            } else if (isStreamDocumentMarker(isDocumentEnd, line)) {
+              remaining_mut = rest;
+              currentDoc_1_mut = empty();
+              docs_1_mut = appendCurrentDocument(currentDoc_1, docs_1);
+              blockHeaderIndent_mut = void 0;
+              continue splitDocuments;
+            } else {
+              remaining_mut = rest;
+              currentDoc_1_mut = cons(line, currentDoc_1);
+              docs_1_mut = docs_1;
+              blockHeaderIndent_mut = (matchValue = tryDetectBlockScalarHeaderIndent(line), matchValue == null ? void 0 : value(matchValue));
+              continue splitDocuments;
+            }
+          } else {
+            const headerIndent = value(blockHeaderIndent) | 0;
+            if (line.trim() === "" ? true : countLeadingSpaces(line) > headerIndent) {
+              remaining_mut = rest;
+              currentDoc_1_mut = cons(line, currentDoc_1);
+              docs_1_mut = docs_1;
+              blockHeaderIndent_mut = blockHeaderIndent;
+              continue splitDocuments;
+            } else {
+              remaining_mut = remaining;
+              currentDoc_1_mut = currentDoc_1;
+              docs_1_mut = docs_1;
+              blockHeaderIndent_mut = void 0;
+              continue splitDocuments;
+            }
+          }
+        } else {
+          return reverse(appendCurrentDocument(currentDoc_1, docs_1));
+        }
+        break;
+      }
+  };
+  return map((docLines) => read(join("\n", docLines)), filter((doc) => exists((l_1) => l_1.trim() !== "", doc), splitDocuments(ofArray(split(replace$1(replace$1(yaml, "\r\n", "\n"), "\r", "\n"), ["\n"], void 0, 0)), empty(), empty(), void 0)));
+}
+
+export { collectSequenceElements, isSequenceElement, read, readDocuments };