@magnusopera/fscript 0.75.0

package/dist/FScript.Language/BuiltinFunctions.js

@@ -0,0 +1,2039 @@
+
+import { Span, Position } from "./Span.js";
+import { EvalException, EvalError$ } from "./Error.js";
+import { FSharpMap__Remove, iterate as iterate_1, fold as fold_1, add, FSharpMap__Add, FSharpMap__ContainsKey, FSharpMap__TryFind, empty as empty_1, FSharpMap__get_Item, forAll, FSharpMap__get_Keys, FSharpMap__get_Count, tryFind } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { builtinSchemes } from "./BuiltinSignatures.js";
+import { equals as equals_1, compare, comparePrimitives, Exception } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { endsWith, split, join, substring, replace, format, concat } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { tryParse } from "../fable_modules/fable-library-js.5.2.0/Long.js";
+import { FSharpRef } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { tryParse as tryParse_1 } from "../fable_modules/fable-library-js.5.2.0/Double.js";
+import { append, tryHead, tryFindIndex, tryFind as tryFind_1, filter, collect, choose, iterate, ofArray, map, exists, fold, forAll2, length as length_1, empty, reverse, cons, tail as tail_1, head as head_1, isEmpty } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { ExternalFunction, Value as Value_1, MapKey } from "./Value.js";
+import { compare as compare_1, op_Addition, toInt32_unchecked, fromInt32, toInt64_unchecked, equals } from "../fable_modules/fable-library-js.5.2.0/BigInt.js";
+import { ofSeq } from "../fable_modules/fable-library-js.5.2.0/Set.js";
+import { tryParse as tryParse_2 } from "../fable_modules/fable-library-js.5.2.0/Boolean.js";
+import { some, map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Option.js";
+
+const unknownSpan = new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0));
+
+function fail(message) {
+    throw new EvalException(new EvalError$(message, unknownSpan));
+}
+
+function scheme(name) {
+    const matchValue = tryFind(name, builtinSchemes);
+    if (matchValue == null) {
+        throw new Exception(concat("Missing builtin signature for \'", name, "\'"));
+    }
+    else {
+        return matchValue;
+    }
+}
+
+function tryParseInt64(text) {
+    let matchValue;
+    let outArg = 0n;
+    matchValue = [tryParse(text, 511, false, 64, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    if (matchValue[0]) {
+        return matchValue[1];
+    }
+    else {
+        return undefined;
+    }
+}
+
+function tryParseDouble(text) {
+    let matchValue;
+    let outArg = 0;
+    matchValue = [tryParse_1(text, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    if (matchValue[0]) {
+        return matchValue[1];
+    }
+    else {
+        return undefined;
+    }
+}
+
+function expectString(functionName, args) {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return value;
+        default:
+            return fail(`${functionName} expects (string)`);
+    }
+}
+
+function expectInt(functionName, args) {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 1) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return value;
+        default:
+            return fail(`${functionName} expects (int)`);
+    }
+}
+
+function expectBool(functionName, args) {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 3) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return value;
+        default:
+            return fail(`${functionName} expects (bool)`);
+    }
+}
+
+function expectMap(functionName, args) {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 8) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return value;
+        default:
+            return fail(`${functionName} expects (map)`);
+    }
+}
+
+function expectList(functionName, args) {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 5) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return value;
+        default:
+            return fail(`${functionName} expects (list)`);
+    }
+}
+
+function asStringKey(functionName, value) {
+    if (value.tag === 4) {
+        return new MapKey(0, [value.fields[0]]);
+    }
+    else {
+        return fail(`${functionName} expects string key`);
+    }
+}
+
+function asStringList(functionName, values) {
+    const loop = (remaining_mut, acc_mut) => {
+        loop:
+        while (true) {
+            const remaining = remaining_mut, acc = acc_mut;
+            if (!isEmpty(remaining)) {
+                if (head_1(remaining).tag === 4) {
+                    remaining_mut = tail_1(remaining);
+                    acc_mut = cons(head_1(remaining).fields[0], acc);
+                    continue loop;
+                }
+                else {
+                    return fail(`${functionName} expects (string, string list)`);
+                }
+            }
+            else {
+                return reverse(acc);
+            }
+            break;
+        }
+    };
+    return loop(values, empty());
+}
+
+function mapKeyToValue(key) {
+    if (key.tag === 1) {
+        return new Value_1(1, [key.fields[0]]);
+    }
+    else {
+        return new Value_1(4, [key.fields[0]]);
+    }
+}
+
+function valueEquals(a_mut, b_mut) {
+    valueEquals:
+    while (true) {
+        const a = a_mut, b = b_mut;
+        let matchResult, x, y, x_1, y_1, x_2, y_2, x_3, y_3, xs, ys, xs_1, ys_1, xf, yf, xf_1, yf_1, x_8, y_8, cx, cy, px, py, tx, ty, tx_1, ty_1;
+        switch (a.tag) {
+            case 0: {
+                if (b.tag === 0) {
+                    matchResult = 0;
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 1: {
+                if (b.tag === 1) {
+                    matchResult = 1;
+                    x = a.fields[0];
+                    y = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 2: {
+                if (b.tag === 2) {
+                    matchResult = 2;
+                    x_1 = a.fields[0];
+                    y_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 3: {
+                if (b.tag === 3) {
+                    matchResult = 3;
+                    x_2 = a.fields[0];
+                    y_2 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 4: {
+                if (b.tag === 4) {
+                    matchResult = 4;
+                    x_3 = a.fields[0];
+                    y_3 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 5: {
+                if (b.tag === 5) {
+                    matchResult = 5;
+                    xs = a.fields[0];
+                    ys = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 6: {
+                if (b.tag === 6) {
+                    matchResult = 6;
+                    xs_1 = a.fields[0];
+                    ys_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 7: {
+                if (b.tag === 7) {
+                    matchResult = 7;
+                    xf = a.fields[0];
+                    yf = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 8: {
+                if (b.tag === 8) {
+                    matchResult = 8;
+                    xf_1 = a.fields[0];
+                    yf_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 9: {
+                if (a.fields[0] != null) {
+                    if (b.tag === 9) {
+                        if (b.fields[0] != null) {
+                            matchResult = 10;
+                            x_8 = a.fields[0];
+                            y_8 = b.fields[0];
+                        }
+                        else {
+                            matchResult = 13;
+                        }
+                    }
+                    else {
+                        matchResult = 13;
+                    }
+                }
+                else if (b.tag === 9) {
+                    if (b.fields[0] == null) {
+                        matchResult = 9;
+                    }
+                    else {
+                        matchResult = 13;
+                    }
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 10: {
+                if (b.tag === 10) {
+                    matchResult = 11;
+                    cx = a.fields[1];
+                    cy = b.fields[1];
+                    px = a.fields[2];
+                    py = b.fields[2];
+                    tx = a.fields[0];
+                    ty = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            case 12: {
+                if (b.tag === 12) {
+                    matchResult = 12;
+                    tx_1 = a.fields[0];
+                    ty_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 13;
+                }
+                break;
+            }
+            default:
+                matchResult = 13;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            case 1:
+                return equals(x, y);
+            case 2:
+                return x_1 === y_1;
+            case 3:
+                return x_2 === y_2;
+            case 4:
+                return x_3 === y_3;
+            case 5:
+                if (length_1(xs) === length_1(ys)) {
+                    return forAll2(valueEquals, xs, ys);
+                }
+                else {
+                    return false;
+                }
+            case 6:
+                if (length_1(xs_1) === length_1(ys_1)) {
+                    return forAll2(valueEquals, xs_1, ys_1);
+                }
+                else {
+                    return false;
+                }
+            case 7:
+                if ((FSharpMap__get_Count(xf) === FSharpMap__get_Count(yf)) && ofSeq(FSharpMap__get_Keys(xf), {
+                    Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                }).Equals(ofSeq(FSharpMap__get_Keys(yf), {
+                    Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+                }))) {
+                    return forAll((k, xv) => valueEquals(xv, FSharpMap__get_Item(yf, k)), xf);
+                }
+                else {
+                    return false;
+                }
+            case 8:
+                if ((FSharpMap__get_Count(xf_1) === FSharpMap__get_Count(yf_1)) && ofSeq(FSharpMap__get_Keys(xf_1), {
+                    Compare: (x_6, y_6) => (compare(x_6, y_6) | 0),
+                }).Equals(ofSeq(FSharpMap__get_Keys(yf_1), {
+                    Compare: (x_7, y_7) => (compare(x_7, y_7) | 0),
+                }))) {
+                    return forAll((k_1, xv_1) => valueEquals(xv_1, FSharpMap__get_Item(yf_1, k_1)), xf_1);
+                }
+                else {
+                    return false;
+                }
+            case 9:
+                return true;
+            case 10: {
+                a_mut = x_8;
+                b_mut = y_8;
+                continue valueEquals;
+            }
+            case 11:
+                if ((tx === ty) && (cx === cy)) {
+                    let matchResult_1, xv_2, yv;
+                    if (px != null) {
+                        if (py != null) {
+                            matchResult_1 = 1;
+                            xv_2 = px;
+                            yv = py;
+                        }
+                        else {
+                            matchResult_1 = 2;
+                        }
+                    }
+                    else if (py == null) {
+                        matchResult_1 = 0;
+                    }
+                    else {
+                        matchResult_1 = 2;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return true;
+                        case 1: {
+                            a_mut = xv_2;
+                            b_mut = yv;
+                            continue valueEquals;
+                        }
+                        default:
+                            return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            case 12:
+                return equals_1(tx_1, ty_1);
+            default:
+                return false;
+        }
+        break;
+    }
+}
+
+function distinctValues(values) {
+    return reverse(fold((acc, value) => {
+        if (exists((existing) => valueEquals(existing, value), acc)) {
+            return acc;
+        }
+        else {
+            return cons(value, acc);
+        }
+    }, empty(), values));
+}
+
+const builtinIgnore = new ExternalFunction("ignore", scheme("ignore"), (_arg, _arg_1) => (new Value_1(0, [])), 1);
+
+const builtinIntTryParse = new ExternalFunction("Int.tryParse", scheme("Int.tryParse"), (_arg, args) => {
+    const matchValue = tryParseInt64(expectString("Int.tryParse", args));
+    return (matchValue == null) ? (new Value_1(9, [undefined])) : (new Value_1(9, [new Value_1(1, [matchValue])]));
+}, 1);
+
+const builtinFloatTryParse = new ExternalFunction("Float.tryParse", scheme("Float.tryParse"), (_arg, args) => {
+    const matchValue = tryParseDouble(expectString("Float.tryParse", args));
+    return (matchValue == null) ? (new Value_1(9, [undefined])) : (new Value_1(9, [new Value_1(2, [matchValue])]));
+}, 1);
+
+const builtinBoolTryParse = new ExternalFunction("Bool.tryParse", scheme("Bool.tryParse"), (_arg, args) => {
+    let matchValue;
+    let outArg = false;
+    matchValue = [tryParse_2(expectString("Bool.tryParse", args), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    return matchValue[0] ? (new Value_1(9, [new Value_1(3, [matchValue[1]])])) : (new Value_1(9, [undefined]));
+}, 1);
+
+const builtinIntToString = new ExternalFunction("Int.toString", scheme("Int.toString"), (_arg, args) => (new Value_1(4, [String(expectInt("Int.toString", args))])), 1);
+
+const builtinFloatToString = new ExternalFunction("Float.toString", scheme("Float.toString"), (_arg, args) => {
+    let matchResult, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 2) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                value = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(4, [format('{0:' + "G17" + '}', value)]);
+        default:
+            return fail("Float.toString expects (float)");
+    }
+}, 1);
+
+const builtinBoolToString = new ExternalFunction("Bool.toString", scheme("Bool.toString"), (_arg, args) => (new Value_1(4, [expectBool("Bool.toString", args) ? "true" : "false"])), 1);
+
+const builtinStringReplace = new ExternalFunction("String.replace", scheme("String.replace"), (_arg, args) => {
+    let matchResult, newValue, oldValue, source;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 4) {
+                    if (!isEmpty(tail_1(tail_1(args)))) {
+                        if (head_1(tail_1(tail_1(args))).tag === 4) {
+                            if (isEmpty(tail_1(tail_1(tail_1(args))))) {
+                                matchResult = 0;
+                                newValue = head_1(tail_1(args)).fields[0];
+                                oldValue = head_1(args).fields[0];
+                                source = head_1(tail_1(tail_1(args))).fields[0];
+                            }
+                            else {
+                                matchResult = 1;
+                            }
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(4, [replace(source, oldValue, newValue)]);
+        default:
+            return fail("String.replace expects (string, string, string)");
+    }
+}, 3);
+
+const builtinStringIndexOf = new ExternalFunction("String.indexOf", scheme("String.indexOf"), (_arg, args) => {
+    let matchResult, source, value;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 4) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        source = head_1(tail_1(args)).fields[0];
+                        value = head_1(args).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const index = source.indexOf(value) | 0;
+            return (index >= 0) ? (new Value_1(9, [new Value_1(1, [toInt64_unchecked(fromInt32(index))])])) : (new Value_1(9, [undefined]));
+        }
+        default:
+            return fail("String.indexOf expects (string, string)");
+    }
+}, 2);
+
+const builtinStringToLower = new ExternalFunction("String.toLower", scheme("String.toLower"), (_arg, args) => {
+    const source = expectString("String.toLower", args);
+    return new Value_1(4, [source.toLowerCase()]);
+}, 1);
+
+const builtinStringToUpper = new ExternalFunction("String.toUpper", scheme("String.toUpper"), (_arg, args) => {
+    const source = expectString("String.toUpper", args);
+    return new Value_1(4, [source.toUpperCase()]);
+}, 1);
+
+const builtinStringSubstring = new ExternalFunction("String.substring", scheme("String.substring"), (_arg, args) => {
+    let matchResult, length, source, start;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 1) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 1) {
+                    if (!isEmpty(tail_1(tail_1(args)))) {
+                        if (head_1(tail_1(tail_1(args))).tag === 4) {
+                            if (isEmpty(tail_1(tail_1(tail_1(args))))) {
+                                matchResult = 0;
+                                length = head_1(tail_1(args)).fields[0];
+                                source = head_1(tail_1(tail_1(args))).fields[0];
+                                start = head_1(args).fields[0];
+                            }
+                            else {
+                                matchResult = 1;
+                            }
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const startIndex = ~~toInt32_unchecked(start) | 0;
+            const sliceLength = ~~toInt32_unchecked(length) | 0;
+            return ((((startIndex < 0) ? true : (sliceLength < 0)) ? true : (startIndex > source.length)) ? true : ((startIndex + sliceLength) > source.length)) ? (new Value_1(9, [undefined])) : (new Value_1(9, [new Value_1(4, [substring(source, startIndex, sliceLength)])]));
+        }
+        default:
+            return fail("String.substring expects (string, int, int)");
+    }
+}, 3);
+
+const builtinStringConcat = new ExternalFunction("String.concat", scheme("String.concat"), (_arg, args) => {
+    let matchResult, separator, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 5) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        separator = head_1(args).fields[0];
+                        values = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(4, [join(separator, asStringList("String.concat", values))]);
+        default:
+            return fail("String.concat expects (string, string list)");
+    }
+}, 2);
+
+const builtinStringSplit = new ExternalFunction("String.split", scheme("String.split"), (_arg, args) => {
+    let matchResult, separator, source;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 4) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        separator = head_1(args).fields[0];
+                        source = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [map((Item) => (new Value_1(4, [Item])), ofArray(split(source, [separator], undefined, 0)))]);
+        default:
+            return fail("String.split expects (string, string)");
+    }
+}, 2);
+
+const builtinStringEndsWith = new ExternalFunction("String.endsWith", scheme("String.endsWith"), (_arg, args) => {
+    let matchResult, source, suffix;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 4) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        source = head_1(tail_1(args)).fields[0];
+                        suffix = head_1(args).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [endsWith(source, suffix, 4)]);
+        default:
+            return fail("String.endsWith expects (string, string)");
+    }
+}, 2);
+
+const builtinListEmpty = new ExternalFunction("List.empty", scheme("List.empty"), (_arg, _arg_1) => (new Value_1(5, [empty()])), 0);
+
+const builtinListMap = new ExternalFunction("List.map", scheme("List.map"), (ctx, args) => {
+    let matchResult, mapper, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    mapper = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [map((value) => ctx.Apply(mapper, value), values)]);
+        default:
+            return fail("List.map expects (mapper, values)");
+    }
+}, 2);
+
+const builtinListIter = new ExternalFunction("List.iter", scheme("List.iter"), (ctx, args) => {
+    let matchResult, iterator, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    iterator = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            iterate((value) => {
+                ctx.Apply(iterator, value);
+            }, values);
+            return new Value_1(0, []);
+        }
+        default:
+            return fail("List.iter expects (iterator, values)");
+    }
+}, 2);
+
+const builtinListChoose = new ExternalFunction("List.choose", scheme("List.choose"), (ctx, args) => {
+    let matchResult, chooser, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    chooser = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [choose((value) => {
+                const matchValue = ctx.Apply(chooser, value);
+                if (matchValue.tag === 9) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.choose chooser must return option");
+                }
+            }, values)]);
+        default:
+            return fail("List.choose expects (chooser, values)");
+    }
+}, 2);
+
+const builtinListCollect = new ExternalFunction("List.collect", scheme("List.collect"), (ctx, args) => {
+    let matchResult, collector, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    collector = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [collect((value) => {
+                const matchValue = ctx.Apply(collector, value);
+                if (matchValue.tag === 5) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.collect collector must return list");
+                }
+            }, values)]);
+        default:
+            return fail("List.collect expects (collector, values)");
+    }
+}, 2);
+
+const builtinListExists = new ExternalFunction("List.exists", scheme("List.exists"), (ctx, args) => {
+    let matchResult, predicate, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    predicate = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [exists((value) => {
+                const matchValue = ctx.Apply(predicate, value);
+                if (matchValue.tag === 3) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.exists predicate must return bool");
+                }
+            }, values)]);
+        default:
+            return fail("List.exists expects (predicate, values)");
+    }
+}, 2);
+
+const builtinListContains = new ExternalFunction("List.contains", scheme("List.contains"), (_arg, args) => {
+    let matchResult, needle, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    needle = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [exists((value) => {
+                let matchResult_1, x, y, x_1, y_1, x_2, y_2, x_3, y_3;
+                switch (value.tag) {
+                    case 0: {
+                        if (needle.tag === 0) {
+                            matchResult_1 = 0;
+                        }
+                        else {
+                            matchResult_1 = 5;
+                        }
+                        break;
+                    }
+                    case 1: {
+                        if (needle.tag === 1) {
+                            matchResult_1 = 1;
+                            x = value.fields[0];
+                            y = needle.fields[0];
+                        }
+                        else {
+                            matchResult_1 = 5;
+                        }
+                        break;
+                    }
+                    case 2: {
+                        if (needle.tag === 2) {
+                            matchResult_1 = 2;
+                            x_1 = value.fields[0];
+                            y_1 = needle.fields[0];
+                        }
+                        else {
+                            matchResult_1 = 5;
+                        }
+                        break;
+                    }
+                    case 3: {
+                        if (needle.tag === 3) {
+                            matchResult_1 = 3;
+                            x_2 = value.fields[0];
+                            y_2 = needle.fields[0];
+                        }
+                        else {
+                            matchResult_1 = 5;
+                        }
+                        break;
+                    }
+                    case 4: {
+                        if (needle.tag === 4) {
+                            matchResult_1 = 4;
+                            x_3 = value.fields[0];
+                            y_3 = needle.fields[0];
+                        }
+                        else {
+                            matchResult_1 = 5;
+                        }
+                        break;
+                    }
+                    default:
+                        matchResult_1 = 5;
+                }
+                switch (matchResult_1) {
+                    case 0:
+                        return true;
+                    case 1:
+                        return equals(x, y);
+                    case 2:
+                        return x_1 === y_1;
+                    case 3:
+                        return x_2 === y_2;
+                    case 4:
+                        return x_3 === y_3;
+                    default:
+                        return false;
+                }
+            }, values)]);
+        default:
+            return fail("List.contains expects (needle, values)");
+    }
+}, 2);
+
+const builtinListRev = new ExternalFunction("List.rev", scheme("List.rev"), (_arg, args) => (new Value_1(5, [reverse(expectList("List.rev", args))])), 1);
+
+const builtinListDistinct = new ExternalFunction("List.distinct", scheme("List.distinct"), (_arg, args) => (new Value_1(5, [distinctValues(expectList("List.distinct", args))])), 1);
+
+const builtinListFold = new ExternalFunction("List.fold", scheme("List.fold"), (ctx, args) => {
+    let matchResult, folder, state, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (!isEmpty(tail_1(tail_1(args)))) {
+                if (head_1(tail_1(tail_1(args))).tag === 5) {
+                    if (isEmpty(tail_1(tail_1(tail_1(args))))) {
+                        matchResult = 0;
+                        folder = head_1(args);
+                        state = head_1(tail_1(args));
+                        values = head_1(tail_1(tail_1(args))).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return fold((acc, value) => ctx.Apply(ctx.Apply(folder, acc), value), state, values);
+        default:
+            return fail("List.fold expects (folder, state, values)");
+    }
+}, 3);
+
+const builtinListFilter = new ExternalFunction("List.filter", scheme("List.filter"), (ctx, args) => {
+    let matchResult, predicate, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    predicate = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [filter((value) => {
+                const matchValue = ctx.Apply(predicate, value);
+                if (matchValue.tag === 3) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.filter predicate must return bool");
+                }
+            }, values)]);
+        default:
+            return fail("List.filter expects (predicate, values)");
+    }
+}, 2);
+
+const builtinListLength = new ExternalFunction("List.length", scheme("List.length"), (_arg, args) => (new Value_1(1, [toInt64_unchecked(fromInt32(length_1(expectList("List.length", args))))])), 1);
+
+const builtinListTryFind = new ExternalFunction("List.tryFind", scheme("List.tryFind"), (ctx, args) => {
+    let matchResult, predicate, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    predicate = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(9, [tryFind_1((value) => {
+                const matchValue = ctx.Apply(predicate, value);
+                if (matchValue.tag === 3) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.tryFind predicate must return bool");
+                }
+            }, values)]);
+        default:
+            return fail("List.tryFind expects (predicate, values)");
+    }
+}, 2);
+
+const builtinListTryGet = new ExternalFunction("List.tryGet", scheme("List.tryGet"), (ctx, args) => {
+    let matchResult, predicate, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 5) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    predicate = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(9, [map_1((arg) => (new Value_1(1, [toInt64_unchecked(fromInt32(arg))])), tryFindIndex((value) => {
+                const matchValue = ctx.Apply(predicate, value);
+                if (matchValue.tag === 3) {
+                    return matchValue.fields[0];
+                }
+                else {
+                    return fail("List.tryGet predicate must return bool");
+                }
+            }, values))]);
+        default:
+            return fail("List.tryGet expects (predicate, values)");
+    }
+}, 2);
+
+const builtinListTryItem = new ExternalFunction("List.tryItem", scheme("List.tryItem"), (_arg, args) => {
+    let matchResult, index, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 1) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 5) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        index = head_1(args).fields[0];
+                        values = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            const loop = (remaining_mut, current_mut) => {
+                loop:
+                while (true) {
+                    const remaining = remaining_mut, current = current_mut;
+                    if (!isEmpty(remaining)) {
+                        if (equals(current, index)) {
+                            return some(head_1(remaining));
+                        }
+                        else {
+                            remaining_mut = tail_1(remaining);
+                            current_mut = toInt64_unchecked(op_Addition(current, 1n));
+                            continue loop;
+                        }
+                    }
+                    else {
+                        return undefined;
+                    }
+                    break;
+                }
+            };
+            return (compare_1(index, 0n) < 0) ? (new Value_1(9, [undefined])) : (new Value_1(9, [loop(values, 0n)]));
+        }
+        default:
+            return fail("List.tryItem expects (index, values)");
+    }
+}, 2);
+
+const builtinListTryHead = new ExternalFunction("List.tryHead", scheme("List.tryHead"), (_arg, args) => (new Value_1(9, [tryHead(expectList("List.tryHead", args))])), 1);
+
+const builtinListTail = new ExternalFunction("List.tail", scheme("List.tail"), (_arg, args) => {
+    const matchValue = expectList("List.tail", args);
+    return !isEmpty(matchValue) ? (new Value_1(5, [tail_1(matchValue)])) : fail("List.tail expects a non-empty list");
+}, 1);
+
+const builtinListAppend = new ExternalFunction("List.append", scheme("List.append"), (_arg, args) => {
+    let matchResult, left, right;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 5) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 5) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        left = head_1(args).fields[0];
+                        right = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(5, [append(left, right)]);
+        default:
+            return fail("List.append expects (left, right)");
+    }
+}, 2);
+
+const builtinOptionDefaultValue = new ExternalFunction("Option.defaultValue", scheme("Option.defaultValue"), (_arg, args) => {
+    let matchResult, current, fallback, fallback_1;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 9) {
+                if (head_1(tail_1(args)).fields[0] == null) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 1;
+                        fallback_1 = head_1(args);
+                    }
+                    else {
+                        matchResult = 2;
+                    }
+                }
+                else if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    current = head_1(tail_1(args)).fields[0];
+                    fallback = head_1(args);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return current;
+        case 1:
+            return fallback_1;
+        default:
+            return fail("Option.defaultValue expects (fallback, value)");
+    }
+}, 2);
+
+const builtinOptionDefaultWith = new ExternalFunction("Option.defaultWith", scheme("Option.defaultWith"), (ctx, args) => {
+    let matchResult, current, fallback, fallback_1;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 9) {
+                if (head_1(tail_1(args)).fields[0] == null) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 1;
+                        fallback_1 = head_1(args);
+                    }
+                    else {
+                        matchResult = 2;
+                    }
+                }
+                else if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    current = head_1(tail_1(args)).fields[0];
+                    fallback = head_1(args);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return current;
+        case 1:
+            return ctx.Apply(fallback_1, new Value_1(0, []));
+        default:
+            return fail("Option.defaultWith expects (fallback, value)");
+    }
+}, 2);
+
+const builtinOptionIsNone = new ExternalFunction("Option.isNone", scheme("Option.isNone"), (_arg, args) => {
+    let matchResult;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 9) {
+            if (head_1(args).fields[0] != null) {
+                if (isEmpty(tail_1(args))) {
+                    matchResult = 1;
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [true]);
+        case 1:
+            return new Value_1(3, [false]);
+        default:
+            return fail("Option.isNone expects (value)");
+    }
+}, 1);
+
+const builtinOptionIsSome = new ExternalFunction("Option.isSome", scheme("Option.isSome"), (_arg, args) => {
+    let matchResult;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 9) {
+            if (head_1(args).fields[0] != null) {
+                if (isEmpty(tail_1(args))) {
+                    matchResult = 1;
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [false]);
+        case 1:
+            return new Value_1(3, [true]);
+        default:
+            return fail("Option.isSome expects (value)");
+    }
+}, 1);
+
+const builtinOptionMap = new ExternalFunction("Option.map", scheme("Option.map"), (ctx, args) => {
+    let matchResult, current, mapper;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 9) {
+                if (head_1(tail_1(args)).fields[0] == null) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 1;
+                    }
+                    else {
+                        matchResult = 2;
+                    }
+                }
+                else if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    current = head_1(tail_1(args)).fields[0];
+                    mapper = head_1(args);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(9, [ctx.Apply(mapper, current)]);
+        case 1:
+            return new Value_1(9, [undefined]);
+        default:
+            return fail("Option.map expects (mapper, value)");
+    }
+}, 2);
+
+const builtinMapEmpty = new ExternalFunction("Map.empty", scheme("Map.empty"), (_arg, _arg_1) => (new Value_1(8, [empty_1({
+    Compare: (x, y) => (compare(x, y) | 0),
+})])), 0);
+
+const builtinMapTryGet = new ExternalFunction("Map.tryGet", scheme("Map.tryGet"), (_arg, args) => {
+    let matchResult, key, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 8) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        key = head_1(args).fields[0];
+                        values = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(9, [FSharpMap__TryFind(values, new MapKey(0, [key]))]);
+        default:
+            return fail("Map.tryGet expects (key, values)");
+    }
+}, 2);
+
+const builtinMapContainsKey = new ExternalFunction("Map.containsKey", scheme("Map.containsKey"), (_arg, args) => {
+    let matchResult, key, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 8) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        key = head_1(args).fields[0];
+                        values = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(3, [FSharpMap__ContainsKey(values, new MapKey(0, [key]))]);
+        default:
+            return fail("Map.containsKey expects (key, values)");
+    }
+}, 2);
+
+const builtinMapAdd = new ExternalFunction("Map.add", scheme("Map.add"), (_arg, args) => {
+    let matchResult, key, value, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (!isEmpty(tail_1(tail_1(args)))) {
+                    if (head_1(tail_1(tail_1(args))).tag === 8) {
+                        if (isEmpty(tail_1(tail_1(tail_1(args))))) {
+                            matchResult = 0;
+                            key = head_1(args).fields[0];
+                            value = head_1(tail_1(args));
+                            values = head_1(tail_1(tail_1(args))).fields[0];
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [FSharpMap__Add(values, new MapKey(0, [key]), value)]);
+        default:
+            return fail("Map.add expects (key, value, values)");
+    }
+}, 3);
+
+const builtinMapOfList = new ExternalFunction("Map.ofList", scheme("Map.ofList"), (_arg, args) => {
+    let matchResult, pairs;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 5) {
+            if (isEmpty(tail_1(args))) {
+                matchResult = 0;
+                pairs = head_1(args).fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [fold((state, entry) => {
+                let matchResult_1, key, value;
+                if (entry.tag === 6) {
+                    if (!isEmpty(entry.fields[0])) {
+                        if (head_1(entry.fields[0]).tag === 4) {
+                            if (!isEmpty(tail_1(entry.fields[0]))) {
+                                if (isEmpty(tail_1(tail_1(entry.fields[0])))) {
+                                    matchResult_1 = 0;
+                                    key = head_1(entry.fields[0]).fields[0];
+                                    value = head_1(tail_1(entry.fields[0]));
+                                }
+                                else {
+                                    matchResult_1 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+                switch (matchResult_1) {
+                    case 0:
+                        return add(new MapKey(0, [key]), value, state);
+                    default:
+                        return fail("Map.ofList expects [(string * value)]");
+                }
+            }, empty_1({
+                Compare: (x, y) => (compare(x, y) | 0),
+            }), pairs)]);
+        default:
+            return fail("Map.ofList expects (pairs)");
+    }
+}, 1);
+
+const builtinMapFold = new ExternalFunction("Map.fold", scheme("Map.fold"), (ctx, args) => {
+    let matchResult, folder, state, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (!isEmpty(tail_1(tail_1(args)))) {
+                if (head_1(tail_1(tail_1(args))).tag === 8) {
+                    if (isEmpty(tail_1(tail_1(tail_1(args))))) {
+                        matchResult = 0;
+                        folder = head_1(args);
+                        state = head_1(tail_1(args));
+                        values = head_1(tail_1(tail_1(args))).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return fold_1((acc, key, value) => ctx.Apply(ctx.Apply(ctx.Apply(folder, acc), mapKeyToValue(key)), value), state, values);
+        default:
+            return fail("Map.fold expects (folder, state, values)");
+    }
+}, 3);
+
+const builtinMapCount = new ExternalFunction("Map.count", scheme("Map.count"), (_arg, args) => (new Value_1(1, [toInt64_unchecked(fromInt32(FSharpMap__get_Count(expectMap("Map.count", args))))])), 1);
+
+const builtinMapFilter = new ExternalFunction("Map.filter", scheme("Map.filter"), (ctx, args) => {
+    let matchResult, predicate, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 8) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    predicate = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [fold_1((acc, key, value) => {
+                const matchValue = ctx.Apply(ctx.Apply(predicate, mapKeyToValue(key)), value);
+                if (matchValue.tag === 3) {
+                    if (matchValue.fields[0]) {
+                        return add(key, value, acc);
+                    }
+                    else {
+                        return acc;
+                    }
+                }
+                else {
+                    return fail("Map.filter predicate must return bool");
+                }
+            }, empty_1({
+                Compare: (x, y) => (compare(x, y) | 0),
+            }), values)]);
+        default:
+            return fail("Map.filter expects (predicate, values)");
+    }
+}, 2);
+
+const builtinMapChoose = new ExternalFunction("Map.choose", scheme("Map.choose"), (ctx, args) => {
+    let matchResult, chooser, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 8) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    chooser = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [fold_1((acc, key, value) => {
+                const matchValue = ctx.Apply(ctx.Apply(chooser, mapKeyToValue(key)), value);
+                if (matchValue.tag === 9) {
+                    if (matchValue.fields[0] == null) {
+                        return acc;
+                    }
+                    else {
+                        const chosen = matchValue.fields[0];
+                        return add(key, chosen, acc);
+                    }
+                }
+                else {
+                    return fail("Map.choose chooser must return option");
+                }
+            }, empty_1({
+                Compare: (x, y) => (compare(x, y) | 0),
+            }), values)]);
+        default:
+            return fail("Map.choose expects (chooser, values)");
+    }
+}, 2);
+
+const builtinMapMap = new ExternalFunction("Map.map", scheme("Map.map"), (ctx, args) => {
+    let matchResult, mapper, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 8) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    mapper = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [fold_1((acc, key, value) => add(key, ctx.Apply(mapper, value), acc), empty_1({
+                Compare: (x, y) => (compare(x, y) | 0),
+            }), values)]);
+        default:
+            return fail("Map.map expects (mapper, values)");
+    }
+}, 2);
+
+const builtinMapIter = new ExternalFunction("Map.iter", scheme("Map.iter"), (ctx, args) => {
+    let matchResult, iterator, values;
+    if (!isEmpty(args)) {
+        if (!isEmpty(tail_1(args))) {
+            if (head_1(tail_1(args)).tag === 8) {
+                if (isEmpty(tail_1(tail_1(args)))) {
+                    matchResult = 0;
+                    iterator = head_1(args);
+                    values = head_1(tail_1(args)).fields[0];
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            iterate_1((key, value) => {
+                ctx.Apply(ctx.Apply(iterator, mapKeyToValue(key)), value);
+            }, values);
+            return new Value_1(0, []);
+        }
+        default:
+            return fail("Map.iter expects (iterator, values)");
+    }
+}, 2);
+
+const builtinMapRemove = new ExternalFunction("Map.remove", scheme("Map.remove"), (_arg, args) => {
+    let matchResult, key, values;
+    if (!isEmpty(args)) {
+        if (head_1(args).tag === 4) {
+            if (!isEmpty(tail_1(args))) {
+                if (head_1(tail_1(args)).tag === 8) {
+                    if (isEmpty(tail_1(tail_1(args)))) {
+                        matchResult = 0;
+                        key = head_1(args).fields[0];
+                        values = head_1(tail_1(args)).fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new Value_1(8, [FSharpMap__Remove(values, new MapKey(0, [key]))]);
+        default:
+            return fail("Map.remove expects (key, values)");
+    }
+}, 2);
+
+export const builtinExterns = ofArray([builtinIgnore, builtinIntTryParse, builtinFloatTryParse, builtinBoolTryParse, builtinIntToString, builtinFloatToString, builtinBoolToString, builtinStringReplace, builtinStringIndexOf, builtinStringToLower, builtinStringToUpper, builtinStringSubstring, builtinStringConcat, builtinStringSplit, builtinStringEndsWith, builtinListEmpty, builtinListMap, builtinListIter, builtinListChoose, builtinListCollect, builtinListExists, builtinListContains, builtinListRev, builtinListDistinct, builtinListFold, builtinListFilter, builtinListLength, builtinListTryFind, builtinListTryGet, builtinListTryItem, builtinListTryHead, builtinListTail, builtinListAppend, builtinOptionDefaultValue, builtinOptionDefaultWith, builtinOptionIsNone, builtinOptionIsSome, builtinOptionMap, builtinMapEmpty, builtinMapTryGet, builtinMapContainsKey, builtinMapAdd, builtinMapOfList, builtinMapFold, builtinMapCount, builtinMapFilter, builtinMapChoose, builtinMapMap, builtinMapIter, builtinMapRemove]);
+