@nfdi4plants/arctrl 2.0.0-beta.2 → 2.0.0

package/fable_modules/YAMLicious.0.0.1/Reader.fs.js

@@ -0,0 +1,530 @@
+import { match } from "../fable-library-js.4.16.0/RegExp.js";
+import { getItemFromDict } from "../fable-library-js.4.16.0/MapUtil.js";
+import { parse } from "../fable-library-js.4.16.0/Int32.js";
+import { unwrap, value as value_2, map } from "../fable-library-js.4.16.0/Option.js";
+import { empty as empty_1, collect, map as map_1, skipWhile, takeWhile, singleton, append, delay, toList } from "../fable-library-js.4.16.0/Seq.js";
+import { YAMLContent_create_27AED5E3, YAMLElement, PreprocessorElement } from "./YAMLiciousTypes.fs.js";
+import { append as append_1, reverse, ofArrayWithTail, tail, singleton as singleton_1, head, empty, isEmpty, cons } from "../fable-library-js.4.16.0/List.js";
+import { $007CSchemaNamespace$007C_$007C, $007CSequenceSquareCloser$007C_$007C, $007CSequenceSquareOpener$007C_$007C, $007CInlineSequence$007C_$007C, $007CJSONCloser$007C_$007C, $007CJSONKeyOpener$007C_$007C, $007CInlineJSON$007C_$007C, $007CKey$007C_$007C, $007CYamlValue$007C_$007C, $007CKeyValue$007C_$007C, $007CYamlComment$007C_$007C, $007CSequenceMinusOpener$007C_$007C } from "./RegexActivePatterns.fs.js";
+import { trimEnd, split as split_2, printf, toFail } from "../fable-library-js.4.16.0/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);
+}
+
+export 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 === 1) {
+                    matchResult = 0;
+                    rest = tail(tail(eles));
+                    v = activePatternResult;
+                    yamlAstList = head(tail(eles)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return toList(delay(() => append((v.Value != null) ? singleton(cons(new PreprocessorElement(2, [value_2(v.Value)]), yamlAstList)) : singleton(yamlAstList), delay(() => collectSequenceElements(rest)))));
+        default:
+            if (isEmpty(eles)) {
+                return empty();
+            }
+            else {
+                const activePatternResult_1 = $007CSequenceMinusOpener$007C_$007C(head(eles));
+                if (activePatternResult_1 != null) {
+                    const v_1 = activePatternResult_1;
+                    return toList(delay(() => append(singleton(singleton_1(new PreprocessorElement(2, [value_2(v_1.Value)]))), delay(() => collectSequenceElements(tail(eles))))));
+                }
+                else if ($007CYamlComment$007C_$007C(head(eles)) != null) {
+                    return toList(delay(() => append(singleton(singleton_1(head(eles))), delay(() => collectSequenceElements(tail(eles))))));
+                }
+                else {
+                    return toFail(printf("Unknown pattern for sequence elements: %A"))(eles);
+                }
+            }
+    }
+}
+
+export function isSequenceElement(e) {
+    let matchResult;
+    if (e.tag === 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 === 1) {
+                            matchResult = 0;
+                            rest0 = tail(tail(restlist));
+                            v = 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(new YAMLElement(2, [toList(delay(() => append(singleton(loopRead(cons(new PreprocessorElement(2, [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 = activePatternResult_1;
+                        }
+                        else {
+                            const activePatternResult_2 = $007CSequenceMinusOpener$007C_$007C(head(restlist));
+                            if (activePatternResult_2 != null) {
+                                if (!isEmpty(tail(restlist))) {
+                                    if (head(tail(restlist)).tag === 1) {
+                                        matchResult_1 = 1;
+                                        rest0_2 = tail(tail(restlist));
+                                        v_2 = 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(new YAMLElement(2, [toList(delay(() => append(singleton(loopRead(singleton_1(new PreprocessorElement(2, [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(new PreprocessorElement(2, [value_2(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(new YAMLElement(2, [toList(delay(() => append(singleton(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 = activePatternResult_3;
+                                }
+                                else {
+                                    const activePatternResult_4 = $007CInlineSequence$007C_$007C(head(restlist));
+                                    if (activePatternResult_4 != null) {
+                                        matchResult_2 = 1;
+                                        rest_4 = tail(restlist);
+                                        v_4 = activePatternResult_4;
+                                    }
+                                    else {
+                                        const activePatternResult_5 = $007CSequenceSquareOpener$007C_$007C(head(restlist));
+                                        if (activePatternResult_5 != null) {
+                                            if (!isEmpty(tail(restlist))) {
+                                                if (head(tail(restlist)).tag === 1) {
+                                                    if (!isEmpty(tail(tail(restlist)))) {
+                                                        const activePatternResult_6 = $007CSequenceSquareCloser$007C_$007C(head(tail(tail(restlist))));
+                                                        if (activePatternResult_6 != null) {
+                                                            matchResult_2 = 2;
+                                                            closer = activePatternResult_6;
+                                                            iList = head(tail(restlist)).fields[0];
+                                                            opener = 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(new YAMLElement(2, [toList(delay(() => append(singleton(loopRead(singleton_1(new PreprocessorElement(2, [value_2(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 = split_2(v_4.Value, [","], void 0, 1);
+                                    const current_4 = new YAMLElement(2, [toList(delay(() => map_1((value) => loopRead(singleton_1(new PreprocessorElement(2, [value.trim()])), empty()), split)))]);
+                                    restlist_mut = rest_4;
+                                    acc_mut = ((c != null) ? ofArrayWithTail([current_4, new YAMLElement(4, [value_2(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 = new YAMLElement(2, [toList(delay(() => collect((i_4) => singleton(loopRead(singleton_1((i_4.tag === 2) ? (new PreprocessorElement(2, [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 = c2, ofArrayWithTail([new YAMLElement(4, [c2_2]), current_5], acc)))) : ((c2 == null) ? ((c1_2 = c1, ofArrayWithTail([current_5, new YAMLElement(4, [c1_2])], acc))) : ((c1_1 = c1, (c2_1 = c2, ofArrayWithTail([new YAMLElement(4, [c2_1]), current_5, new YAMLElement(4, [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 = activePatternResult_7;
+                                        }
+                                        else {
+                                            const activePatternResult_8 = $007CJSONKeyOpener$007C_$007C(head(restlist));
+                                            if (activePatternResult_8 != null) {
+                                                if (!isEmpty(tail(restlist))) {
+                                                    if (head(tail(restlist)).tag === 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 = activePatternResult_9;
+                                                                iList_1 = head(tail(restlist)).fields[0];
+                                                                opener_1 = 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_2(v_5.Value, [","], void 0, 1);
+                                            const current_6 = reverse(toList(delay(() => collect((value_1) => {
+                                                const matchValue_1 = loopRead(singleton_1(new PreprocessorElement(2, [value_1.trim()])), empty());
+                                                if (matchValue_1.tag === 3) {
+                                                    return matchValue_1.fields[0];
+                                                }
+                                                else {
+                                                    throw new Error("Unexpected element in InlineJSON");
+                                                    return empty_1();
+                                                }
+                                            }, split_1))));
+                                            restlist_mut = rest_6;
+                                            acc_mut = ((c_1 != null) ? append_1(current_6, cons(new YAMLElement(4, [value_2(c_1)]), acc)) : append_1(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 = new YAMLElement(0, [YAMLContent_create_27AED5E3(opener_1.Key, unwrap(c1_3)), new YAMLElement(3, [toList(delay(() => collect((i_5) => {
+                                                const matchValue_2 = loopRead(singleton_1((i_5.tag === 2) ? (new PreprocessorElement(2, [trimEnd(i_5.fields[0], ",")])) : toFail(printf("Unexpected element in MultiLineSquareBrackets: %A"))(i_5)), empty());
+                                                if (matchValue_2.tag === 3) {
+                                                    return matchValue_2.fields[0];
+                                                }
+                                                else {
+                                                    throw new Error("Unexpected element in MultilineJSON");
+                                                    return empty_1();
+                                                }
+                                            }, iList_1)))])]);
+                                            restlist_mut = rest_7;
+                                            acc_mut = ((c2_3 == null) ? cons(current_7, acc) : ofArrayWithTail([new YAMLElement(4, [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 === 1) {
+                                                            matchResult_4 = 0;
+                                                            rest_8 = tail(tail(restlist));
+                                                            v_6 = 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(new YAMLElement(0, [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 === 1) {
+                                                                            matchResult_5 = 0;
+                                                                            rest0_4 = tail(tail(tail(restlist)));
+                                                                            v_7 = activePatternResult_11;
+                                                                            w = 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(new PreprocessorElement(2, [value_2(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 = new YAMLElement(2, [toList(delay(() => append(singleton(loopRead(objectList_2, empty())), delay(() => map_1((i_6) => loopRead(i_6, empty()), sequenceElements_4)))))]);
+                                                            restlist_mut = rest_9;
+                                                            acc_mut = cons(new YAMLElement(0, [YAMLContent_create_27AED5E3(v_7.Key, unwrap(c_3)), new YAMLElement(3, [singleton_1(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 = activePatternResult_13;
+                                                                            w_1 = 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 = new YAMLElement(2, [toList(delay(() => append(singleton(loopRead(singleton_1(new PreprocessorElement(2, [value_2(w_1.Value)])), empty())), delay(() => map_1((i_7) => loopRead(i_7, empty()), sequenceElements_5)))))]);
+                                                                    restlist_mut = rest_10;
+                                                                    acc_mut = cons(new YAMLElement(0, [YAMLContent_create_27AED5E3(v_8.Key, unwrap(c_4)), new YAMLElement(3, [singleton_1(seq_1)])]), acc);
+                                                                    continue loopRead;
+                                                                }
+                                                                default:
+                                                                    if (isEmpty(restlist)) {
+                                                                        return new YAMLElement(3, [reverse(acc)]);
+                                                                    }
+                                                                    else {
+                                                                        const activePatternResult_15 = $007CKeyValue$007C_$007C(head(restlist));
+                                                                        if (activePatternResult_15 != null) {
+                                                                            const v_9 = activePatternResult_15;
+                                                                            restlist_mut = tail(restlist);
+                                                                            acc_mut = cons(new YAMLElement(0, [YAMLContent_create_27AED5E3(v_9.Key), loopRead(singleton_1(new PreprocessorElement(2, [v_9.Value])), empty())]), acc);
+                                                                            continue loopRead;
+                                                                        }
+                                                                        else {
+                                                                            const activePatternResult_16 = $007CYamlComment$007C_$007C(head(restlist));
+                                                                            if (activePatternResult_16 != null) {
+                                                                                const v_10 = activePatternResult_16;
+                                                                                restlist_mut = tail(restlist);
+                                                                                acc_mut = cons(new YAMLElement(4, [getItemFromDict(commentDict, v_10.Comment)]), acc);
+                                                                                continue loopRead;
+                                                                            }
+                                                                            else {
+                                                                                const activePatternResult_17 = $007CYamlValue$007C_$007C(head(restlist));
+                                                                                if (activePatternResult_17 != null) {
+                                                                                    const v_11 = activePatternResult_17;
+                                                                                    restlist_mut = tail(restlist);
+                                                                                    acc_mut = cons(new YAMLElement(1, [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);
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+        }
+    };
+    return loopRead(yamlList, empty());
+}
+
+export function read(yaml) {
+    const ast = read_1(yaml);
+    const matchValue = ast.AST;
+    if (matchValue.tag === 0) {
+        return tokenize(matchValue.fields[0], ast.StringMap, ast.CommentMap);
+    }
+    else {
+        throw new Error("Not a root!");
+    }
+}
+

package/fable_modules/YAMLicious.0.0.1/Regex.fs

@@ -0,0 +1,108 @@
+module YAMLicious.Regex
+
+[<Literal>]
+let CommentPattern =
+    #if FABLE_COMPILER_PYTHON
+    "\<c f=(?P<comment>\d+)\/\>"
+    #endif
+    #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+    "<c f=(?<comment>\d+)\/>"
+    #endif
+    #if !FABLE_COMPILER
+    "\<c f=(?<comment>\d+)\/\>"
+    #endif
+
+let KeyPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^(?P<key>[^\{{\[]+):\s*({CommentPattern})?$"
+    #else
+    $"^(?<key>[^\{{\[]+):\s*({CommentPattern})?$"
+    #endif
+
+[<Literal>]
+let KeyValuePattern =
+    #if FABLE_COMPILER_PYTHON
+    "^(?P<key>[^\{{\[]+):\s+(?P<value>.*)$"
+    #else
+    "^(?<key>[^\{{\[]+):\s+(?<value>(.*))$"
+    #endif
+
+let LineCommentPattern =
+    $"^{CommentPattern}$"
+
+let ValuePattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^(?P<value>.*?)\s*?({CommentPattern})?$"
+    #else
+    $"^(?<value>.*?)\s*?({CommentPattern})?$"
+    #endif
+
+[<Literal>]
+let SequenceMinusPattern =
+    #if FABLE_COMPILER_PYTHON
+    "^-(\s+(?P<value>.*))?$"
+    #else
+    "^-(\s+(?<value>.*))?$"
+    #endif
+
+let InlineSequencePattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^\[(?P<inlineSequence>.+)\]\s*?({CommentPattern})?$"
+    #else
+    $"^\[(?<inlineSequence>.+)\]\s*?({CommentPattern})?$"
+    #endif
+
+let InlineJSONPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^\{{(?P<inlineSequence>.+)\}}\s*?({CommentPattern})?$"
+    #else
+    $"^\{{(?<inlineSequence>.+)\}}\s*?({CommentPattern})?$"
+    #endif
+
+let SequenceOpenerPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^\[\s*({CommentPattern})?$"
+    #else
+    $"^\[\s*({CommentPattern})?$"
+    #endif
+
+let SequenceCloserPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^\]\s*({CommentPattern})?$"
+    #else
+    $"^\]\s*({CommentPattern})?$"
+    #endif
+
+let JSONOpenerPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^(?P<key>[^\{{\[]+):\s+\{{\s*({CommentPattern})?$"
+    #else
+    $"^(?<key>[^\{{\[]+):\s+\{{\s*({CommentPattern})?$"
+    #endif
+
+let JSONCloserPattern =
+    #if FABLE_COMPILER_PYTHON
+    $"^\}}\s*({CommentPattern})?$"
+    #else
+    $"^\}}\s*({CommentPattern})?$"
+    #endif
+
+[<Literal>]
+let StringReplacementPattern =
+    #if FABLE_COMPILER_PYTHON
+    "\<s f=(?P<index>\d+)\/\>"
+    #endif
+    #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+    "<s f=(?<index>\d+)\/>"
+    #endif
+    #if !FABLE_COMPILER
+    "\<s f=(?<index>\d+)\/\>"
+    #endif
+
+[<Literal>]
+let SchemaNamespacePattern =
+    #if FABLE_COMPILER_PYTHON
+    "^\$(?P<key>[a-zA-Z0-9\s:]+):$"
+    #else
+    "^\$(?<key>[a-zA-Z0-9\s:]+):$"
+    #endif

package/fable_modules/YAMLicious.0.0.1/Regex.fs.js

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