@nfdi4plants/arctrl 3.1.0 → 3.1.1

package/dist/ts/ts/fable_modules/{YAMLicious.1.0.0-alpha.7 → YAMLicious.1.0.0-alpha.11}/Persil.fs.js

@@ -1,17 +1,17 @@
-import { max, length, takeWhile, toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { max, 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 { item, tryFind, takeWhile, take, append } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { trimStart, trimEnd, replace, substring, toText, printf, 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 { Line_normalizeNewlines, BlockScalar_tryDetectHeaderIndent, Line_countLeadingSpaces, Document_isStart, Document_tryInlineContentAfterStartMarker } from './Syntax.fs.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) {
@@ -271,139 +271,14 @@ function replaceQuotedStrings(target, dict, protectedBlockScalarLines, s) {
   }
   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 lines = split(Line_normalizeNewlines(yamlString), ["\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));
+      const matchValue = BlockScalar_tryDetectHeaderIndent(item(i, lines));
       if (matchValue == null) {
         i = i + 1 | 0;
       } else {
@@ -414,7 +289,7 @@ function detectBlockScalarContentLines(yamlString) {
     } else {
       const headerIndent = value(openBlockIndent) | 0;
       const line = item(i, lines);
-      if (line.trim() === "" ? true : countLeadingSpaces(line) > headerIndent) {
+      if (line.trim() === "" ? true : Line_countLeadingSpaces(line) > headerIndent) {
         const value = void protectedLines.push(i);
         i = i + 1 | 0;
       } else {
@@ -474,34 +349,11 @@ function parseTagDirective(line) {
     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 normalizedContent = Line_normalizeNewlines(yamlString);
   const protectedBlockScalarLines = detectBlockScalarContentLines(normalizedContent);
   const lines = cut(commentCleanUp(commentMap, stringCleanUpWithProtected(stringMap, protectedBlockScalarLines, singleQuotedStringCleanUpWithProtected(stringMap, protectedBlockScalarLines, normalizedContent))));
   let directivePreludeLength;
@@ -513,7 +365,7 @@ function pipeline(yamlString) {
       return false;
     }
   }, lines)), false)) {
-    const array_2 = takeWhile$1((l_1) => {
+    const array_2 = takeWhile((l_1) => {
       const t_1 = trimStart(l_1);
       if (t_1.startsWith("%") ? true : t_1.startsWith("#")) {
         return true;
@@ -552,11 +404,11 @@ function pipeline(yamlString) {
   }
   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,
+    Lines: contentLines.length > 0 && Document_isStart(item(0, contentLines)) ? (matchValue_2 = Document_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 };
+export { commentCleanUp, cut, parseTagDirective, parseYAMLDirective, pipeline, singleQuotedStringCleanUp, stringCleanUp };

package/dist/ts/ts/fable_modules/YAMLicious.1.0.0-alpha.11/Preprocessing.fs.js

@@ -0,0 +1,319 @@
+import { Placeholder_isCommentOnlyLine, Line_countLeadingSpaces, BlockScalar_isHeaderLine } from './Syntax.fs.js';
+import { tryFind, isEmpty, head, tail, reverse, cons, empty, ofArray, ofSeq } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { Config_init_71136F3F, Config__get_WhitespaceString, Config, PreprocessorElement_Line, PreprocessorElement_Intendation, Preprocessor, PreprocessorElement_Level } from './YAMLiciousTypes.fs.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';
+import { substring, trimStart, trimEnd } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+
+function isPresentationOnlyLine(line) {
+  if (line.trim() === "") {
+    return true;
+  } else {
+    return Placeholder_isCommentOnlyLine(line);
+  }
+}
+function tryFindContentLine(lines) {
+  return tryFind((arg) => !isPresentationOnlyLine(arg), lines);
+}
+function shouldStayInNestedBlock(currentIntendation, inBlockScalar, line, rest) {
+  let nextLine_1;
+  if (line.trim() === "") {
+    if (inBlockScalar) {
+      const matchValue = tryFind((l) => l.trim() !== "", rest);
+      if (matchValue == null) {
+        return true;
+      } else {
+        return Line_countLeadingSpaces(value(matchValue)) > currentIntendation;
+      }
+    } else {
+      const matchValue_1 = tryFind((l_1) => l_1.trim() !== "", rest);
+      if (matchValue_1 == null) {
+        return true;
+      } else if (nextLine_1 = value(matchValue_1), Placeholder_isCommentOnlyLine(nextLine_1) && Line_countLeadingSpaces(nextLine_1) <= currentIntendation) {
+        const nextLine_2 = value(matchValue_1);
+        const matchValue_2 = tryFindContentLine(rest);
+        if (matchValue_2 == null) {
+          return true;
+        } else {
+          return Line_countLeadingSpaces(value(matchValue_2)) > currentIntendation;
+        }
+      } else {
+        const nextLine_3 = value(matchValue_1);
+        return Line_countLeadingSpaces(nextLine_3) > currentIntendation;
+      }
+    }
+  } else if (Placeholder_isCommentOnlyLine(line)) {
+    if (inBlockScalar) {
+      return Line_countLeadingSpaces(line) > currentIntendation;
+    } else if (Line_countLeadingSpaces(line) > currentIntendation) {
+      return true;
+    } else {
+      const matchValue_3 = tryFindContentLine(rest);
+      if (matchValue_3 == null) {
+        return true;
+      } else {
+        return Line_countLeadingSpaces(value(matchValue_3)) > currentIntendation;
+      }
+    }
+  } else {
+    return Line_countLeadingSpaces(line) > currentIntendation;
+  }
+}
+function splitNestedBlock(currentIntendation, inBlockScalar, lines) {
+  const loop = (acc_mut, remaining_mut) => {
+    loop:
+      while (true) {
+        const acc = acc_mut, remaining = remaining_mut;
+        let matchResult, line_1, rest_1;
+        if (!isEmpty(remaining)) {
+          if (shouldStayInNestedBlock(currentIntendation, inBlockScalar, head(remaining), tail(remaining))) {
+            matchResult = 0;
+            line_1 = head(remaining);
+            rest_1 = tail(remaining);
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            acc_mut = cons(line_1, acc);
+            remaining_mut = rest_1;
+            continue loop;
+          }
+          default:
+            return [reverse(acc), remaining];
+        }
+        break;
+      }
+  };
+  return loop(empty(), lines);
+}
+function write(rootElement, fconfig) {
+  let config_1;
+  const config = Config_init_71136F3F();
+  config_1 = fconfig != null ? value(fconfig)(config) : config;
+  const sb = StringBuffer_$ctor();
+  const loop = (current, sb_1, config_2) => {
+    switch (current.tag) {
+      case /* Intendation */
+      1: {
+        const nextConfig = new Config(config_2.Whitespace, config_2.Level + 1);
+        const enumerator = getEnumerator(current.fields[0]);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            loop(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), sb_1, nextConfig);
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        break;
+      }
+      case /* Level */
+      0: {
+        const enumerator_1 = getEnumerator(current.fields[0]);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            loop(enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"](), sb_1, config_2);
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        break;
+      }
+      case /* Nil */
+      3: {
+        break;
+      }
+      default: {
+        const line = current.fields[0];
+        StringBuffer__AppendLine_Z721C83C5(sb_1, Config__get_WhitespaceString(config_2) + line);
+      }
+    }
+  };
+  loop(rootElement, sb, config_1);
+  return toString(sb);
+}
+function read(yamlStr) {
+  const content = pipeline(yamlStr);
+  const stripIndent = (indent, line) => {
+    if (indent <= 0) {
+      return line;
+    } else if (Line_countLeadingSpaces(line) >= indent) {
+      return substring(line, indent);
+    } else {
+      return trimStart(line);
+    }
+  };
+  const loop = (lines_mut, currentIntendation_mut, inBlockScalar_mut, acc_mut) => {
+    loop:
+      while (true) {
+        const lines = lines_mut, currentIntendation = currentIntendation_mut, inBlockScalar = inBlockScalar_mut, acc = acc_mut;
+        const previousContentLine = () => tryFind((_arg) => {
+          if (_arg.tag === /* Line */
+          2) {
+            const line_1 = _arg.fields[0];
+            return line_1.trim() !== "";
+          } else {
+            return true;
+          }
+        }, acc);
+        const canStartNestedBlockAfterPresentation = () => {
+          const _arg_1 = previousContentLine();
+          let matchResult, line_2;
+          if (_arg_1 != null) {
+            if (value(_arg_1).tag === /* Line */
+            2) {
+              matchResult = 0;
+              line_2 = value(_arg_1).fields[0];
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+          switch (matchResult) {
+            case 0: {
+              const trimmed = trimEnd(line_2);
+              if ((trimmed.endsWith(":") ? true : trimmed.endsWith("[")) ? true : trimmed.endsWith("{")) {
+                return true;
+              } else {
+                return BlockScalar_isHeaderLine(trimmed);
+              }
+            }
+            default:
+              return false;
+          }
+        };
+        const nestedBlockScalarAfterPresentation = () => {
+          const matchValue = previousContentLine();
+          let matchResult_1, line_3;
+          if (matchValue != null) {
+            if (value(matchValue).tag === /* Line */
+            2) {
+              matchResult_1 = 0;
+              line_3 = value(matchValue).fields[0];
+            } else {
+              matchResult_1 = 1;
+            }
+          } else {
+            matchResult_1 = 1;
+          }
+          switch (matchResult_1) {
+            case 0:
+              return BlockScalar_isHeaderLine(trimEnd(line_3));
+            default:
+              return false;
+          }
+        };
+        if (!isEmpty(lines)) {
+          const rest = tail(lines);
+          const line_4 = head(lines);
+          const isEmptyLine = line_4.trim() === "";
+          const isCommentLine = Placeholder_isCommentOnlyLine(line_4);
+          if (isEmptyLine) {
+            const nextIndentedLine = tryFind((l) => l.trim() !== "", rest);
+            let matchResult_2, nextLine_1;
+            if (nextIndentedLine != null) {
+              if (Line_countLeadingSpaces(value(nextIndentedLine)) > currentIntendation && ((isEmpty(acc) ? true : inBlockScalar) ? true : canStartNestedBlockAfterPresentation())) {
+                matchResult_2 = 0;
+                nextLine_1 = value(nextIndentedLine);
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+              case 0: {
+                const nextIntendation = Line_countLeadingSpaces(nextLine_1) | 0;
+                const childInBlockScalar = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+                const patternInput = splitNestedBlock(currentIntendation, childInBlockScalar, cons(line_4, rest));
+                lines_mut = patternInput[1];
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Intendation(reverse(loop(patternInput[0], nextIntendation, childInBlockScalar, empty()))), acc);
+                continue loop;
+              }
+              default: {
+                lines_mut = rest;
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Line(""), acc);
+                continue loop;
+              }
+            }
+          } else if (isCommentLine) {
+            const nextIndentedLine_1 = tryFindContentLine(rest);
+            let matchResult_3, nextLine_3;
+            if (nextIndentedLine_1 != null) {
+              if (Line_countLeadingSpaces(value(nextIndentedLine_1)) > currentIntendation && canStartNestedBlockAfterPresentation()) {
+                matchResult_3 = 0;
+                nextLine_3 = value(nextIndentedLine_1);
+              } else {
+                matchResult_3 = 1;
+              }
+            } else {
+              matchResult_3 = 1;
+            }
+            switch (matchResult_3) {
+              case 0: {
+                const nextIntendation_1 = Line_countLeadingSpaces(nextLine_3) | 0;
+                const childInBlockScalar_1 = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+                const patternInput_1 = splitNestedBlock(currentIntendation, childInBlockScalar_1, cons(line_4, rest));
+                lines_mut = patternInput_1[1];
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Intendation(reverse(loop(patternInput_1[0], nextIntendation_1, childInBlockScalar_1, empty()))), acc);
+                continue loop;
+              }
+              default: {
+                lines_mut = rest;
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Line(stripIndent(currentIntendation, line_4)), acc);
+                continue loop;
+              }
+            }
+          } else {
+            const nextIntendation_2 = Line_countLeadingSpaces(line_4) | 0;
+            if (nextIntendation_2 === currentIntendation) {
+              lines_mut = rest;
+              currentIntendation_mut = currentIntendation;
+              inBlockScalar_mut = inBlockScalar;
+              acc_mut = cons(PreprocessorElement_Line(stripIndent(currentIntendation, line_4)), acc);
+              continue loop;
+            } else {
+              const lineText_2 = stripIndent(nextIntendation_2, line_4);
+              const childInBlockScalar_2 = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+              const patternInput_2 = splitNestedBlock(currentIntendation, childInBlockScalar_2, rest);
+              lines_mut = patternInput_2[1];
+              currentIntendation_mut = currentIntendation;
+              inBlockScalar_mut = inBlockScalar;
+              acc_mut = cons(PreprocessorElement_Intendation(cons(PreprocessorElement_Line(lineText_2), reverse(loop(patternInput_2[0], nextIntendation_2, childInBlockScalar_2, empty())))), acc);
+              continue loop;
+            }
+          }
+        } else {
+          return acc;
+        }
+        break;
+      }
+  };
+  return new Preprocessor(PreprocessorElement_Level(reverse(loop(ofArray(content.Lines), 0, false, empty()))), content.StringMap, content.CommentMap, content.YAMLVersion, content.TagHandles);
+}
+function mkLine(line) {
+  return PreprocessorElement_Line(line);
+}
+function mklLevel(children) {
+  return PreprocessorElement_Level(ofSeq(children));
+}
+function mkIntendation(children) {
+  return PreprocessorElement_Intendation(ofSeq(children));
+}
+
+export { mkIntendation, mkLine, mklLevel, read, write };