@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.1

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

@@ -0,0 +1,10 @@
+function isInt(s) {
+  if (typeof s != "string") return false;
+  return !isNaN(parseFloat(s)) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+  !isNaN(parseFloat(s));
+}
+function isString(s) {
+  return typeof s === "string" || s instanceof String;
+}
+
+export { isInt, isString };

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

@@ -0,0 +1,562 @@
+import { max, length, takeWhile, toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { comparePrimitives, getEnumerator, disposeSafe, equals } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { QuotedStringKind_SingleQuotedString, StringMapEntry, QuotedStringKind_DoubleQuotedString, YAMLDirective } from './YAMLiciousTypes.fs.js';
+import { StringBuffer_$ctor, StringBuffer__Append_244C7CD6, StringBuffer__get_Length, StringBuffer__get_Item_Z524259A4, StringBuffer__Append_Z721C83C5 } from './StringBuffer.fs.js';
+import { item, tryHead, tryFind, takeWhile as takeWhile$1, take, append } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { trimStart, trimEnd, replace, substring, toText, printf, isNullOrWhiteSpace, split } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FSharpSet__Contains, ofList, empty } from '../../../node_modules/@fable-org/fable-library-js/Set.js';
+import { value, defaultArg, map, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { replace as replace$1, match } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { ofArray, isEmpty, head, tail, toArray, reverse } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { isWhiteSpace } from '../../../node_modules/@fable-org/fable-library-js/Char.js';
+import { add, empty as empty$1 } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+
+function nextStringIndex(dict) {
+  if (dict.size === 0) {
+    return 0;
+  } else {
+    return max(dict.keys(), {
+      Compare: comparePrimitives
+    }) + 1 | 0;
+  }
+}
+function foldSingleQuoted(s) {
+  const lines = s.split("\n");
+  const sb = StringBuffer_$ctor();
+  for (let i = 0; i <= lines.length - 1; i++) {
+    let line = item(i, lines);
+    if (i > 0) {
+      line = trimStart(line);
+    }
+    if (i < lines.length - 1) {
+      line = trimEnd(line);
+    }
+    if (line.length === 0) {
+      StringBuffer__Append_244C7CD6(sb, "\n");
+    } else {
+      if (StringBuffer__get_Length(sb) > 0 && StringBuffer__get_Item_Z524259A4(sb, StringBuffer__get_Length(sb) - 1) !== "\n") {
+        StringBuffer__Append_Z721C83C5(sb, " ");
+      }
+      StringBuffer__Append_Z721C83C5(sb, line);
+    }
+  }
+  return replace(toString(sb), "''", "'");
+}
+function parseSingleQuotedSegment(s, startIndex) {
+  const content = StringBuffer_$ctor();
+  let i = startIndex + 1;
+  let closed = false;
+  while (i < s.length && !closed) {
+    const ch = s[i];
+    if (ch === "'") {
+      if (i + 1 < s.length && s[i + 1] === "'") {
+        StringBuffer__Append_Z721C83C5(content, "''");
+        i = i + 2 | 0;
+      } else {
+        closed = true;
+        i = i + 1 | 0;
+      }
+    } else {
+      StringBuffer__Append_244C7CD6(content, ch);
+      i = i + 1 | 0;
+    }
+  }
+  return [closed, toString(content), i];
+}
+function parseDoubleQuotedSegment(s, startIndex) {
+  const content = StringBuffer_$ctor();
+  let i = startIndex + 1;
+  let closed = false;
+  let escaped = false;
+  while (i < s.length && !closed) {
+    const ch = s[i];
+    if (escaped) {
+      StringBuffer__Append_244C7CD6(content, ch);
+      escaped = false;
+      i = i + 1 | 0;
+    } else {
+      switch (ch) {
+        case '"': {
+          closed = true;
+          i = i + 1 | 0;
+          break;
+        }
+        case "\\": {
+          StringBuffer__Append_244C7CD6(content, ch);
+          escaped = true;
+          i = i + 1 | 0;
+          break;
+        }
+        default: {
+          StringBuffer__Append_244C7CD6(content, ch);
+          i = i + 1 | 0;
+        }
+      }
+    }
+  }
+  return [closed, toString(content), i];
+}
+function isTokenBoundaryStart(s, quoteIndex) {
+  let c, c_1;
+  let i = quoteIndex - 1;
+  while (i >= 0 && (c = s[i], c === " " ? true : c === "	")) {
+    i = i - 1 | 0;
+  }
+  if (i < 0) {
+    return true;
+  } else {
+    const matchValue = s[i];
+    switch (matchValue) {
+      case "\n":
+      case "\r":
+      case ",":
+      case "-":
+      case ":":
+      case "?":
+      case "[":
+      case "{":
+        return true;
+      default: {
+        let start = i;
+        while (start >= 0 && !(c_1 = s[start], ((((((((c_1 === " " ? true : c_1 === "	") ? true : c_1 === "\n") ? true : c_1 === "\r") ? true : c_1 === ":") ? true : c_1 === "-") ? true : c_1 === ",") ? true : c_1 === "[") ? true : c_1 === "{") ? true : c_1 === "?")) {
+          start = start - 1 | 0;
+        }
+        const token = substring(s, start + 1, i - start);
+        if (token.startsWith("!")) {
+          return true;
+        } else {
+          return token.startsWith("&");
+        }
+      }
+    }
+  }
+}
+function isTokenBoundaryEnd(s, nextIndex) {
+  let c;
+  let i = nextIndex;
+  while (i < s.length && (c = s[i], c === " " ? true : c === "	")) {
+    i = i + 1 | 0;
+  }
+  if (i >= s.length) {
+    return true;
+  } else {
+    const matchValue = s[i];
+    switch (matchValue) {
+      case "\n":
+      case "\r":
+      case "#":
+      case ",":
+      case ":":
+      case "]":
+      case "}":
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+function replaceQuotedStrings(target, dict, protectedBlockScalarLines, s) {
+  const sb = StringBuffer_$ctor();
+  let i = 0;
+  let n = nextStringIndex(dict);
+  let inComment = false;
+  const length = s.length | 0;
+  let lineIndex = 0;
+  const appendPlaceholder = (entry) => {
+    const currentN = n | 0;
+    n = n + 1 | 0;
+    addToDict(dict, currentN, entry);
+    StringBuffer__Append_Z721C83C5(sb, toText(printf("<s f=%i/>"))(currentN));
+  };
+  const appendChar = (c) => {
+    StringBuffer__Append_244C7CD6(sb, c);
+    if (c === "\n") {
+      lineIndex = lineIndex + 1 | 0;
+    }
+  };
+  const appendText = (text) => {
+    const enumerator = getEnumerator(text.split(""));
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        appendChar(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  };
+  const advanceLineIndex = (startIndex, endIndex) => {
+    for (let j = startIndex; j <= endIndex - 1; j++) {
+      if (s[j] === "\n") {
+        lineIndex = lineIndex + 1 | 0;
+      }
+    }
+  };
+  while (i < length) {
+    const c_2 = s[i];
+    if (FSharpSet__Contains(protectedBlockScalarLines, lineIndex)) {
+      appendChar(c_2);
+      i = i + 1 | 0;
+      if (c_2 === "\n") {
+        inComment = false;
+      }
+    } else if (inComment) {
+      appendChar(c_2);
+      i = i + 1 | 0;
+      if (c_2 === "\n") {
+        inComment = false;
+      }
+    } else {
+      switch (c_2) {
+        case '"': {
+          if (equals(target, QuotedStringKind_DoubleQuotedString())) {
+            if (isTokenBoundaryStart(s, i)) {
+              const patternInput_2 = parseDoubleQuotedSegment(s, i);
+              const nextIndex_2 = patternInput_2[2] | 0;
+              if (patternInput_2[0] && isTokenBoundaryEnd(s, nextIndex_2)) {
+                appendPlaceholder(new StringMapEntry(patternInput_2[1], QuotedStringKind_DoubleQuotedString()));
+                advanceLineIndex(i, nextIndex_2);
+              } else {
+                appendText(substring(s, i, nextIndex_2 - i));
+              }
+              i = nextIndex_2 | 0;
+            } else {
+              appendChar(c_2);
+              i = i + 1 | 0;
+            }
+          } else {
+            const nextIndex_3 = parseDoubleQuotedSegment(s, i)[2] | 0;
+            appendText(substring(s, i, nextIndex_3 - i));
+            i = nextIndex_3 | 0;
+          }
+          break;
+        }
+        case "#": {
+          inComment = true;
+          appendChar(c_2);
+          i = i + 1 | 0;
+          break;
+        }
+        case "'": {
+          if (equals(target, QuotedStringKind_SingleQuotedString())) {
+            if (isTokenBoundaryStart(s, i)) {
+              const patternInput = parseSingleQuotedSegment(s, i);
+              const nextIndex = patternInput[2] | 0;
+              if (patternInput[0] && isTokenBoundaryEnd(s, nextIndex)) {
+                appendPlaceholder(new StringMapEntry(foldSingleQuoted(patternInput[1]), QuotedStringKind_SingleQuotedString()));
+                advanceLineIndex(i, nextIndex);
+              } else {
+                appendText(substring(s, i, nextIndex - i));
+              }
+              i = nextIndex | 0;
+            } else {
+              appendChar(c_2);
+              i = i + 1 | 0;
+            }
+          } else {
+            const nextIndex_1 = parseSingleQuotedSegment(s, i)[2] | 0;
+            appendText(substring(s, i, nextIndex_1 - i));
+            i = nextIndex_1 | 0;
+          }
+          break;
+        }
+        default: {
+          appendChar(c_2);
+          i = i + 1 | 0;
+        }
+      }
+    }
+  }
+  return toString(sb);
+}
+function encodingCleanUp(s) {
+  return replace(s, "\r\n", "\n");
+}
+function countLeadingSpaces(line) {
+  return length(takeWhile((c) => c === " ", line.split("")));
+}
+function parseBlockScalarHeaderToken(token) {
+  let c;
+  if (isNullOrWhiteSpace(token)) {
+    return false;
+  } else {
+    const t = token.trim();
+    if (t.length === 0) {
+      return false;
+    } else {
+      const first = t[0];
+      if (first !== "|" && first !== ">") {
+        return false;
+      } else {
+        let valid = true;
+        let seenIndent = false;
+        let seenChomp = false;
+        let idx = 1;
+        while (idx < t.length && valid) {
+          const matchValue = t[idx];
+          let matchResult;
+          if (c = matchValue, c >= "1" && c <= "9") {
+            matchResult = 0;
+          } else {
+            switch (matchValue) {
+              case "+":
+              case "-": {
+                matchResult = 1;
+                break;
+              }
+              default:
+                matchResult = 2;
+            }
+          }
+          switch (matchResult) {
+            case 0: {
+              if (seenIndent) {
+                valid = false;
+              } else {
+                seenIndent = true;
+              }
+              break;
+            }
+            case 1: {
+              if (seenChomp) {
+                valid = false;
+              } else {
+                seenChomp = true;
+              }
+              break;
+            }
+            case 2: {
+              valid = false;
+              break;
+            }
+          }
+          idx = idx + 1 | 0;
+        }
+        return valid;
+      }
+    }
+  }
+}
+function tryDetectBlockScalarHeaderIndent(line) {
+  let loop, idx_3;
+  const trimmed = trimStart(line);
+  const afterDash = trimmed.startsWith("- ") ? trimStart(substring(trimmed, 2)) : trimmed;
+  const token = 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, t_1;
+  if (token != null) {
+    if (parseBlockScalarHeaderToken(value(token))) {
+      matchResult = 0;
+      t_1 = value(token);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return countLeadingSpaces(line);
+    default:
+      return void 0;
+  }
+}
+function detectBlockScalarContentLines(yamlString) {
+  const lines = split(replace(replace(yamlString, "\r\n", "\n"), "\r", "\n"), ["\n"], void 0, 0);
+  const protectedLines = [];
+  let i = 0;
+  let openBlockIndent = void 0;
+  while (i < lines.length) {
+    if (openBlockIndent == null) {
+      const matchValue = tryDetectBlockScalarHeaderIndent(item(i, lines));
+      if (matchValue == null) {
+        i = i + 1 | 0;
+      } else {
+        const indent = value(matchValue) | 0;
+        openBlockIndent = indent;
+        i = i + 1 | 0;
+      }
+    } else {
+      const headerIndent = value(openBlockIndent) | 0;
+      const line = item(i, lines);
+      if (line.trim() === "" ? true : countLeadingSpaces(line) > headerIndent) {
+        const value = void protectedLines.push(i);
+        i = i + 1 | 0;
+      } else {
+        openBlockIndent = void 0;
+      }
+    }
+  }
+  return ofList(toList(protectedLines), {
+    Compare: comparePrimitives
+  });
+}
+function stringCleanUpWithProtected(dict, protectedBlockScalarLines, s) {
+  return replaceQuotedStrings(QuotedStringKind_DoubleQuotedString(), dict, protectedBlockScalarLines, s);
+}
+function singleQuotedStringCleanUpWithProtected(dict, protectedBlockScalarLines, s) {
+  return replaceQuotedStrings(QuotedStringKind_SingleQuotedString(), dict, protectedBlockScalarLines, s);
+}
+function stringCleanUp(dict, s) {
+  return stringCleanUpWithProtected(dict, empty({
+    Compare: comparePrimitives
+  }), s);
+}
+function singleQuotedStringCleanUp(dict, s) {
+  return singleQuotedStringCleanUpWithProtected(dict, empty({
+    Compare: comparePrimitives
+  }), s);
+}
+function commentCleanUp(dict, s) {
+  let n = 0;
+  return replace$1(/#(?<comment>.*)/gu, s, (m) => {
+    const v = m.groups && m.groups.comment || "";
+    const currentN = n | 0;
+    n = n + 1 | 0;
+    addToDict(dict, currentN, v);
+    return toText(printf("<c f=%i/>"))(currentN);
+  });
+}
+function cut(yamlString) {
+  let matchValue;
+  const lines = ofArray(split(yamlString, ["\n"], void 0, 0));
+  const withoutLeading = !isEmpty(lines) ? head(lines) === "" ? tail(lines) : lines : lines;
+  return toArray((matchValue = reverse(withoutLeading), !isEmpty(matchValue) ? head(matchValue) === "" ? reverse(tail(matchValue)) : withoutLeading : withoutLeading));
+}
+function parseYAMLDirective(line) {
+  const m = match(/^%YAML\s+(\d+)\.(\d+)/gu, line.trim());
+  if (m != null) {
+    return new YAMLDirective(parse(m[1] || "", 511, false, 32), parse(m[2] || "", 511, false, 32));
+  } else {
+    return void 0;
+  }
+}
+function parseTagDirective(line) {
+  const m = match(/^%TAG\s+(\S+)\s+(\S+)/gu, line.trim());
+  if (m != null) {
+    return [m[1] || "", m[2] || ""];
+  } else {
+    return void 0;
+  }
+}
+function isDocumentMarker(marker, line) {
+  const trimmed = trimStart(line);
+  if (!trimmed.startsWith(marker)) {
+    return false;
+  } else if (trimmed.length === marker.length) {
+    return true;
+  } else {
+    return isWhiteSpace(trimmed[marker.length]);
+  }
+}
+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 pipeline(yamlString) {
+  let matchValue_2;
+  const stringMap = /* @__PURE__ */ new Map([]);
+  const commentMap = /* @__PURE__ */ new Map([]);
+  const normalizedContent = encodingCleanUp(yamlString);
+  const protectedBlockScalarLines = detectBlockScalarContentLines(normalizedContent);
+  const lines = cut(commentCleanUp(commentMap, stringCleanUpWithProtected(stringMap, protectedBlockScalarLines, singleQuotedStringCleanUpWithProtected(stringMap, protectedBlockScalarLines, normalizedContent))));
+  let directivePreludeLength;
+  if (defaultArg(map((line) => trimStart(line).startsWith("%"), tryFind((l) => {
+    const t = l.trim();
+    if (t !== "") {
+      return !t.startsWith("#");
+    } else {
+      return false;
+    }
+  }, lines)), false)) {
+    const array_2 = takeWhile$1((l_1) => {
+      const t_1 = trimStart(l_1);
+      if (t_1.startsWith("%") ? true : t_1.startsWith("#")) {
+        return true;
+      } else {
+        return t_1.trim() === "";
+      }
+    }, lines);
+    directivePreludeLength = array_2.length;
+  } else {
+    directivePreludeLength = 0;
+  }
+  const directiveLines = take(directivePreludeLength, lines);
+  const contentLines = lines.slice(directivePreludeLength, lines.length);
+  let yamlVersion = void 0;
+  let tagHandles = add("!!", "tag:yaml.org,2002:", add("!", "!", empty$1({
+    Compare: comparePrimitives
+  })));
+  for (let idx = 0; idx <= directiveLines.length - 1; idx++) {
+    const line_1 = item(idx, directiveLines);
+    const matchValue = parseYAMLDirective(line_1);
+    if (matchValue == null) {
+      const matchValue_1 = parseTagDirective(line_1);
+      if (matchValue_1 == null) {
+      } else {
+        const t_2 = value(matchValue_1)[1];
+        const h = value(matchValue_1)[0];
+        tagHandles = add(h, t_2, tagHandles);
+      }
+    } else {
+      const v = value(matchValue);
+      if (yamlVersion != null) {
+        throw new Error("Duplicate YAML directive");
+      }
+      yamlVersion = v;
+    }
+  }
+  return {
+    CommentMap: commentMap,
+    Lines: contentLines.length > 0 && isDocumentMarker("---", item(0, contentLines)) ? (matchValue_2 = tryInlineContentAfterStartMarker(item(0, contentLines)), matchValue_2 == null ? contentLines.slice(1, contentLines.length) : append([value(matchValue_2)], contentLines.slice(1, contentLines.length))) : contentLines,
+    StringMap: stringMap,
+    TagHandles: tagHandles,
+    YAMLVersion: unwrap(yamlVersion)
+  };
+}
+
+export { commentCleanUp, cut, encodingCleanUp, parseTagDirective, parseYAMLDirective, pipeline, singleQuotedStringCleanUp, stringCleanUp };

package/dist/ts/ts/fable_modules/{YAMLicious.0.0.3 → YAMLicious.1.0.0-alpha.4}/Preprocessing.fs.js

@@ -1,7 +1,9 @@
 import { length, takeWhile } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { trimStart, substring } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { isWhiteSpace } from '../../../node_modules/@fable-org/fable-library-js/Char.js';
 import { Config_init_71136F3F, Config__get_WhitespaceString, Config, PreprocessorElement_Line, PreprocessorElement_Intendation, Preprocessor, PreprocessorElement_Level } from './YAMLiciousTypes.fs.js';
 import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { StringBuilder_$ctor, StringBuilder__AppendLine_Z721C83C5 } from '../../../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { StringBuffer_$ctor, StringBuffer__AppendLine_Z721C83C5 } from './StringBuffer.fs.js';
 import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
 import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
 import { pipeline } from './Persil.fs.js';
@@ -10,11 +12,27 @@ import { isEmpty, tail, head, cons, takeWhile as takeWhile$1, skipWhile, reverse
 function ReadHelpers_indentLevel(line) {
   return length(takeWhile((c) => c === " ", line.split("")));
 }
+function isDocumentMarker(marker, line) {
+  const trimmed = trimStart(line);
+  if (!trimmed.startsWith(marker)) {
+    return false;
+  } else if (trimmed.length === marker.length) {
+    return true;
+  } else {
+    return isWhiteSpace(trimmed[marker.length]);
+  }
+}
+function isDocumentStart(line) {
+  return isDocumentMarker("---", line);
+}
+function isDocumentEnd(line) {
+  return isDocumentMarker("...", line);
+}
 function write(rootElement, fconfig) {
   let config_1;
   const config = Config_init_71136F3F();
   config_1 = fconfig != null ? value(fconfig)(config) : config;
-  const sb = StringBuilder_$ctor();
+  const sb = StringBuffer_$ctor();
   const loop = (current, sb_1, config_2) => {
     switch (current.tag) {
       case /* Intendation */
@@ -48,7 +66,7 @@ function write(rootElement, fconfig) {
       }
       default: {
         const line = current.fields[0];
-        StringBuilder__AppendLine_Z721C83C5(sb_1, Config__get_WhitespaceString(config_2) + line);
+        StringBuffer__AppendLine_Z721C83C5(sb_1, Config__get_WhitespaceString(config_2) + line);
       }
     }
   };
@@ -57,25 +75,47 @@ function write(rootElement, fconfig) {
 }
 function read(yamlStr) {
   const content = pipeline(yamlStr);
+  const stripIndent = (indent, line) => {
+    if (indent <= 0) {
+      return line;
+    } else if (line.length >= indent) {
+      return substring(line, indent);
+    } else {
+      return trimStart(line);
+    }
+  };
   const loop = (lines_mut, currentIntendation_mut, acc_mut) => {
     loop:
       while (true) {
         const lines = lines_mut, currentIntendation = currentIntendation_mut, acc = acc_mut;
         if (!isEmpty(lines)) {
           const rest = tail(lines);
-          const line = head(lines);
-          const lineEle = PreprocessorElement_Line(line.trim());
-          const nextIntendation = ReadHelpers_indentLevel(line) | 0;
+          const line_1 = head(lines);
+          const isEmptyLine = line_1.trim() === "";
+          const nextIntendation = (isEmptyLine ? currentIntendation : ReadHelpers_indentLevel(line_1)) | 0;
           if (nextIntendation === currentIntendation) {
             lines_mut = rest;
             currentIntendation_mut = currentIntendation;
-            acc_mut = cons(PreprocessorElement_Line(line.trim()), acc);
+            acc_mut = cons(PreprocessorElement_Line(isEmptyLine ? "" : stripIndent(currentIntendation, line_1)), acc);
             continue loop;
           } else {
-            const nextLevelLines = takeWhile$1((l) => ReadHelpers_indentLevel(l) > currentIntendation, rest);
-            lines_mut = skipWhile((l_1) => ReadHelpers_indentLevel(l_1) > currentIntendation, rest);
+            const lineText_1 = isEmptyLine ? "" : stripIndent(nextIntendation, line_1);
+            const nextLevelLines = takeWhile$1((l) => {
+              if (l.trim() === "") {
+                return true;
+              } else {
+                return ReadHelpers_indentLevel(l) > currentIntendation;
+              }
+            }, rest);
+            lines_mut = skipWhile((l_1) => {
+              if (l_1.trim() === "") {
+                return true;
+              } else {
+                return ReadHelpers_indentLevel(l_1) > currentIntendation;
+              }
+            }, rest);
             currentIntendation_mut = currentIntendation;
-            acc_mut = cons(PreprocessorElement_Intendation(cons(lineEle, reverse(loop(nextLevelLines, nextIntendation, empty())))), acc);
+            acc_mut = cons(PreprocessorElement_Intendation(cons(PreprocessorElement_Line(lineText_1), reverse(loop(nextLevelLines, nextIntendation, empty())))), acc);
             continue loop;
           }
         } else {
@@ -84,7 +124,7 @@ function read(yamlStr) {
         break;
       }
   };
-  return new Preprocessor(PreprocessorElement_Level(reverse(loop(ofArray(content.Lines), 0, empty()))), content.StringMap, content.CommentMap);
+  return new Preprocessor(PreprocessorElement_Level(reverse(loop(ofArray(content.Lines), 0, empty()))), content.StringMap, content.CommentMap, content.YAMLVersion, content.TagHandles);
 }
 function mkLine(line) {
   return PreprocessorElement_Line(line);
@@ -96,4 +136,4 @@ function mkIntendation(children) {
   return PreprocessorElement_Intendation(ofSeq(children));
 }
 
-export { ReadHelpers_indentLevel, mkIntendation, mkLine, mklLevel, read, write };
+export { ReadHelpers_indentLevel, isDocumentEnd, isDocumentStart, mkIntendation, mkLine, mklLevel, read, write };