@nfdi4plants/arctrl 3.0.0-beta.8 → 3.0.0

package/dist/ts/ts/fable_modules/YAMLicious.1.0.0-alpha.3/FlowToBlock.fs.js

@@ -0,0 +1,954 @@
+import { Record, Union } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { record_type, int32_type, class_type, string_type, union_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { isEmpty, head, tail, cons, ofArrayWithTail, reverse, empty, ofArray, append, toArray, ofSeq, singleton, collect } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { PreprocessorElement_Line, PreprocessorElement_Intendation } from './YAMLiciousTypes.fs.js';
+import { toText, printf, trimEnd, join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { match, create } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { FlowStyleObjectPattern, FlowStyleArrayPattern, FlowStyleObjectOpenerPattern, FlowStyleObjectCloserPattern } from './Regex.fs.js';
+
+class TransformContext extends Record {
+  constructor(BaseIndent, IndentStep, StringDict) {
+    super();
+    this.BaseIndent = BaseIndent | 0;
+    this.IndentStep = IndentStep | 0;
+    this.StringDict = StringDict;
+  }
+}
+function TransformContext_$reflection() {
+  return record_type("YAMLicious.FlowToBlock.TransformContext", [], TransformContext, () => [["BaseIndent", int32_type], ["IndentStep", int32_type], ["StringDict", class_type("System.Collections.Generic.Dictionary`2", [int32_type, string_type])]]);
+}
+function defaultContext(stringDict) {
+  return new TransformContext(0, 2, stringDict);
+}
+function Token_OpenBrace() {
+  return new Token(0, []);
+}
+function Token_CloseBrace() {
+  return new Token(1, []);
+}
+function Token_OpenBracket() {
+  return new Token(2, []);
+}
+function Token_CloseBracket() {
+  return new Token(3, []);
+}
+function Token_Colon() {
+  return new Token(4, []);
+}
+function Token_Comma() {
+  return new Token(5, []);
+}
+function Token_String(Item) {
+  return new Token(6, [Item]);
+}
+function Token_EOF() {
+  return new Token(7, []);
+}
+class Token extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["OpenBrace", "CloseBrace", "OpenBracket", "CloseBracket", "Colon", "Comma", "String", "EOF"];
+  }
+}
+function Token_$reflection() {
+  return union_type("YAMLicious.FlowToBlock.Token", [], Token, () => [[], [], [], [], [], [], [["Item", string_type]], []]);
+}
+function tokenize(input) {
+  const parseString = (chars_mut, acc_mut) => {
+    parseString:
+      while (true) {
+        const chars = chars_mut, acc = acc_mut;
+        let matchResult, rest, c, rest_1, c_1, rest_2;
+        if (!isEmpty(chars)) {
+          switch (head(chars)) {
+            case '"': {
+              matchResult = 1;
+              rest = tail(chars);
+              break;
+            }
+            case "\\": {
+              if (!isEmpty(tail(chars))) {
+                matchResult = 2;
+                c = head(tail(chars));
+                rest_1 = tail(tail(chars));
+              } else {
+                matchResult = 3;
+                c_1 = head(chars);
+                rest_2 = tail(chars);
+              }
+              break;
+            }
+            default: {
+              matchResult = 3;
+              c_1 = head(chars);
+              rest_2 = tail(chars);
+            }
+          }
+        } else {
+          matchResult = 0;
+        }
+        switch (matchResult) {
+          case 0:
+            return [reverse(acc), empty()];
+          case 1:
+            return [reverse(acc), rest];
+          case 2: {
+            chars_mut = rest_1;
+            acc_mut = ofArrayWithTail([c, "\\"], acc);
+            continue parseString;
+          }
+          default: {
+            chars_mut = rest_2;
+            acc_mut = cons(c_1, acc);
+            continue parseString;
+          }
+        }
+        break;
+      }
+  };
+  const tokenizeChars = (chars_1_mut, acc_1_mut) => {
+    tokenizeChars:
+      while (true) {
+        const chars_1 = chars_1_mut, acc_1 = acc_1_mut;
+        let matchResult_1, rest_3, rest_4, rest_5, rest_6, rest_7, rest_8, rest_9, rest_10, chars_2;
+        if (!isEmpty(chars_1)) {
+          switch (head(chars_1)) {
+            case "	": {
+              matchResult_1 = 1;
+              rest_3 = tail(chars_1);
+              break;
+            }
+            case "\n": {
+              matchResult_1 = 1;
+              rest_3 = tail(chars_1);
+              break;
+            }
+            case "\r": {
+              matchResult_1 = 1;
+              rest_3 = tail(chars_1);
+              break;
+            }
+            case " ": {
+              matchResult_1 = 1;
+              rest_3 = tail(chars_1);
+              break;
+            }
+            case '"': {
+              matchResult_1 = 8;
+              rest_10 = tail(chars_1);
+              break;
+            }
+            case ",": {
+              matchResult_1 = 7;
+              rest_9 = tail(chars_1);
+              break;
+            }
+            case ":": {
+              matchResult_1 = 6;
+              rest_8 = tail(chars_1);
+              break;
+            }
+            case "[": {
+              matchResult_1 = 4;
+              rest_6 = tail(chars_1);
+              break;
+            }
+            case "]": {
+              matchResult_1 = 5;
+              rest_7 = tail(chars_1);
+              break;
+            }
+            case "{": {
+              matchResult_1 = 2;
+              rest_4 = tail(chars_1);
+              break;
+            }
+            case "}": {
+              matchResult_1 = 3;
+              rest_5 = tail(chars_1);
+              break;
+            }
+            default: {
+              matchResult_1 = 9;
+              chars_2 = chars_1;
+            }
+          }
+        } else {
+          matchResult_1 = 0;
+        }
+        switch (matchResult_1) {
+          case 0:
+            return reverse(cons(Token_EOF(), acc_1));
+          case 1: {
+            chars_1_mut = rest_3;
+            acc_1_mut = acc_1;
+            continue tokenizeChars;
+          }
+          case 2: {
+            chars_1_mut = rest_4;
+            acc_1_mut = cons(Token_OpenBrace(), acc_1);
+            continue tokenizeChars;
+          }
+          case 3: {
+            chars_1_mut = rest_5;
+            acc_1_mut = cons(Token_CloseBrace(), acc_1);
+            continue tokenizeChars;
+          }
+          case 4: {
+            chars_1_mut = rest_6;
+            acc_1_mut = cons(Token_OpenBracket(), acc_1);
+            continue tokenizeChars;
+          }
+          case 5: {
+            chars_1_mut = rest_7;
+            acc_1_mut = cons(Token_CloseBracket(), acc_1);
+            continue tokenizeChars;
+          }
+          case 6: {
+            chars_1_mut = rest_8;
+            acc_1_mut = cons(Token_Colon(), acc_1);
+            continue tokenizeChars;
+          }
+          case 7: {
+            chars_1_mut = rest_9;
+            acc_1_mut = cons(Token_Comma(), acc_1);
+            continue tokenizeChars;
+          }
+          case 8: {
+            const patternInput = parseString(rest_10, empty());
+            chars_1_mut = patternInput[1];
+            acc_1_mut = cons(Token_String(toArray(patternInput[0]).join("")), acc_1);
+            continue tokenizeChars;
+          }
+          default: {
+            const consumePlaceholder = (cs, acc_2) => {
+              const loop = (cs_1_mut, acc_3_mut) => {
+                loop:
+                  while (true) {
+                    const cs_1 = cs_1_mut, acc_3 = acc_3_mut;
+                    let matchResult_2, rest_11, c_2, rest_12;
+                    if (isEmpty(cs_1)) {
+                      matchResult_2 = 2;
+                    } else if (head(cs_1) === "/") {
+                      if (!isEmpty(tail(cs_1))) {
+                        if (head(tail(cs_1)) === ">") {
+                          matchResult_2 = 0;
+                          rest_11 = tail(tail(cs_1));
+                        } else {
+                          matchResult_2 = 1;
+                          c_2 = head(cs_1);
+                          rest_12 = tail(cs_1);
+                        }
+                      } else {
+                        matchResult_2 = 1;
+                        c_2 = head(cs_1);
+                        rest_12 = tail(cs_1);
+                      }
+                    } else {
+                      matchResult_2 = 1;
+                      c_2 = head(cs_1);
+                      rest_12 = tail(cs_1);
+                    }
+                    switch (matchResult_2) {
+                      case 0:
+                        return [reverse(ofArrayWithTail([">", "/"], acc_3)), rest_11];
+                      case 1: {
+                        cs_1_mut = rest_12;
+                        acc_3_mut = cons(c_2, acc_3);
+                        continue loop;
+                      }
+                      default:
+                        return [reverse(acc_3), empty()];
+                    }
+                    break;
+                  }
+              };
+              return loop(cs, acc_2);
+            };
+            const parseUnquoted = (cs_2_mut, acc_4_mut) => {
+              let c_3, c_4, c_5, c_6, c_7, c_8, c_9, c_10, c_11, c_12, c_13, c_14, c_15, c_16, c_17, c_18;
+              parseUnquoted:
+                while (true) {
+                  const cs_2 = cs_2_mut, acc_4 = acc_4_mut;
+                  let matchResult_3, rest_30, rest_31, c_19, rest_32, rest_33, c_20, rest_34;
+                  if (!isEmpty(cs_2)) {
+                    switch (head(cs_2)) {
+                      case " ": {
+                        if (c_3 = head(cs_2), (((((((c_3 === "{" ? true : c_3 === "}") ? true : c_3 === "[") ? true : c_3 === "]") ? true : c_3 === ":") ? true : c_3 === ",") ? true : c_3 === "\n") ? true : c_3 === "\r") ? true : c_3 === "	") {
+                          matchResult_3 = 3;
+                          c_19 = head(cs_2);
+                          rest_32 = tail(cs_2);
+                        } else if (isEmpty(acc_4)) {
+                          matchResult_3 = 4;
+                          rest_33 = tail(cs_2);
+                        } else {
+                          matchResult_3 = 5;
+                          c_20 = head(cs_2);
+                          rest_34 = tail(cs_2);
+                        }
+                        break;
+                      }
+                      case "<": {
+                        if (!isEmpty(tail(cs_2))) {
+                          switch (head(tail(cs_2))) {
+                            case "c": {
+                              if (!isEmpty(tail(tail(cs_2)))) {
+                                if (head(tail(tail(cs_2))) === " ") {
+                                  if (!isEmpty(tail(tail(tail(cs_2))))) {
+                                    if (head(tail(tail(tail(cs_2)))) === "f") {
+                                      if (!isEmpty(tail(tail(tail(tail(cs_2)))))) {
+                                        if (head(tail(tail(tail(tail(cs_2))))) === "=") {
+                                          matchResult_3 = 2;
+                                          rest_31 = tail(tail(tail(tail(tail(cs_2)))));
+                                        } else if (c_4 = head(cs_2), (((((((c_4 === "{" ? true : c_4 === "}") ? true : c_4 === "[") ? true : c_4 === "]") ? true : c_4 === ":") ? true : c_4 === ",") ? true : c_4 === "\n") ? true : c_4 === "\r") ? true : c_4 === "	") {
+                                          matchResult_3 = 3;
+                                          c_19 = head(cs_2);
+                                          rest_32 = tail(cs_2);
+                                        } else {
+                                          matchResult_3 = 5;
+                                          c_20 = head(cs_2);
+                                          rest_34 = tail(cs_2);
+                                        }
+                                      } else if (c_5 = head(cs_2), (((((((c_5 === "{" ? true : c_5 === "}") ? true : c_5 === "[") ? true : c_5 === "]") ? true : c_5 === ":") ? true : c_5 === ",") ? true : c_5 === "\n") ? true : c_5 === "\r") ? true : c_5 === "	") {
+                                        matchResult_3 = 3;
+                                        c_19 = head(cs_2);
+                                        rest_32 = tail(cs_2);
+                                      } else {
+                                        matchResult_3 = 5;
+                                        c_20 = head(cs_2);
+                                        rest_34 = tail(cs_2);
+                                      }
+                                    } else if (c_6 = head(cs_2), (((((((c_6 === "{" ? true : c_6 === "}") ? true : c_6 === "[") ? true : c_6 === "]") ? true : c_6 === ":") ? true : c_6 === ",") ? true : c_6 === "\n") ? true : c_6 === "\r") ? true : c_6 === "	") {
+                                      matchResult_3 = 3;
+                                      c_19 = head(cs_2);
+                                      rest_32 = tail(cs_2);
+                                    } else {
+                                      matchResult_3 = 5;
+                                      c_20 = head(cs_2);
+                                      rest_34 = tail(cs_2);
+                                    }
+                                  } else if (c_7 = head(cs_2), (((((((c_7 === "{" ? true : c_7 === "}") ? true : c_7 === "[") ? true : c_7 === "]") ? true : c_7 === ":") ? true : c_7 === ",") ? true : c_7 === "\n") ? true : c_7 === "\r") ? true : c_7 === "	") {
+                                    matchResult_3 = 3;
+                                    c_19 = head(cs_2);
+                                    rest_32 = tail(cs_2);
+                                  } else {
+                                    matchResult_3 = 5;
+                                    c_20 = head(cs_2);
+                                    rest_34 = tail(cs_2);
+                                  }
+                                } else if (c_8 = head(cs_2), (((((((c_8 === "{" ? true : c_8 === "}") ? true : c_8 === "[") ? true : c_8 === "]") ? true : c_8 === ":") ? true : c_8 === ",") ? true : c_8 === "\n") ? true : c_8 === "\r") ? true : c_8 === "	") {
+                                  matchResult_3 = 3;
+                                  c_19 = head(cs_2);
+                                  rest_32 = tail(cs_2);
+                                } else {
+                                  matchResult_3 = 5;
+                                  c_20 = head(cs_2);
+                                  rest_34 = tail(cs_2);
+                                }
+                              } else if (c_9 = head(cs_2), (((((((c_9 === "{" ? true : c_9 === "}") ? true : c_9 === "[") ? true : c_9 === "]") ? true : c_9 === ":") ? true : c_9 === ",") ? true : c_9 === "\n") ? true : c_9 === "\r") ? true : c_9 === "	") {
+                                matchResult_3 = 3;
+                                c_19 = head(cs_2);
+                                rest_32 = tail(cs_2);
+                              } else {
+                                matchResult_3 = 5;
+                                c_20 = head(cs_2);
+                                rest_34 = tail(cs_2);
+                              }
+                              break;
+                            }
+                            case "s": {
+                              if (!isEmpty(tail(tail(cs_2)))) {
+                                if (head(tail(tail(cs_2))) === " ") {
+                                  if (!isEmpty(tail(tail(tail(cs_2))))) {
+                                    if (head(tail(tail(tail(cs_2)))) === "f") {
+                                      if (!isEmpty(tail(tail(tail(tail(cs_2)))))) {
+                                        if (head(tail(tail(tail(tail(cs_2))))) === "=") {
+                                          matchResult_3 = 1;
+                                          rest_30 = tail(tail(tail(tail(tail(cs_2)))));
+                                        } else if (c_10 = head(cs_2), (((((((c_10 === "{" ? true : c_10 === "}") ? true : c_10 === "[") ? true : c_10 === "]") ? true : c_10 === ":") ? true : c_10 === ",") ? true : c_10 === "\n") ? true : c_10 === "\r") ? true : c_10 === "	") {
+                                          matchResult_3 = 3;
+                                          c_19 = head(cs_2);
+                                          rest_32 = tail(cs_2);
+                                        } else {
+                                          matchResult_3 = 5;
+                                          c_20 = head(cs_2);
+                                          rest_34 = tail(cs_2);
+                                        }
+                                      } else if (c_11 = head(cs_2), (((((((c_11 === "{" ? true : c_11 === "}") ? true : c_11 === "[") ? true : c_11 === "]") ? true : c_11 === ":") ? true : c_11 === ",") ? true : c_11 === "\n") ? true : c_11 === "\r") ? true : c_11 === "	") {
+                                        matchResult_3 = 3;
+                                        c_19 = head(cs_2);
+                                        rest_32 = tail(cs_2);
+                                      } else {
+                                        matchResult_3 = 5;
+                                        c_20 = head(cs_2);
+                                        rest_34 = tail(cs_2);
+                                      }
+                                    } else if (c_12 = head(cs_2), (((((((c_12 === "{" ? true : c_12 === "}") ? true : c_12 === "[") ? true : c_12 === "]") ? true : c_12 === ":") ? true : c_12 === ",") ? true : c_12 === "\n") ? true : c_12 === "\r") ? true : c_12 === "	") {
+                                      matchResult_3 = 3;
+                                      c_19 = head(cs_2);
+                                      rest_32 = tail(cs_2);
+                                    } else {
+                                      matchResult_3 = 5;
+                                      c_20 = head(cs_2);
+                                      rest_34 = tail(cs_2);
+                                    }
+                                  } else if (c_13 = head(cs_2), (((((((c_13 === "{" ? true : c_13 === "}") ? true : c_13 === "[") ? true : c_13 === "]") ? true : c_13 === ":") ? true : c_13 === ",") ? true : c_13 === "\n") ? true : c_13 === "\r") ? true : c_13 === "	") {
+                                    matchResult_3 = 3;
+                                    c_19 = head(cs_2);
+                                    rest_32 = tail(cs_2);
+                                  } else {
+                                    matchResult_3 = 5;
+                                    c_20 = head(cs_2);
+                                    rest_34 = tail(cs_2);
+                                  }
+                                } else if (c_14 = head(cs_2), (((((((c_14 === "{" ? true : c_14 === "}") ? true : c_14 === "[") ? true : c_14 === "]") ? true : c_14 === ":") ? true : c_14 === ",") ? true : c_14 === "\n") ? true : c_14 === "\r") ? true : c_14 === "	") {
+                                  matchResult_3 = 3;
+                                  c_19 = head(cs_2);
+                                  rest_32 = tail(cs_2);
+                                } else {
+                                  matchResult_3 = 5;
+                                  c_20 = head(cs_2);
+                                  rest_34 = tail(cs_2);
+                                }
+                              } else if (c_15 = head(cs_2), (((((((c_15 === "{" ? true : c_15 === "}") ? true : c_15 === "[") ? true : c_15 === "]") ? true : c_15 === ":") ? true : c_15 === ",") ? true : c_15 === "\n") ? true : c_15 === "\r") ? true : c_15 === "	") {
+                                matchResult_3 = 3;
+                                c_19 = head(cs_2);
+                                rest_32 = tail(cs_2);
+                              } else {
+                                matchResult_3 = 5;
+                                c_20 = head(cs_2);
+                                rest_34 = tail(cs_2);
+                              }
+                              break;
+                            }
+                            default:
+                              if (c_16 = head(cs_2), (((((((c_16 === "{" ? true : c_16 === "}") ? true : c_16 === "[") ? true : c_16 === "]") ? true : c_16 === ":") ? true : c_16 === ",") ? true : c_16 === "\n") ? true : c_16 === "\r") ? true : c_16 === "	") {
+                                matchResult_3 = 3;
+                                c_19 = head(cs_2);
+                                rest_32 = tail(cs_2);
+                              } else {
+                                matchResult_3 = 5;
+                                c_20 = head(cs_2);
+                                rest_34 = tail(cs_2);
+                              }
+                          }
+                        } else if (c_17 = head(cs_2), (((((((c_17 === "{" ? true : c_17 === "}") ? true : c_17 === "[") ? true : c_17 === "]") ? true : c_17 === ":") ? true : c_17 === ",") ? true : c_17 === "\n") ? true : c_17 === "\r") ? true : c_17 === "	") {
+                          matchResult_3 = 3;
+                          c_19 = head(cs_2);
+                          rest_32 = tail(cs_2);
+                        } else {
+                          matchResult_3 = 5;
+                          c_20 = head(cs_2);
+                          rest_34 = tail(cs_2);
+                        }
+                        break;
+                      }
+                      default:
+                        if (c_18 = head(cs_2), (((((((c_18 === "{" ? true : c_18 === "}") ? true : c_18 === "[") ? true : c_18 === "]") ? true : c_18 === ":") ? true : c_18 === ",") ? true : c_18 === "\n") ? true : c_18 === "\r") ? true : c_18 === "	") {
+                          matchResult_3 = 3;
+                          c_19 = head(cs_2);
+                          rest_32 = tail(cs_2);
+                        } else {
+                          matchResult_3 = 5;
+                          c_20 = head(cs_2);
+                          rest_34 = tail(cs_2);
+                        }
+                    }
+                  } else {
+                    matchResult_3 = 0;
+                  }
+                  switch (matchResult_3) {
+                    case 0:
+                      return [reverse(acc_4), empty()];
+                    case 1: {
+                      const patternInput_1 = consumePlaceholder(rest_30, ofArray(["=", "f", " ", "s", "<"]));
+                      const patternInput_2 = parseUnquoted(patternInput_1[1], empty());
+                      return [append(patternInput_1[0], patternInput_2[0]), patternInput_2[1]];
+                    }
+                    case 2: {
+                      const patternInput_3 = consumePlaceholder(rest_31, ofArray(["=", "f", " ", "c", "<"]));
+                      const patternInput_4 = parseUnquoted(patternInput_3[1], empty());
+                      return [append(patternInput_3[0], patternInput_4[0]), patternInput_4[1]];
+                    }
+                    case 3:
+                      return [reverse(acc_4), cs_2];
+                    case 4: {
+                      cs_2_mut = rest_33;
+                      acc_4_mut = acc_4;
+                      continue parseUnquoted;
+                    }
+                    default: {
+                      cs_2_mut = rest_34;
+                      acc_4_mut = cons(c_20, acc_4);
+                      continue parseUnquoted;
+                    }
+                  }
+                  break;
+                }
+            };
+            const patternInput_5 = parseUnquoted(chars_2, empty());
+            const str_1 = patternInput_5[0];
+            const remaining_3 = patternInput_5[1];
+            if (isEmpty(str_1)) {
+              chars_1_mut = remaining_3;
+              acc_1_mut = acc_1;
+              continue tokenizeChars;
+            } else {
+              chars_1_mut = remaining_3;
+              acc_1_mut = cons(Token_String(toArray(str_1).join("")), acc_1);
+              continue tokenizeChars;
+            }
+          }
+        }
+        break;
+      }
+  };
+  return tokenizeChars(ofSeq(input.split("")), empty());
+}
+function tokensToBlockElements(ctx, tokens) {
+  let simpleValue;
+  let matchResult, rest, rest_1, key, rest_2, rest_3, s;
+  if (!isEmpty(tokens)) {
+    switch (head(tokens).tag) {
+      case /* OpenBrace */
+      0: {
+        matchResult = 0;
+        rest = tail(tokens);
+        break;
+      }
+      case /* OpenBracket */
+      2: {
+        matchResult = 1;
+        rest_1 = tail(tokens);
+        break;
+      }
+      case /* String */
+      6: {
+        if (!isEmpty(tail(tokens))) {
+          if (head(tail(tokens)).tag === /* Colon */
+          4) {
+            matchResult = 2;
+            key = head(tokens).fields[0];
+            rest_2 = tail(tail(tokens));
+          } else {
+            matchResult = 3;
+            rest_3 = tail(tokens);
+            s = head(tokens).fields[0];
+          }
+        } else {
+          matchResult = 3;
+          rest_3 = tail(tokens);
+          s = head(tokens).fields[0];
+        }
+        break;
+      }
+      case /* EOF */
+      7: {
+        matchResult = 4;
+        break;
+      }
+      default:
+        matchResult = 5;
+    }
+  } else {
+    matchResult = 5;
+  }
+  switch (matchResult) {
+    case 0:
+      return objectToBlockElements(ctx, rest);
+    case 1:
+      return arrayToBlockElements(ctx, rest_1);
+    case 2: {
+      const childCtx = new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict);
+      let matchResult_1;
+      if (!isEmpty(rest_2)) {
+        switch (head(rest_2).tag) {
+          case /* OpenBrace */
+          0: {
+            matchResult_1 = 0;
+            break;
+          }
+          case /* OpenBracket */
+          2: {
+            matchResult_1 = 1;
+            break;
+          }
+          default:
+            matchResult_1 = 2;
+        }
+      } else {
+        matchResult_1 = 2;
+      }
+      switch (matchResult_1) {
+        case 0: {
+          const patternInput = tokensToBlockElements(childCtx, rest_2);
+          return [ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(patternInput[0])]), patternInput[1]];
+        }
+        case 1: {
+          const patternInput_1 = tokensToBlockElements(childCtx, rest_2);
+          return [ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(patternInput_1[0])]), patternInput_1[1]];
+        }
+        default: {
+          const patternInput_2 = tokensToBlockElements(childCtx, rest_2);
+          const valueElements_2 = patternInput_2[0];
+          return [isEmpty(valueElements_2) ? singleton(PreprocessorElement_Line(toText(printf("%s: {}"))(key))) : head(valueElements_2).tag === /* Line */
+          2 ? isEmpty(tail(valueElements_2)) ? (simpleValue = head(valueElements_2).fields[0], singleton(PreprocessorElement_Line(toText(printf("%s: %s"))(key)(simpleValue)))) : ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(valueElements_2)]) : ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(valueElements_2)]), patternInput_2[1]];
+        }
+      }
+    }
+    case 3:
+      return [singleton(PreprocessorElement_Line(s)), rest_3];
+    case 4:
+      return [empty(), tokens];
+    default:
+      throw new Error(`Unexpected token in tokensToBlockElements: ${tokens}`);
+  }
+}
+function objectToBlockElements(ctx, tokens) {
+  const childCtx = new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict);
+  const parseKeyValues = (tokens_1_mut, acc_mut) => {
+    let simpleValue;
+    parseKeyValues:
+      while (true) {
+        const tokens_1 = tokens_1_mut, acc = acc_mut;
+        let matchResult, rest, rest_1, key, rest_2;
+        if (!isEmpty(tokens_1)) {
+          switch (head(tokens_1).tag) {
+            case /* CloseBrace */
+            1: {
+              matchResult = 0;
+              rest = tail(tokens_1);
+              break;
+            }
+            case /* Comma */
+            5: {
+              matchResult = 1;
+              rest_1 = tail(tokens_1);
+              break;
+            }
+            case /* EOF */
+            7: {
+              matchResult = 2;
+              break;
+            }
+            case /* String */
+            6: {
+              if (!isEmpty(tail(tokens_1))) {
+                if (head(tail(tokens_1)).tag === /* Colon */
+                4) {
+                  matchResult = 3;
+                  key = head(tokens_1).fields[0];
+                  rest_2 = tail(tail(tokens_1));
+                } else {
+                  matchResult = 4;
+                }
+              } else {
+                matchResult = 4;
+              }
+              break;
+            }
+            default:
+              matchResult = 4;
+          }
+        } else {
+          matchResult = 4;
+        }
+        switch (matchResult) {
+          case 0:
+            return [reverse(acc), rest];
+          case 1: {
+            tokens_1_mut = rest_1;
+            acc_mut = acc;
+            continue parseKeyValues;
+          }
+          case 2:
+            return [reverse(acc), tokens_1];
+          case 3: {
+            let matchResult_1;
+            if (!isEmpty(rest_2)) {
+              switch (head(rest_2).tag) {
+                case /* OpenBrace */
+                0: {
+                  matchResult_1 = 0;
+                  break;
+                }
+                case /* OpenBracket */
+                2: {
+                  matchResult_1 = 1;
+                  break;
+                }
+                default:
+                  matchResult_1 = 2;
+              }
+            } else {
+              matchResult_1 = 2;
+            }
+            switch (matchResult_1) {
+              case 0: {
+                const patternInput = tokensToBlockElements(childCtx, rest_2);
+                tokens_1_mut = patternInput[1];
+                acc_mut = append(reverse(ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(patternInput[0])])), acc);
+                continue parseKeyValues;
+              }
+              case 1: {
+                const patternInput_1 = tokensToBlockElements(childCtx, rest_2);
+                tokens_1_mut = patternInput_1[1];
+                acc_mut = append(reverse(ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(patternInput_1[0])])), acc);
+                continue parseKeyValues;
+              }
+              default: {
+                const patternInput_2 = tokensToBlockElements(childCtx, rest_2);
+                const valueElements_2 = patternInput_2[0];
+                tokens_1_mut = patternInput_2[1];
+                acc_mut = append(reverse(isEmpty(valueElements_2) ? singleton(PreprocessorElement_Line(toText(printf("%s: {}"))(key))) : head(valueElements_2).tag === /* Line */
+                2 ? isEmpty(tail(valueElements_2)) ? (simpleValue = head(valueElements_2).fields[0], singleton(PreprocessorElement_Line(toText(printf("%s: %s"))(key)(simpleValue)))) : ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(valueElements_2)]) : ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(valueElements_2)])), acc);
+                continue parseKeyValues;
+              }
+            }
+          }
+          default:
+            throw new Error(`Expected key or close brace in object, got: ${tokens_1}`);
+        }
+        break;
+      }
+  };
+  return parseKeyValues(tokens, empty());
+}
+function arrayToBlockElements(ctx, tokens) {
+  const childCtx = new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict);
+  const parseElements = (tokens_1_mut, acc_mut) => {
+    let singleValue;
+    parseElements:
+      while (true) {
+        const tokens_1 = tokens_1_mut, acc = acc_mut;
+        let matchResult, rest, rest_1;
+        if (!isEmpty(tokens_1)) {
+          switch (head(tokens_1).tag) {
+            case /* CloseBracket */
+            3: {
+              matchResult = 0;
+              rest = tail(tokens_1);
+              break;
+            }
+            case /* Comma */
+            5: {
+              matchResult = 1;
+              rest_1 = tail(tokens_1);
+              break;
+            }
+            case /* EOF */
+            7: {
+              matchResult = 2;
+              break;
+            }
+            default:
+              matchResult = 3;
+          }
+        } else {
+          matchResult = 3;
+        }
+        switch (matchResult) {
+          case 0:
+            return [reverse(acc), rest];
+          case 1: {
+            tokens_1_mut = rest_1;
+            acc_mut = acc;
+            continue parseElements;
+          }
+          case 2:
+            return [reverse(acc), tokens_1];
+          default: {
+            const patternInput = tokensToBlockElements(childCtx, tokens_1);
+            const elementLines = patternInput[0];
+            tokens_1_mut = patternInput[1];
+            acc_mut = append(reverse(isEmpty(elementLines) ? singleton(PreprocessorElement_Line("- {}")) : head(elementLines).tag === /* Line */
+            2 ? isEmpty(tail(elementLines)) ? (singleValue = head(elementLines).fields[0], singleton(PreprocessorElement_Line(toText(printf("- %s"))(singleValue)))) : ofArray([PreprocessorElement_Line("-"), PreprocessorElement_Intendation(elementLines)]) : ofArray([PreprocessorElement_Line("-"), PreprocessorElement_Intendation(elementLines)])), acc);
+            continue parseElements;
+          }
+        }
+        break;
+      }
+  };
+  return parseElements(tokens, empty());
+}
+function transformFlowContent(ctx, content) {
+  return tokensToBlockElements(ctx, tokenize(content))[0];
+}
+function transformElement(ctx, element) {
+  let arg_1, arg_4;
+  switch (element.tag) {
+    case /* Line */
+    2: {
+      const s = element.fields[0];
+      const keyValueMatch = match(/^(?<key>[^\{{\[]+):\s+(?<value>(.*))$/gu, s);
+      if (keyValueMatch != null) {
+        const key = keyValueMatch.groups && keyValueMatch.groups.key || "";
+        const value = (keyValueMatch.groups && keyValueMatch.groups.value || "").trim();
+        if (value.startsWith("{")) {
+          const childCtx = new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict);
+          const objCommentMatch = match(/^(\{.*\})\s*(<c f=(\d+)\/>)?$/gu, value);
+          if (objCommentMatch != null) {
+            const objContent = objCommentMatch[1] || "";
+            const commentGroup = objCommentMatch[3];
+            const transformedValue = transformFlowContent(childCtx, objContent);
+            const keyLine = PreprocessorElement_Line(toText(printf("%s:"))(key));
+            if (commentGroup != null) {
+              const commentId = parse(commentGroup || "", 511, false, 32) | 0;
+              return ofArray([keyLine, PreprocessorElement_Intendation(cons(PreprocessorElement_Line((arg_1 = commentGroup || "", toText(printf("<c f=%s/>"))(arg_1))), transformedValue))]);
+            } else {
+              return ofArray([keyLine, PreprocessorElement_Intendation(transformedValue)]);
+            }
+          } else {
+            const transformedValue_1 = transformFlowContent(childCtx, value);
+            return ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(transformedValue_1)]);
+          }
+        } else if (value.startsWith("[")) {
+          const childCtx_1 = new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict);
+          const arrCommentMatch = match(/^(\[.*\])\s*(<c f=(\d+)\/>)?$/gu, value);
+          if (arrCommentMatch != null) {
+            const arrContent = arrCommentMatch[1] || "";
+            const commentGroup_1 = arrCommentMatch[3];
+            const transformedValue_2 = transformFlowContent(childCtx_1, arrContent);
+            const keyLine_1 = PreprocessorElement_Line(toText(printf("%s:"))(key));
+            if (commentGroup_1 != null) {
+              return ofArray([keyLine_1, PreprocessorElement_Intendation(cons(PreprocessorElement_Line((arg_4 = commentGroup_1 || "", toText(printf("<c f=%s/>"))(arg_4))), transformedValue_2))]);
+            } else {
+              return ofArray([keyLine_1, PreprocessorElement_Intendation(transformedValue_2)]);
+            }
+          } else {
+            const transformedValue_3 = transformFlowContent(childCtx_1, value);
+            return ofArray([PreprocessorElement_Line(toText(printf("%s:"))(key)), PreprocessorElement_Intendation(transformedValue_3)]);
+          }
+        } else {
+          return singleton(element);
+        }
+      } else {
+        const inlineJsonMatch = match(create(FlowStyleObjectPattern), s);
+        if (inlineJsonMatch != null) {
+          const content = inlineJsonMatch.groups && inlineJsonMatch.groups.inlineSequence || "";
+          if (content.trim() === "") {
+            return singleton(PreprocessorElement_Line("{}"));
+          } else {
+            return transformFlowContent(ctx, "{" + content + "}");
+          }
+        } else {
+          const inlineSeqMatch = match(create(FlowStyleArrayPattern), s);
+          if (inlineSeqMatch != null) {
+            const content_1 = inlineSeqMatch.groups && inlineSeqMatch.groups.inlineSequence || "";
+            const commentGroup_2 = inlineSeqMatch.groups && inlineSeqMatch.groups.comment;
+            const transformed_1 = transformFlowContent(ctx, "[" + content_1 + "]");
+            if (commentGroup_2 != null) {
+              const commentId_1 = parse(commentGroup_2 || "", 511, false, 32) | 0;
+              return cons(PreprocessorElement_Line(toText(printf("<c f=%d/>"))(commentId_1)), transformed_1);
+            } else {
+              return transformed_1;
+            }
+          } else {
+            return singleton(element);
+          }
+        }
+      }
+    }
+    case /* Intendation */
+    1:
+      return singleton(PreprocessorElement_Intendation(transformElements(ctx, element.fields[0])));
+    default:
+      return singleton(element);
+  }
+}
+function transformElements(ctx, elements) {
+  const processElements = (elems_mut, acc_mut) => {
+    processElements:
+      while (true) {
+        const elems = elems_mut, acc = acc_mut;
+        let matchResult, closer, iList, opener, rest, elem, rest_1;
+        if (!isEmpty(elems)) {
+          if (head(elems).tag === /* Line */
+          2) {
+            if (!isEmpty(tail(elems))) {
+              if (head(tail(elems)).tag === /* Intendation */
+              1) {
+                if (!isEmpty(tail(tail(elems)))) {
+                  if (head(tail(tail(elems))).tag === /* Line */
+                  2) {
+                    matchResult = 1;
+                    closer = head(tail(tail(elems))).fields[0];
+                    iList = head(tail(elems)).fields[0];
+                    opener = head(elems).fields[0];
+                    rest = tail(tail(tail(elems)));
+                  } else {
+                    matchResult = 2;
+                    elem = head(elems);
+                    rest_1 = tail(elems);
+                  }
+                } else {
+                  matchResult = 2;
+                  elem = head(elems);
+                  rest_1 = tail(elems);
+                }
+              } else {
+                matchResult = 2;
+                elem = head(elems);
+                rest_1 = tail(elems);
+              }
+            } else {
+              matchResult = 2;
+              elem = head(elems);
+              rest_1 = tail(elems);
+            }
+          } else {
+            matchResult = 2;
+            elem = head(elems);
+            rest_1 = tail(elems);
+          }
+        } else {
+          matchResult = 0;
+        }
+        switch (matchResult) {
+          case 0:
+            return reverse(acc);
+          case 1: {
+            const jsonOpenerMatch = match(create(FlowStyleObjectOpenerPattern), opener);
+            if (jsonOpenerMatch != null && match(create(FlowStyleObjectCloserPattern), closer) != null) {
+              const key = jsonOpenerMatch.groups && jsonOpenerMatch.groups.key || "";
+              const flattenLines = (eles) => collect((_arg) => {
+                switch (_arg.tag) {
+                  case /* Line */
+                  2:
+                    return singleton(trimEnd(_arg.fields[0], ","));
+                  case /* Intendation */
+                  1:
+                    return flattenLines(_arg.fields[0]);
+                  default:
+                    return empty();
+                }
+              }, eles);
+              elems_mut = rest;
+              acc_mut = ofArrayWithTail([PreprocessorElement_Intendation(transformFlowContent(new TransformContext(ctx.BaseIndent + ctx.IndentStep, ctx.IndentStep, ctx.StringDict), "{" + join("\n", flattenLines(iList)) + "}")), PreprocessorElement_Line(toText(printf("%s:"))(key))], acc);
+              continue processElements;
+            } else {
+              const transformed1 = transformElement(ctx, PreprocessorElement_Line(opener));
+              const transformed2 = transformElement(ctx, PreprocessorElement_Intendation(iList));
+              elems_mut = rest;
+              acc_mut = append(reverse(transformElement(ctx, PreprocessorElement_Line(closer))), append(reverse(transformed2), append(reverse(transformed1), acc)));
+              continue processElements;
+            }
+          }
+          default: {
+            elems_mut = rest_1;
+            acc_mut = append(reverse(transformElement(ctx, elem)), acc);
+            continue processElements;
+          }
+        }
+        break;
+      }
+  };
+  return processElements(elements, empty());
+}
+
+export { Token, Token_$reflection, Token_CloseBrace, Token_CloseBracket, Token_Colon, Token_Comma, Token_EOF, Token_OpenBrace, Token_OpenBracket, Token_String, TransformContext, TransformContext_$reflection, arrayToBlockElements, defaultContext, objectToBlockElements, tokenize, tokensToBlockElements, transformElement, transformElements, transformFlowContent };