@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Reader.fs.js

@@ -0,0 +1,480 @@
+import { match } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { getItemFromDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { value, unwrap, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toList, takeWhile, skipWhile, delay, append as append$1, singleton as singleton$1, collect, map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { YAMLElement_Object, YAMLElement_Mapping, PreprocessorElement_Line, YAMLContent_create_27AED5E3, YAMLElement_Comment, YAMLElement_Value, YAMLElement_Sequence } from './YAMLiciousTypes.fs.js';
+import { empty, isEmpty, head, tail, reverse, cons, singleton, ofArrayWithTail, append } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { $007CSchemaNamespace$007C_$007C, $007CSequenceMinusOpener$007C_$007C, $007CInlineSequence$007C_$007C, $007CSequenceSquareOpener$007C_$007C, $007CSequenceSquareCloser$007C_$007C, $007CInlineJSON$007C_$007C, $007CJSONKeyOpener$007C_$007C, $007CJSONCloser$007C_$007C, $007CKey$007C_$007C, $007CKeyValue$007C_$007C, $007CYamlComment$007C_$007C, $007CYamlValue$007C_$007C } from './RegexActivePatterns.fs.js';
+import { toFail, split, printf, trimEnd } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { read as read$1 } from './Preprocessing.fs.js';
+
+function restoreStringReplace(stringDict, v) {
+  const m = match(/<s f=(?<index>\d+)\/>/gu, v);
+  if (m != null) {
+    return getItemFromDict(stringDict, parse(m.groups && m.groups.index || "", 511, false, 32));
+  } else {
+    return v;
+  }
+}
+function restoreCommentReplace(commentDict, commentId) {
+  return map((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$1(v.Value != null ? singleton$1(cons(PreprocessorElement_Line(value(v.Value)), yamlAstList)) : singleton$1(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$1(singleton$1(singleton(PreprocessorElement_Line(value(v_1.Value)))), delay(() => collectSequenceElements(tail(eles))))));
+        } else if ($007CYamlComment$007C_$007C(head(eles)) != null) {
+          return toList(delay(() => append$1(singleton$1(singleton(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) {
+  const loopRead = (restlist_mut, acc_mut) => {
+    let c2_2, c1_2, c1_1, c2_1;
+    loopRead:
+      while (true) {
+        const restlist = restlist_mut, acc = acc_mut;
+        let matchResult, rest0, v, yamlAstList;
+        if (!isEmpty(restlist)) {
+          const activePatternResult = $007CSchemaNamespace$007C_$007C(head(restlist));
+          if (activePatternResult != null) {
+            if (!isEmpty(tail(restlist))) {
+              if (head(tail(restlist)).tag === /* Intendation */
+              1) {
+                matchResult = 0;
+                rest0 = tail(tail(restlist));
+                v = value(activePatternResult);
+                yamlAstList = head(tail(restlist)).fields[0];
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            const sequenceElements = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0)));
+            restlist_mut = toList(skipWhile(isSequenceElement, rest0));
+            acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(cons(PreprocessorElement_Line(v.Key), yamlAstList), empty())), delay(() => map$1((i) => loopRead(i, empty()), sequenceElements)))))), acc);
+            continue loopRead;
+          }
+          default: {
+            let matchResult_1, rest0_1, v_1, rest0_2, v_2, yamlAstList_1;
+            if (!isEmpty(restlist)) {
+              const activePatternResult_1 = $007CSchemaNamespace$007C_$007C(head(restlist));
+              if (activePatternResult_1 != null) {
+                matchResult_1 = 0;
+                rest0_1 = tail(restlist);
+                v_1 = value(activePatternResult_1);
+              } else {
+                const activePatternResult_2 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                if (activePatternResult_2 != null) {
+                  if (!isEmpty(tail(restlist))) {
+                    if (head(tail(restlist)).tag === /* Intendation */
+                    1) {
+                      matchResult_1 = 1;
+                      rest0_2 = tail(tail(restlist));
+                      v_2 = value(activePatternResult_2);
+                      yamlAstList_1 = head(tail(restlist)).fields[0];
+                    } else {
+                      matchResult_1 = 2;
+                    }
+                  } else {
+                    matchResult_1 = 2;
+                  }
+                } else {
+                  matchResult_1 = 2;
+                }
+              }
+            } else {
+              matchResult_1 = 2;
+            }
+            switch (matchResult_1) {
+              case 0: {
+                const sequenceElements_1 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_1)));
+                restlist_mut = toList(skipWhile(isSequenceElement, rest0_1));
+                acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(singleton(PreprocessorElement_Line(v_1.Key)), empty())), delay(() => map$1((i_1) => loopRead(i_1, empty()), sequenceElements_1)))))), acc);
+                continue loopRead;
+              }
+              case 1: {
+                const objectList_1 = v_2.Value != null ? cons(PreprocessorElement_Line(value(v_2.Value)), yamlAstList_1) : yamlAstList_1;
+                const sequenceElements_2 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_2)));
+                restlist_mut = toList(skipWhile(isSequenceElement, rest0_2));
+                acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(objectList_1, empty())), delay(() => map$1((i_2) => loopRead(i_2, empty()), sequenceElements_2)))))), acc);
+                continue loopRead;
+              }
+              default: {
+                let matchResult_2, rest0_3, v_3, rest_4, v_4, closer, iList, opener, rest_5;
+                if (!isEmpty(restlist)) {
+                  const activePatternResult_3 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                  if (activePatternResult_3 != null) {
+                    matchResult_2 = 0;
+                    rest0_3 = tail(restlist);
+                    v_3 = value(activePatternResult_3);
+                  } else {
+                    const activePatternResult_4 = $007CInlineSequence$007C_$007C(head(restlist));
+                    if (activePatternResult_4 != null) {
+                      matchResult_2 = 1;
+                      rest_4 = tail(restlist);
+                      v_4 = value(activePatternResult_4);
+                    } else {
+                      const activePatternResult_5 = $007CSequenceSquareOpener$007C_$007C(head(restlist));
+                      if (activePatternResult_5 != null) {
+                        if (!isEmpty(tail(restlist))) {
+                          if (head(tail(restlist)).tag === /* Intendation */
+                          1) {
+                            if (!isEmpty(tail(tail(restlist)))) {
+                              const activePatternResult_6 = $007CSequenceSquareCloser$007C_$007C(head(tail(tail(restlist))));
+                              if (activePatternResult_6 != null) {
+                                matchResult_2 = 2;
+                                closer = value(activePatternResult_6);
+                                iList = head(tail(restlist)).fields[0];
+                                opener = value(activePatternResult_5);
+                                rest_5 = tail(tail(tail(restlist)));
+                              } else {
+                                matchResult_2 = 3;
+                              }
+                            } else {
+                              matchResult_2 = 3;
+                            }
+                          } else {
+                            matchResult_2 = 3;
+                          }
+                        } else {
+                          matchResult_2 = 3;
+                        }
+                      } else {
+                        matchResult_2 = 3;
+                      }
+                    }
+                  }
+                } else {
+                  matchResult_2 = 3;
+                }
+                switch (matchResult_2) {
+                  case 0: {
+                    const sequenceElements_3 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_3)));
+                    restlist_mut = toList(skipWhile(isSequenceElement, rest0_3));
+                    acc_mut = cons(YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(singleton(PreprocessorElement_Line(value(v_3.Value))), empty())), delay(() => map$1((i_3) => loopRead(i_3, empty()), sequenceElements_3)))))), acc);
+                    continue loopRead;
+                  }
+                  case 1: {
+                    const c = restoreCommentReplace(commentDict, v_4.Comment);
+                    const split$1 = split(v_4.Value, [","], void 0, 1);
+                    const current_4 = YAMLElement_Sequence(toList(delay(() => map$1((value) => loopRead(singleton(PreprocessorElement_Line(value.trim())), empty()), split$1))));
+                    restlist_mut = rest_4;
+                    acc_mut = c != null ? ofArrayWithTail([current_4, YAMLElement_Comment(value(c))], acc) : cons(current_4, acc);
+                    continue loopRead;
+                  }
+                  case 2: {
+                    const c1 = restoreCommentReplace(commentDict, opener.Comment);
+                    const c2 = restoreCommentReplace(commentDict, closer.Comment);
+                    const current_5 = YAMLElement_Sequence(toList(delay(() => collect((i_4) => singleton$1(loopRead(singleton(i_4.tag === /* Line */
+                    2 ? PreprocessorElement_Line(trimEnd(i_4.fields[0], ",")) : toFail(printf("Unexpected element in MultiLineSquareBrackets: %A"))(i_4)), empty())), iList))));
+                    restlist_mut = rest_5;
+                    acc_mut = c1 == null ? c2 == null ? cons(current_5, acc) : (c2_2 = value(c2), ofArrayWithTail([YAMLElement_Comment(c2_2), current_5], acc)) : c2 == null ? (c1_2 = value(c1), ofArrayWithTail([current_5, YAMLElement_Comment(c1_2)], acc)) : (c1_1 = value(c1), c2_1 = value(c2), ofArrayWithTail([YAMLElement_Comment(c2_1), current_5, YAMLElement_Comment(c1_1)], acc));
+                    continue loopRead;
+                  }
+                  default: {
+                    let matchResult_3, rest_6, v_5, closer_1, iList_1, opener_1, rest_7;
+                    if (!isEmpty(restlist)) {
+                      const activePatternResult_7 = $007CInlineJSON$007C_$007C(head(restlist));
+                      if (activePatternResult_7 != null) {
+                        matchResult_3 = 0;
+                        rest_6 = tail(restlist);
+                        v_5 = value(activePatternResult_7);
+                      } else {
+                        const activePatternResult_8 = $007CJSONKeyOpener$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 = $007CJSONCloser$007C_$007C(head(tail(tail(restlist))));
+                                if (activePatternResult_9 != null) {
+                                  matchResult_3 = 1;
+                                  closer_1 = value(activePatternResult_9);
+                                  iList_1 = head(tail(restlist)).fields[0];
+                                  opener_1 = value(activePatternResult_8);
+                                  rest_7 = tail(tail(tail(restlist)));
+                                } else {
+                                  matchResult_3 = 2;
+                                }
+                              } else {
+                                matchResult_3 = 2;
+                              }
+                            } else {
+                              matchResult_3 = 2;
+                            }
+                          } else {
+                            matchResult_3 = 2;
+                          }
+                        } else {
+                          matchResult_3 = 2;
+                        }
+                      }
+                    } else {
+                      matchResult_3 = 2;
+                    }
+                    switch (matchResult_3) {
+                      case 0: {
+                        const c_1 = restoreCommentReplace(commentDict, v_5.Comment);
+                        const split_1 = split(v_5.Value, [","], void 0, 1);
+                        const current_6 = reverse(toList(delay(() => collect((value_1) => {
+                          const matchValue_1 = loopRead(singleton(PreprocessorElement_Line(value_1.trim())), empty());
+                          if (matchValue_1.tag === /* Object */
+                          3) {
+                            return matchValue_1.fields[0];
+                          } else {
+                            throw new Error("Unexpected element in InlineJSON");
+                          }
+                        }, split_1))));
+                        restlist_mut = rest_6;
+                        acc_mut = c_1 != null ? append(current_6, cons(YAMLElement_Comment(value(c_1)), acc)) : append(current_6, acc);
+                        continue loopRead;
+                      }
+                      case 1: {
+                        const c1_3 = restoreCommentReplace(commentDict, opener_1.Comment);
+                        const c2_3 = restoreCommentReplace(commentDict, closer_1.Comment);
+                        const current_7 = YAMLElement_Mapping(YAMLContent_create_27AED5E3(opener_1.Key, unwrap(c1_3)), YAMLElement_Object(toList(delay(() => collect((i_5) => {
+                          const matchValue_2 = loopRead(singleton(i_5.tag === /* Line */
+                          2 ? PreprocessorElement_Line(trimEnd(i_5.fields[0], ",")) : toFail(printf("Unexpected element in MultiLineSquareBrackets: %A"))(i_5)), empty());
+                          if (matchValue_2.tag === /* Object */
+                          3) {
+                            return matchValue_2.fields[0];
+                          } else {
+                            throw new Error("Unexpected element in MultilineJSON");
+                          }
+                        }, iList_1)))));
+                        restlist_mut = rest_7;
+                        acc_mut = c2_3 == null ? cons(current_7, acc) : ofArrayWithTail([YAMLElement_Comment(value(c2_3)), current_7], acc);
+                        continue loopRead;
+                      }
+                      default: {
+                        let matchResult_4, rest_8, v_6, yamlAstList_2;
+                        if (!isEmpty(restlist)) {
+                          const activePatternResult_10 = $007CKey$007C_$007C(head(restlist));
+                          if (activePatternResult_10 != null) {
+                            if (!isEmpty(tail(restlist))) {
+                              if (head(tail(restlist)).tag === /* Intendation */
+                              1) {
+                                matchResult_4 = 0;
+                                rest_8 = tail(tail(restlist));
+                                v_6 = value(activePatternResult_10);
+                                yamlAstList_2 = head(tail(restlist)).fields[0];
+                              } else {
+                                matchResult_4 = 1;
+                              }
+                            } else {
+                              matchResult_4 = 1;
+                            }
+                          } else {
+                            matchResult_4 = 1;
+                          }
+                        } else {
+                          matchResult_4 = 1;
+                        }
+                        switch (matchResult_4) {
+                          case 0: {
+                            restlist_mut = rest_8;
+                            acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_27AED5E3(v_6.Key, unwrap(restoreCommentReplace(commentDict, v_6.Comment))), loopRead(yamlAstList_2, empty())), acc);
+                            continue loopRead;
+                          }
+                          default: {
+                            let matchResult_5, rest0_4, v_7, w, yamlAstList_3;
+                            if (!isEmpty(restlist)) {
+                              const activePatternResult_11 = $007CKey$007C_$007C(head(restlist));
+                              if (activePatternResult_11 != null) {
+                                if (!isEmpty(tail(restlist))) {
+                                  const activePatternResult_12 = $007CSequenceMinusOpener$007C_$007C(head(tail(restlist)));
+                                  if (activePatternResult_12 != null) {
+                                    if (!isEmpty(tail(tail(restlist)))) {
+                                      if (head(tail(tail(restlist))).tag === /* Intendation */
+                                      1) {
+                                        matchResult_5 = 0;
+                                        rest0_4 = tail(tail(tail(restlist)));
+                                        v_7 = value(activePatternResult_11);
+                                        w = value(activePatternResult_12);
+                                        yamlAstList_3 = head(tail(tail(restlist))).fields[0];
+                                      } else {
+                                        matchResult_5 = 1;
+                                      }
+                                    } else {
+                                      matchResult_5 = 1;
+                                    }
+                                  } else {
+                                    matchResult_5 = 1;
+                                  }
+                                } else {
+                                  matchResult_5 = 1;
+                                }
+                              } else {
+                                matchResult_5 = 1;
+                              }
+                            } else {
+                              matchResult_5 = 1;
+                            }
+                            switch (matchResult_5) {
+                              case 0: {
+                                const c_3 = restoreCommentReplace(commentDict, v_7.Comment);
+                                const objectList_2 = w.Value != null ? cons(PreprocessorElement_Line(value(w.Value)), yamlAstList_3) : yamlAstList_3;
+                                const sequenceElements_4 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_4)));
+                                const rest_9 = toList(skipWhile(isSequenceElement, rest0_4));
+                                const seq = YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(objectList_2, empty())), delay(() => map$1((i_6) => loopRead(i_6, empty()), sequenceElements_4))))));
+                                restlist_mut = rest_9;
+                                acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_27AED5E3(v_7.Key, unwrap(c_3)), YAMLElement_Object(singleton(seq))), acc);
+                                continue loopRead;
+                              }
+                              default: {
+                                let matchResult_6, rest0_5, v_8, w_1;
+                                if (!isEmpty(restlist)) {
+                                  const activePatternResult_13 = $007CKey$007C_$007C(head(restlist));
+                                  if (activePatternResult_13 != null) {
+                                    if (!isEmpty(tail(restlist))) {
+                                      const activePatternResult_14 = $007CSequenceMinusOpener$007C_$007C(head(tail(restlist)));
+                                      if (activePatternResult_14 != null) {
+                                        matchResult_6 = 0;
+                                        rest0_5 = tail(tail(restlist));
+                                        v_8 = value(activePatternResult_13);
+                                        w_1 = value(activePatternResult_14);
+                                      } else {
+                                        matchResult_6 = 1;
+                                      }
+                                    } else {
+                                      matchResult_6 = 1;
+                                    }
+                                  } else {
+                                    matchResult_6 = 1;
+                                  }
+                                } else {
+                                  matchResult_6 = 1;
+                                }
+                                switch (matchResult_6) {
+                                  case 0: {
+                                    const c_4 = restoreCommentReplace(commentDict, v_8.Comment);
+                                    const sequenceElements_5 = collectSequenceElements(toList(takeWhile(isSequenceElement, rest0_5)));
+                                    const rest_10 = toList(skipWhile(isSequenceElement, rest0_5));
+                                    const seq_1 = YAMLElement_Sequence(toList(delay(() => append$1(singleton$1(loopRead(singleton(PreprocessorElement_Line(value(w_1.Value))), empty())), delay(() => map$1((i_7) => loopRead(i_7, empty()), sequenceElements_5))))));
+                                    restlist_mut = rest_10;
+                                    acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_27AED5E3(v_8.Key, unwrap(c_4)), YAMLElement_Object(singleton(seq_1))), acc);
+                                    continue loopRead;
+                                  }
+                                  default:
+                                    if (isEmpty(restlist)) {
+                                      return YAMLElement_Object(reverse(acc));
+                                    } else {
+                                      const activePatternResult_15 = $007CKeyValue$007C_$007C(head(restlist));
+                                      if (activePatternResult_15 != null) {
+                                        const v_9 = value(activePatternResult_15);
+                                        restlist_mut = tail(restlist);
+                                        acc_mut = cons(YAMLElement_Mapping(YAMLContent_create_27AED5E3(v_9.Key), loopRead(singleton(PreprocessorElement_Line(v_9.Value)), empty())), acc);
+                                        continue loopRead;
+                                      } else {
+                                        const activePatternResult_16 = $007CYamlComment$007C_$007C(head(restlist));
+                                        if (activePatternResult_16 != null) {
+                                          const v_10 = value(activePatternResult_16);
+                                          restlist_mut = tail(restlist);
+                                          acc_mut = cons(YAMLElement_Comment(getItemFromDict(commentDict, v_10.Comment)), acc);
+                                          continue loopRead;
+                                        } else {
+                                          const activePatternResult_17 = $007CYamlValue$007C_$007C(head(restlist));
+                                          if (activePatternResult_17 != null) {
+                                            const v_11 = value(activePatternResult_17);
+                                            restlist_mut = tail(restlist);
+                                            acc_mut = cons(YAMLElement_Value(YAMLContent_create_27AED5E3(restoreStringReplace(stringDict, v_11.Value), unwrap(restoreCommentReplace(commentDict, v_11.Comment)))), acc);
+                                            continue loopRead;
+                                          } else {
+                                            return toFail(printf("Unknown pattern: %A"))(restlist);
+                                          }
+                                        }
+                                      }
+                                    }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+  };
+  return loopRead(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);
+  } else {
+    throw new Error("Not a root!");
+  }
+}
+
+export { collectSequenceElements, isSequenceElement, read };

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Regex.fs.js

@@ -0,0 +1,11 @@
+const KeyPattern = `^(?<key>[^\\{\\[]+):\\s*(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const LineCommentPattern = `^${"<c f=(?<comment>\\d+)\\/>"}$`;
+const ValuePattern = `^(?<value>.*?)\\s*?(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const InlineSequencePattern = `^\\[(?<inlineSequence>.+)\\]\\s*?(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const InlineJSONPattern = `^\\{(?<inlineSequence>.+)\\}\\s*?(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const SequenceOpenerPattern = `^\\[\\s*(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const SequenceCloserPattern = `^\\]\\s*(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const JSONOpenerPattern = `^(?<key>[^\\{\\[]+):\\s+\\{\\s*(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+const JSONCloserPattern = `^\\}\\s*(${"<c f=(?<comment>\\d+)\\/>"})?$`;
+
+export { InlineJSONPattern, InlineSequencePattern, JSONCloserPattern, JSONOpenerPattern, KeyPattern, LineCommentPattern, SequenceCloserPattern, SequenceOpenerPattern, ValuePattern };