@magnusopera/fscript 0.75.0

package/dist/FScript.Language/IncludeResolver.js

@@ -0,0 +1,806 @@
+
+import { printf, toText, isNullOrWhiteSpace, concat, endsWith, substring, split, join, trimEnd, startsWith, replace, isNullOrEmpty, compare } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { exists, choose, collect, append, map, ofArray, fold as fold_1, singleton, empty, tail as tail_2, cons, head as head_1, isEmpty, reverse } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { fold } from "../fable_modules/fable-library-js.5.2.0/Array.js";
+import { ParseException, ParseError } from "./Error.js";
+import { isLetterOrDigit, isLetter } from "../fable_modules/fable-library-js.5.2.0/Char.js";
+import { toList as toList_1, fold as fold_2, forAll } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { union, toList, ofList, FSharpSet__Contains, empty as empty_1, add } from "../fable_modules/fable-library-js.5.2.0/Set.js";
+import { curry4, defaultOf, disposeSafe, getEnumerator, Exception, curry2, comparePrimitives } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { empty as empty_2, add as add_1, FSharpMap__ContainsKey, FSharpMap__get_Item } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { TypeDef, Stmt, InterpolatedPart, MapEntry, Param, Expr, Pattern, TypeRef } from "./Ast.js";
+import { map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Option.js";
+import { parseProgramWithSourceName } from "./Parser.js";
+import { FSharpRef } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { Span, Position } from "./Span.js";
+import { addToSet, tryGetValue } from "../fable_modules/fable-library-js.5.2.0/MapUtil.js";
+
+const pathComparison = 4;
+
+function pathsEqual(left, right) {
+    return compare(left, right, pathComparison) === 0;
+}
+
+function makeStringDictionary() {
+    return new Map([]);
+}
+
+function makeStringHashSet() {
+    return new Set([]);
+}
+
+function normalizeSeparators(path) {
+    if (isNullOrEmpty(path)) {
+        return "";
+    }
+    else {
+        return replace(path, "\\", "/");
+    }
+}
+
+function isPathRooted(path) {
+    return startsWith(normalizeSeparators(path), "/", 4);
+}
+
+function trimTrailingDirectorySeparators(path) {
+    const normalized = normalizeSeparators(path);
+    if (isNullOrEmpty(normalized) ? true : (normalized === "/")) {
+        return normalized;
+    }
+    else {
+        return trimEnd(normalized, "/");
+    }
+}
+
+function normalizePath(path) {
+    const normalized = normalizeSeparators(path);
+    const isRooted = startsWith(normalized, "/", 4);
+    const body = join("/", reverse(fold((acc, part) => {
+        switch (part) {
+            case ".":
+                return acc;
+            case "..":
+                if (!isEmpty(acc)) {
+                    if (head_1(acc) === "..") {
+                        return cons(part, acc);
+                    }
+                    else {
+                        return tail_2(acc);
+                    }
+                }
+                else if (isRooted) {
+                    return empty();
+                }
+                else {
+                    return singleton("..");
+                }
+            default:
+                return cons(part, acc);
+        }
+    }, empty(), split(normalized, ["/"], undefined, 1))));
+    if (isRooted) {
+        if (isNullOrEmpty(body)) {
+            return "/";
+        }
+        else {
+            return "/" + body;
+        }
+    }
+    else if (isNullOrEmpty(body)) {
+        return ".";
+    }
+    else {
+        return body;
+    }
+}
+
+function normalizeFilePath(path) {
+    return normalizePath(path);
+}
+
+function getDirectoryName(path) {
+    const normalized = trimTrailingDirectorySeparators(path);
+    if (isNullOrEmpty(normalized) ? true : (normalized === "/")) {
+        return "";
+    }
+    else {
+        const matchValue = normalized.lastIndexOf("/") | 0;
+        switch (matchValue) {
+            case -1:
+                return "";
+            case 0:
+                return "/";
+            default:
+                return substring(normalized, 0, matchValue);
+        }
+    }
+}
+
+function combinePath(directory, path) {
+    if (isNullOrEmpty(directory)) {
+        return path;
+    }
+    else if (isPathRooted(path)) {
+        return path;
+    }
+    else if (endsWith(directory, "/", 4)) {
+        return directory + path;
+    }
+    else {
+        return (directory + "/") + path;
+    }
+}
+
+function normalizeDirectoryPath(path) {
+    const full = normalizePath(path);
+    if (endsWith(full, "/", 4)) {
+        return full;
+    }
+    else {
+        return full + "/";
+    }
+}
+
+function ensureFssPath(path, span) {
+    if (!endsWith(path, ".fss", 5)) {
+        throw new ParseException(new ParseError("Only \'.fss\' files can be used with \'import\'", span));
+    }
+}
+
+function ensureWithinRoot(rootDirectoryWithSeparator, path, span) {
+    const fullPath = normalizePath(path);
+    const fullRoot = trimTrailingDirectorySeparators(rootDirectoryWithSeparator);
+    const rootWithSeparator = endsWith(fullRoot, "/", 4) ? fullRoot : (fullRoot + "/");
+    if (!((compare(fullPath, fullRoot, pathComparison) === 0) ? true : startsWith(fullPath, rootWithSeparator, pathComparison))) {
+        throw new ParseException(new ParseError(concat("Imported file \'", fullPath, "\' is outside of sandbox root"), span));
+    }
+    return fullPath;
+}
+
+function getFileNameWithoutExtension(sourceName) {
+    const normalized = trimTrailingDirectorySeparators(sourceName);
+    let fileName;
+    const matchValue = normalized.lastIndexOf("/") | 0;
+    fileName = ((matchValue === -1) ? normalized : substring(normalized, matchValue + 1));
+    const matchValue_1 = fileName.lastIndexOf(".") | 0;
+    if (matchValue_1 > 0) {
+        return substring(fileName, 0, matchValue_1);
+    }
+    else {
+        return fileName;
+    }
+}
+
+function resolveImportPath(currentFile, importPath, rootDirectoryWithSeparator, span) {
+    if (isNullOrWhiteSpace(importPath)) {
+        throw new ParseException(new ParseError("Import path cannot be empty", span));
+    }
+    ensureFssPath(importPath, span);
+    const currentDirectory = getDirectoryName(currentFile);
+    return ensureWithinRoot(rootDirectoryWithSeparator, isPathRooted(importPath) ? importPath : (isNullOrEmpty(currentDirectory) ? importPath : combinePath(currentDirectory, importPath)), span);
+}
+
+function isValidAliasName(name) {
+    let c;
+    if (!isNullOrWhiteSpace(name) && ((c = name[0], isLetter(c) ? true : (c === "_")))) {
+        return forAll((c_1) => {
+            if (isLetterOrDigit(c_1)) {
+                return true;
+            }
+            else {
+                return c_1 === "_";
+            }
+        }, name.split(""));
+    }
+    else {
+        return false;
+    }
+}
+
+function tryGetSourceModulePrefix(sourceName) {
+    let stem;
+    try {
+        stem = getFileNameWithoutExtension(sourceName);
+    }
+    catch (matchValue) {
+        stem = sourceName;
+    }
+    if (isValidAliasName(stem)) {
+        return stem;
+    }
+    else {
+        return undefined;
+    }
+}
+
+function collectPatternBindings(pattern) {
+    const loop = (acc_mut, pat_mut) => {
+        loop:
+        while (true) {
+            const acc = acc_mut, pat = pat_mut;
+            switch (pat.tag) {
+                case 1:
+                    return add(pat.fields[0], acc);
+                case 4: {
+                    acc_mut = loop(acc, pat.fields[0]);
+                    pat_mut = pat.fields[1];
+                    continue loop;
+                }
+                case 5:
+                    return fold_1(loop, acc, pat.fields[0]);
+                case 6:
+                    return fold_1((s, tupledArg) => loop(s, tupledArg[1]), acc, pat.fields[0]);
+                case 7: {
+                    const tailPattern = pat.fields[1];
+                    const withClauses = fold_1((s_1, tupledArg_1) => loop(loop(s_1, tupledArg_1[0]), tupledArg_1[1]), acc, pat.fields[0]);
+                    if (tailPattern == null) {
+                        return withClauses;
+                    }
+                    else {
+                        acc_mut = withClauses;
+                        pat_mut = tailPattern;
+                        continue loop;
+                    }
+                }
+                case 8: {
+                    acc_mut = acc;
+                    pat_mut = pat.fields[0];
+                    continue loop;
+                }
+                case 10: {
+                    const payload = pat.fields[2];
+                    if (payload == null) {
+                        return acc;
+                    }
+                    else {
+                        acc_mut = acc;
+                        pat_mut = payload;
+                        continue loop;
+                    }
+                }
+                case 11:
+                    return acc;
+                default:
+                    return acc;
+            }
+            break;
+        }
+    };
+    return loop(empty_1({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }), pattern);
+}
+
+function parseDotted(name) {
+    return ofArray(split(name, ["."], undefined, 0));
+}
+
+function joinDotted(parts) {
+    return join(".", parts);
+}
+
+function rewriteNameWithAliases(aliases, name) {
+    const matchValue = parseDotted(name);
+    let matchResult, first_1, rest_1;
+    if (!isEmpty(matchValue)) {
+        if (FSharpMap__ContainsKey(aliases, head_1(matchValue)) && !isEmpty(tail_2(matchValue))) {
+            matchResult = 0;
+            first_1 = head_1(matchValue);
+            rest_1 = tail_2(matchValue);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (FSharpMap__get_Item(aliases, first_1) + ".") + joinDotted(rest_1);
+        default:
+            return name;
+    }
+}
+
+function rewriteNameWithSelfPrefix(selfPrefix, selfNames, boundNames, name) {
+    let prefix;
+    let matchResult, prefix_1;
+    if (selfPrefix != null) {
+        if ((prefix = selfPrefix, FSharpSet__Contains(selfNames, name) && !FSharpSet__Contains(boundNames, name))) {
+            matchResult = 0;
+            prefix_1 = selfPrefix;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return concat(prefix_1, ".", name);
+        default:
+            return name;
+    }
+}
+
+function rewriteTypeName(aliases, selfPrefix, selfTypeNames, name) {
+    let prefix;
+    const aliasRewritten = rewriteNameWithAliases(aliases, name);
+    if (aliasRewritten !== name) {
+        return aliasRewritten;
+    }
+    else {
+        let matchResult, prefix_1;
+        if (selfPrefix != null) {
+            if ((prefix = selfPrefix, FSharpSet__Contains(selfTypeNames, name))) {
+                matchResult = 0;
+                prefix_1 = selfPrefix;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return concat(prefix_1, ".", name);
+            default:
+                return name;
+        }
+    }
+}
+
+function rewriteTypeQualifier(aliases, selfPrefix, selfTypeNames, qualifier) {
+    if (qualifier != null) {
+        return rewriteTypeName(aliases, selfPrefix, selfTypeNames, qualifier);
+    }
+    else {
+        return undefined;
+    }
+}
+
+function rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref) {
+    switch (tref.tag) {
+        case 1:
+            return new TypeRef(1, [map((tref_1) => rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref_1), tref.fields[0])]);
+        case 2:
+            return new TypeRef(2, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[1])]);
+        case 3:
+            return new TypeRef(3, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), tref.fields[1]]);
+        case 4:
+            return new TypeRef(4, [map((tupledArg) => [tupledArg[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg[1])], tref.fields[0])]);
+        case 5:
+            return new TypeRef(5, [map((tupledArg_1) => [tupledArg_1[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], tref.fields[0])]);
+        default:
+            return new TypeRef(0, [rewriteTypeName(aliases, selfPrefix, selfTypeNames, tref.fields[0])]);
+    }
+}
+
+function rewritePattern(aliases, selfPrefix, selfTypeNames, pat) {
+    switch (pat.tag) {
+        case 4:
+            return new Pattern(4, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[1]), pat.fields[2]]);
+        case 5:
+            return new Pattern(5, [map((pat_1) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_1), pat.fields[0]), pat.fields[1]]);
+        case 6:
+            return new Pattern(6, [map((tupledArg) => [tupledArg[0], rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg[1])], pat.fields[0]), pat.fields[1]]);
+        case 7:
+            return new Pattern(7, [map((tupledArg_1) => [rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], pat.fields[0]), map_1((pat_2) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_2), pat.fields[1]), pat.fields[2]]);
+        case 8:
+            return new Pattern(8, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
+        case 10:
+            return new Pattern(10, [rewriteTypeQualifier(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1], map_1((pat_3) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_3), pat.fields[2]), pat.fields[3]]);
+        case 11:
+            return new Pattern(11, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
+        default:
+            return pat;
+    }
+}
+
+function tryFlattenExprPath(expr) {
+    const loop = (acc_mut, current_mut) => {
+        loop:
+        while (true) {
+            const acc = acc_mut, current = current_mut;
+            switch (current.tag) {
+                case 2:
+                    return append(parseDotted(current.fields[0]), acc);
+                case 21: {
+                    acc_mut = cons(current.fields[1], acc);
+                    current_mut = current.fields[0];
+                    continue loop;
+                }
+                default:
+                    return undefined;
+            }
+            break;
+        }
+    };
+    return loop(empty(), expr);
+}
+
+function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
+    const topLevelValueNames = ofList(collect((_arg) => {
+        switch (_arg.tag) {
+            case 2:
+                return singleton(_arg.fields[0]);
+            case 3:
+                return toList(collectPatternBindings(_arg.fields[0]));
+            case 4:
+                return map((tupledArg) => tupledArg[0], _arg.fields[0]);
+            default:
+                return empty();
+        }
+    }, statements), {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const topLevelTypeNames = ofList(choose((_arg_5) => {
+        if (_arg_5.tag === 0) {
+            return _arg_5.fields[0].Name;
+        }
+        else {
+            return undefined;
+        }
+    }, statements), {
+        Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+    });
+    const rewriteValueName = (boundNames, name_2) => {
+        const aliasRewritten = rewriteNameWithAliases(aliases, name_2);
+        if (aliasRewritten !== name_2) {
+            return aliasRewritten;
+        }
+        else {
+            return rewriteNameWithSelfPrefix(selfPrefix, topLevelValueNames, boundNames, name_2);
+        }
+    };
+    const rewriteExpr = (boundNames_1, expr) => {
+        let rest;
+        switch (expr.tag) {
+            case 2:
+                return new Expr(2, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
+            case 29:
+                return new Expr(29, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
+            case 28:
+                return new Expr(28, [rewriteTypeName(aliases, selfPrefix, topLevelTypeNames, expr.fields[0]), expr.fields[1]]);
+            case 3:
+                return new Expr(3, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+            case 4: {
+                const param = expr.fields[0];
+                return new Expr(4, [new Param(param.Name, map_1((tref) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref), param.Annotation), param.Span), rewriteExpr(add(param.Name, boundNames_1), expr.fields[1]), expr.fields[2]]);
+            }
+            case 5:
+                return new Expr(5, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+            case 6:
+                return new Expr(6, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
+            case 7:
+                return new Expr(7, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+            case 8: {
+                const name_6 = expr.fields[0];
+                return new Expr(8, [name_6, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(add(name_6, boundNames_1), expr.fields[2]), expr.fields[3]]);
+            }
+            case 9: {
+                const rewrittenCases = map((tupledArg_1) => {
+                    const rewrittenPattern = rewritePattern(aliases, selfPrefix, topLevelTypeNames, tupledArg_1[0]);
+                    const boundWithPattern = union(boundNames_1, collectPatternBindings(rewrittenPattern));
+                    return [rewrittenPattern, map_1(curry2(rewriteExpr)(boundWithPattern), tupledArg_1[1]), rewriteExpr(boundWithPattern, tupledArg_1[2]), tupledArg_1[3]];
+                }, expr.fields[1]);
+                return new Expr(9, [rewriteExpr(boundNames_1, expr.fields[0]), rewrittenCases, expr.fields[2]]);
+            }
+            case 10: {
+                const valueExpr_1 = expr.fields[1];
+                const span_10 = expr.fields[5];
+                const name_7 = expr.fields[0];
+                const bodyExpr = expr.fields[2];
+                const rewrittenReturnAnnotation = map_1((tref_1) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_1), expr.fields[4]);
+                if (expr.fields[3]) {
+                    const boundWithName = add(name_7, boundNames_1);
+                    return new Expr(10, [name_7, rewriteExpr(boundWithName, valueExpr_1), rewriteExpr(boundWithName, bodyExpr), true, rewrittenReturnAnnotation, span_10]);
+                }
+                else {
+                    return new Expr(10, [name_7, rewriteExpr(boundNames_1, valueExpr_1), rewriteExpr(add(name_7, boundNames_1), bodyExpr), false, rewrittenReturnAnnotation, span_10]);
+                }
+            }
+            case 11: {
+                const rewrittenPattern_1 = rewritePattern(aliases, selfPrefix, topLevelTypeNames, expr.fields[0]);
+                const boundWithPattern_1 = union(boundNames_1, collectPatternBindings(rewrittenPattern_1));
+                return new Expr(11, [rewrittenPattern_1, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundWithPattern_1, expr.fields[2]), expr.fields[3]]);
+            }
+            case 12: {
+                const bindings_1 = expr.fields[0];
+                const recursiveBound = union(boundNames_1, ofList(map((tupledArg_2) => tupledArg_2[0], bindings_1), {
+                    Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+                }));
+                return new Expr(12, [map((tupledArg_3) => {
+                    const rewrittenArgs = map((p) => (new Param(p.Name, map_1((tref_2) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_2), p.Annotation), p.Span)), tupledArg_3[1]);
+                    return [tupledArg_3[0], rewrittenArgs, map_1((tref_3) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_3), tupledArg_3[2]), rewriteExpr(fold_1((s, p_1) => add(p_1.Name, s), recursiveBound, rewrittenArgs), tupledArg_3[3]), tupledArg_3[4]];
+                }, bindings_1), rewriteExpr(recursiveBound, expr.fields[1]), expr.fields[2]]);
+            }
+            case 13:
+                return new Expr(13, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
+            case 14:
+                return new Expr(14, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+            case 15:
+                return new Expr(15, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
+            case 16:
+                return new Expr(16, [map((tupledArg_4) => [tupledArg_4[0], rewriteExpr(boundNames_1, tupledArg_4[1])], expr.fields[0]), expr.fields[1]]);
+            case 17:
+                return new Expr(17, [map((tupledArg_5) => [tupledArg_5[0], rewriteExpr(boundNames_1, tupledArg_5[1])], expr.fields[0]), expr.fields[1]]);
+            case 18:
+                return new Expr(18, [map((_arg_10) => {
+                    if (_arg_10.tag === 1) {
+                        return new MapEntry(1, [rewriteExpr(boundNames_1, _arg_10.fields[0])]);
+                    }
+                    else {
+                        return new MapEntry(0, [rewriteExpr(boundNames_1, _arg_10.fields[0]), rewriteExpr(boundNames_1, _arg_10.fields[1])]);
+                    }
+                }, expr.fields[0]), expr.fields[1]]);
+            case 19:
+                return new Expr(19, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_6) => [tupledArg_6[0], rewriteExpr(boundNames_1, tupledArg_6[1])], expr.fields[1]), expr.fields[2]]);
+            case 20:
+                return new Expr(20, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_7) => [tupledArg_7[0], rewriteExpr(boundNames_1, tupledArg_7[1])], expr.fields[1]), expr.fields[2]]);
+            case 21: {
+                const target_2 = expr.fields[0];
+                const span_21 = expr.fields[2];
+                const fieldName = expr.fields[1];
+                const matchValue = tryFlattenExprPath(target_2);
+                let matchResult, rest_1, root_1;
+                if (matchValue != null) {
+                    if (!isEmpty(matchValue)) {
+                        if ((rest = tail_2(matchValue), FSharpMap__ContainsKey(aliases, head_1(matchValue)))) {
+                            matchResult = 0;
+                            rest_1 = tail_2(matchValue);
+                            root_1 = head_1(matchValue);
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+                switch (matchResult) {
+                    case 0:
+                        return new Expr(2, [(FSharpMap__get_Item(aliases, root_1) + ".") + joinDotted(append(rest_1, singleton(fieldName))), span_21]);
+                    default:
+                        return new Expr(21, [rewriteExpr(boundNames_1, target_2), fieldName, span_21]);
+                }
+            }
+            case 22:
+                return new Expr(22, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+            case 23:
+                return new Expr(23, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+            case 24:
+                return new Expr(24, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+            case 25:
+                return new Expr(25, [expr.fields[0], rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
+            case 26:
+                return new Expr(26, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+            case 30:
+                return new Expr(30, [map((_arg_11) => {
+                    if (_arg_11.tag === 1) {
+                        return new InterpolatedPart(1, [rewriteExpr(boundNames_1, _arg_11.fields[0])]);
+                    }
+                    else {
+                        return new InterpolatedPart(0, [_arg_11.fields[0]]);
+                    }
+                }, expr.fields[0]), expr.fields[1]]);
+            default:
+                return expr;
+        }
+    };
+    const qualifySelfName = (name_14) => {
+        if (selfPrefix == null) {
+            return name_14;
+        }
+        else {
+            return `${selfPrefix}.${name_14}`;
+        }
+    };
+    const rewriteParam = (param_1) => (new Param(param_1.Name, map_1((tref_4) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_4), param_1.Annotation), param_1.Span));
+    return map((_arg_12) => {
+        let def_1;
+        switch (_arg_12.tag) {
+            case 2: {
+                const isRec_1 = _arg_12.fields[4];
+                const rewrittenName = qualifySelfName(_arg_12.fields[0]);
+                const rewrittenArgs_1 = map(rewriteParam, _arg_12.fields[1]);
+                const rewrittenReturnAnnotation_2 = map_1((tref_6) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_6), _arg_12.fields[2]);
+                const bound = fold_1((s_1, p_2) => add(p_2.Name, s_1), empty_1({
+                    Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+                }), rewrittenArgs_1);
+                return new Stmt(2, [rewrittenName, rewrittenArgs_1, rewrittenReturnAnnotation_2, rewriteExpr(isRec_1 ? add(rewrittenName, bound) : bound, _arg_12.fields[3]), isRec_1, _arg_12.fields[5], _arg_12.fields[6]]);
+            }
+            case 3:
+                return new Stmt(3, [rewritePattern(aliases, selfPrefix, topLevelTypeNames, _arg_12.fields[0]), rewriteExpr(empty_1({
+                    Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                }), _arg_12.fields[1]), _arg_12.fields[2], _arg_12.fields[3]]);
+            case 4: {
+                const bindings_2 = _arg_12.fields[0];
+                const names_1 = ofList(map((tupledArg_10) => qualifySelfName(tupledArg_10[0]), bindings_2), {
+                    Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+                });
+                return new Stmt(4, [map((tupledArg_11) => {
+                    const rewrittenName_1 = qualifySelfName(tupledArg_11[0]);
+                    const rewrittenArgs_2 = map(rewriteParam, tupledArg_11[1]);
+                    return [rewrittenName_1, rewrittenArgs_2, map_1((tref_7) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_7), tupledArg_11[2]), rewriteExpr(fold_1((s_2, p_3) => add(p_3.Name, s_2), names_1, rewrittenArgs_2), tupledArg_11[3]), tupledArg_11[4]];
+                }, bindings_2), _arg_12.fields[1], _arg_12.fields[2]]);
+            }
+            case 5:
+                return new Stmt(5, [rewriteExpr(empty_1({
+                    Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+                }), _arg_12.fields[0])]);
+            case 1:
+                throw new Exception("Unexpected unresolved import directive");
+            default:
+                return new Stmt(0, [(def_1 = _arg_12.fields[0], new TypeDef(qualifySelfName(def_1.Name), def_1.IsRecursive, map((tupledArg_8) => [tupledArg_8[0], rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tupledArg_8[1])], def_1.Fields), map((tupledArg_9) => [tupledArg_9[0], map_1((tref_5) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_5), tupledArg_9[1])], def_1.Cases), def_1.Span))]);
+        }
+    }, statements);
+}
+
+function expandProgram(rootDirectoryWithSeparator, fileSpan, getOrCreatePrefix, loadFileRef, stack, isMainFile, currentFile, currentPrefix, program) {
+    let seenCode = false;
+    const imports = [];
+    const localCode = [];
+    const enumerator = getEnumerator(program);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const stmt = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (stmt.tag === 1) {
+                const span = stmt.fields[2];
+                if (seenCode) {
+                    throw new ParseException(new ParseError("\'import\' directives must appear before code", span));
+                }
+                void (imports.push([stmt.fields[0], stmt.fields[1], span]));
+            }
+            else {
+                seenCode = true;
+                void (localCode.push(stmt));
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    const aliasMappings = fold_2((acc, tupledArg) => {
+        const alias_1 = tupledArg[0];
+        const span_1 = tupledArg[2];
+        if (!isValidAliasName(alias_1)) {
+            throw new ParseException(new ParseError(concat("Invalid import alias \'", alias_1, "\'"), span_1));
+        }
+        if (FSharpMap__ContainsKey(acc, alias_1)) {
+            throw new ParseException(new ParseError(concat("Duplicate import alias \'", alias_1, "\'"), span_1));
+        }
+        return add_1(alias_1, getOrCreatePrefix(resolveImportPath(currentFile, tupledArg[1], rootDirectoryWithSeparator, span_1)), acc);
+    }, empty_2({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }), imports);
+    return append(collect((tupledArg_1) => {
+        const resolvedPath_1 = resolveImportPath(currentFile, tupledArg_1[1], rootDirectoryWithSeparator, tupledArg_1[2]);
+        const childPrefix = FSharpMap__get_Item(aliasMappings, tupledArg_1[0]);
+        return loadFileRef.contents(stack)(false)(resolvedPath_1)(childPrefix);
+    }, toList_1(imports)), rewriteModuleScopedStatements(isMainFile ? undefined : currentPrefix, aliasMappings, toList_1(localCode)));
+}
+
+export function parseIncludedSource(sourceName, source) {
+    const program = parseProgramWithSourceName(sourceName, source);
+    const dummyRoot = normalizeDirectoryPath(".");
+    let counter = 0;
+    const pathPrefixes = makeStringDictionary();
+    const loadRef = new FSharpRef((_arg) => ((_arg_1) => ((_arg_2) => ((_arg_3) => empty()))));
+    if (exists((_arg_4) => {
+        if (_arg_4.tag === 1) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, program)) {
+        throw new ParseException(new ParseError("Embedded source does not support \'import\'", head_1(choose((_arg_5) => {
+            if (_arg_5.tag === 1) {
+                return _arg_5.fields[2];
+            }
+            else {
+                return undefined;
+            }
+        }, program))));
+    }
+    return expandProgram(dummyRoot, (path) => {
+        const p = new Position(path, 1, 1);
+        return new Span(p, p);
+    }, (path_1) => {
+        let matchValue;
+        let outArg = defaultOf();
+        matchValue = [tryGetValue(pathPrefixes, path_1, new FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+        if (matchValue[0]) {
+            return matchValue[1];
+        }
+        else {
+            let prefix_1;
+            counter = ((counter + 1) | 0);
+            prefix_1 = (`__imp${counter}`);
+            pathPrefixes.set(path_1, prefix_1);
+            return prefix_1;
+        }
+    }, loadRef, empty(), false, sourceName, tryGetSourceModulePrefix(sourceName), program);
+}
+
+export function parseProgramFromFile(rootDirectory, entryFile) {
+    const p = new Position(entryFile, 1, 1);
+    throw new ParseException(new ParseError("File-backed imports are not supported in Fable builds; use resolver-backed source imports", new Span(p, p)));
+}
+
+function parseProgramFromSourceWithIncludesCore(rootDirectory, entryFile, entrySource, resolveImportedSource) {
+    const rootDirectoryWithSeparator = normalizeDirectoryPath(rootDirectory);
+    const fileSpan = (path) => {
+        const p = new Position(path, 1, 1);
+        return new Span(p, p);
+    };
+    let counter = 0;
+    const pathPrefixes = makeStringDictionary();
+    const emittedFiles = makeStringHashSet();
+    const entryFullPath = normalizeFilePath(entryFile);
+    const entrySpan = fileSpan(entryFullPath);
+    ensureFssPath(entryFullPath, entrySpan);
+    const entrySandboxedPath = ensureWithinRoot(rootDirectoryWithSeparator, entryFullPath, entrySpan);
+    const loadFile = (stack, isMainFile, filePath, prefix_2) => {
+        let arg, matchValue_1;
+        const fullFilePath = normalizeFilePath(filePath);
+        const initialSpan = fileSpan(fullFilePath);
+        ensureFssPath(fullFilePath, initialSpan);
+        const sandboxedPath = ensureWithinRoot(rootDirectoryWithSeparator, fullFilePath, initialSpan);
+        if (exists((p_1) => pathsEqual(p_1, sandboxedPath), stack)) {
+            throw new ParseException(new ParseError((arg = join(" -> ", append(reverse(cons(sandboxedPath, stack)), singleton(sandboxedPath))), toText(printf("Import cycle detected: %s"))(arg)), fileSpan(sandboxedPath)));
+        }
+        else if (!isMainFile && emittedFiles.has(sandboxedPath)) {
+            return empty();
+        }
+        else {
+            if (!isMainFile) {
+                addToSet(sandboxedPath, emittedFiles);
+            }
+            const program = parseProgramWithSourceName(sandboxedPath, pathsEqual(sandboxedPath, entrySandboxedPath) ? entrySource : ((resolveImportedSource == null) ? (() => {
+                throw new ParseException(new ParseError(concat("Imported file \'", sandboxedPath, "\' could not be resolved; Fable hosts must provide a resolver"), fileSpan(sandboxedPath)));
+            })() : ((matchValue_1 = resolveImportedSource(sandboxedPath), (matchValue_1 == null) ? (() => {
+                throw new ParseException(new ParseError(concat("Imported file \'", sandboxedPath, "\' could not be resolved"), fileSpan(sandboxedPath)));
+            })() : matchValue_1))));
+            return expandProgram(rootDirectoryWithSeparator, fileSpan, (path_1) => {
+                let matchValue;
+                let outArg = defaultOf();
+                matchValue = [tryGetValue(pathPrefixes, path_1, new FSharpRef(() => outArg, (v) => {
+                    outArg = v;
+                })), outArg];
+                if (matchValue[0]) {
+                    return matchValue[1];
+                }
+                else {
+                    let prefix_1;
+                    counter = ((counter + 1) | 0);
+                    prefix_1 = (`__imp${counter}`);
+                    pathPrefixes.set(path_1, prefix_1);
+                    return prefix_1;
+                }
+            }, new FSharpRef(curry4(loadFile)), cons(sandboxedPath, stack), isMainFile, sandboxedPath, prefix_2, program);
+        }
+    };
+    return loadFile(empty(), true, entrySandboxedPath, undefined);
+}
+
+export function parseProgramFromSourceWithIncludes(rootDirectory, entryFile, entrySource) {
+    return parseProgramFromSourceWithIncludesCore(rootDirectory, entryFile, entrySource, undefined);
+}
+
+export function parseProgramFromSourceWithIncludesResolver(rootDirectory, entryFile, entrySource, resolveImportedSource) {
+    return parseProgramFromSourceWithIncludesCore(rootDirectory, entryFile, entrySource, resolveImportedSource);
+}
+