firefly-compiler 0.5.38 → 0.5.40

package/compiler/JsEmitter.ff

@@ -1,1437 +1,1437 @@
-import Syntax
-import Patterns
-import JsImporter
-
-class JsEmitter(
-    otherModules: Map[String, Module]
-    jsImporter: JsImporter
-    emitTarget: EmitTarget
-    isMainModule: Bool
-    compilerModuleFileUrl: Option[String]
-    packagePair: PackagePair
-    moduleName: String
-    mutable emittingAsync: Bool
-    mutable tailCallUsed: Bool
-)
-
-data EmitTarget {
-    EmitNode
-    EmitBrowser
-    EmitBuild
-    EmitExecutable
-}
-
-new(
-    otherModules: List[Module]
-    emitTarget: EmitTarget
-    isMainModule: Bool
-    compilerModuleFileUrl: Option[String]
-    packagePair: PackagePair
-    moduleName: String
-): JsEmitter {
-    JsEmitter(
-        otherModules = otherModules.map {m =>
-            let moduleName = m.packagePair.groupName() + "/" + m.file.dropLast(3)
-            Pair(moduleName, m)
-        }.toMap()
-        jsImporter = JsImporter.new()
-        emitTarget = emitTarget
-        isMainModule = isMainModule
-        compilerModuleFileUrl = compilerModuleFileUrl
-        packagePair = packagePair
-        moduleName = moduleName
-        emittingAsync = False
-        tailCallUsed = False
-    )
-}
-
-fail[T](at: Location, message: String): T {
-    panic(message + " " + at.show())
-}
-
-extend self: JsEmitter {
-
-    emitModule(packagePair: PackagePair, module: Module): String {
-        let selfImport =
-            "import * as " + packagePair.groupName("_") + "_" + module.file.dropLast(3) + " " +
-            "from \"../../" + packagePair.groupName("/") + "/" + module.file.dropLast(3) + ".mjs\""
-        let imports = [
-            self.compilerModuleFileUrl.map {"import * as $firefly_compiler from '" + _ + "'"}.toList()
-            module.imports.sortBy {i => Pair(i.package, i.file) }.map {self.emitImportDefinition(_)}
-        ].flatten()
-        let parts = [
-            if(imports.any {_ == selfImport}) {imports} else {[selfImport, ...imports]}
-            module.types.map {self.emitTypeDefinition(_)}
-            module.lets.map {"export " + self.emitLetDefinition(_, False, False)}
-            module.functions.map {"export " + self.emitFunctionDefinition(_, False)}
-            self.withEmittingAsync {module.functions.map {"export " + self.emitFunctionDefinition(_, True)}}
-            module.extends.map {self.emitExtendsDefinition(_)}
-            module.instances.map {self.emitInstanceDefinition(_)}
-            if(self.isMainModule) {
-                self.emitRun(module.functions, packagePair, packagePair.group == "ff" && packagePair.name == "compiler")
-            } else {[]}
-        ]
-        let ignoreJsImports = if(
-            self.emitTarget == EmitExecutable &&
-            packagePair.group == "ff" &&
-            packagePair.name == "core"
-        ) {["esbuild"]} else {[]}
-        let jsImports = self.jsImporter.generateImports(ignoreJsImports.toSet())
-        [jsImports, ...parts].map {_.join("\n\n")}.join("\n\n") + "\n"
-    }
-
-    withEmittingAsync[T](body: () => T): T {
-        try {
-            self.emittingAsync = True
-            body()
-        } finally {
-            self.emittingAsync = False
-        }
-    }
-
-    emitRun(functions: List[DFunction], mainPackagePair: PackagePair, bootstrapping: Bool): List[String] {
-        let buildMainFunction = functions.find {_.signature.name == "buildMain"}.filter {_ =>
-            self.emitTarget != EmitBrowser && self.emitTarget != EmitExecutable
-        }
-        let willRunOnNode = self.emitTarget != EmitBrowser
-        let targetMain = if(willRunOnNode) {"nodeMain"} else {"browserMain"}
-        let mainFunction =
-            functions.find {_.signature.name == targetMain}.orElse {functions.find {_.signature.name == "main"}}
-        mainFunction.map {_.signature.name}.map {mainName => [[
-            "export async function $run$(fireflyPath_, arguments_) {"
-            "Error.stackTraceLimit = 50"
-            "const $task = {controller_: new AbortController(), subtasks_: new Set(), promise_: new Promise(() => {}), started_: performance.now() * 0.001}"
-            ...if(self.emitTarget != EmitBrowser) {[
-                "let interval = setInterval(() => {}, 24 * 60 * 60 * 1000)" // To prevent deadlocks from exiting node
-            ]} else {[]}
-            "let system = {"
-            "task_: $task,"
-            "array_: arguments_,"
-            "fireflyPath_: fireflyPath_,"
-            "mainPackagePair_: {group_: \"" + mainPackagePair.group + "\", name_: \"" + mainPackagePair.name + "\"},"
-            "executableMode_: " + if(self.emitTarget == EmitExecutable) {"true"} else {"false"} + ","
-            "buildMode_: " + if(self.emitTarget == EmitBuild) {"true"} else {"false"}
-            "}"
-            "try {"
-            ...if(!buildMainFunction.isEmpty()) {[
-                "await buildMain_$(system, $task)"]
-            } else {[]}
-            ...if(self.emitTarget != EmitBuild) {[
-                "await " + mainName + "_$(system, $task)"
-            ]} else {[]}
-            ...if(self.emitTarget == EmitBuild) {[
-                "await $firefly_compiler.internalCreateExecutable_$(system, '.firefly/output/executable/Main.bundle.js', '.firefly/output', ['host'], system.assets_, $task)"
-            ]} else {[]}
-            "} finally {"
-            ...if(self.emitTarget != EmitBrowser) {[
-                "ff_core_Task.Task_abort$($task)"
-                "clearInterval(interval)"
-            ]} else {[]}
-            "}"
-            "}"
-            ...self.emitTarget.{
-                | EmitBrowser => [
-                    "queueMicrotask(async () => {"
-                    "await $run$(null, [])"
-                    "})"
-                ]
-                | EmitNode {bootstrapping} => [
-                    "import * as path from 'node:path'"
-                    "queueMicrotask(async () => {"
-                    "let fireflyPath_ = path.dirname(path.dirname(path.dirname(path.dirname(path.dirname(process.argv[1])))))"
-                    "await $run$(fireflyPath_, process.argv.slice(2))"
-                    "})"
-                ]
-                | EmitExecutable => [
-                    "queueMicrotask(async () => {"
-                    "await $run$(null, process.argv.slice(2))"
-                    "})"
-                ]
-                | _ => []
-            }
-        ].join("\n")]}.else {[]}
-    }
-
-    emitImportDefinition(definition: DImport): String {
-        "import * as " + definition.package.group + "_" + definition.package.name + "_" + definition.file + " " +
-        "from \"../../" + definition.package.group + "/" + definition.package.name + "/" + definition.file + ".mjs\""
-    }
-
-    emitLetDefinition(definition: DLet, mutable: Bool, async: Bool): String {
-        let mutability = if(mutable) {"let"} else {"const"}
-        let valueCode = self.emitTerm(definition.value, async)
-        let assignmentCode = if(!mutable || valueCode != "(void 0)") {" = " + valueCode} else {""}
-        mutability + " " + escapeKeyword(definition.name) + assignmentCode + ";"
-    }
-
-    emitExtendsDefinition(definition: DExtend): String {
-        let typeName = extractTypeName(definition.type).reverse().takeWhile {_ != '.'}.reverse()
-        let methods = definition.methods.map {method =>
-            method.DFunction(
-                signature = method.signature.Signature(
-                    name = typeName + "_" + method.signature.name
-                )
-            )
-        }
-        let syncMethods = methods.map {"export " + self.emitFunctionDefinition(_, False)}
-        let asyncMethods = self.withEmittingAsync {methods.map {"export " + self.emitFunctionDefinition(_, True)}}
-        [...syncMethods, ...asyncMethods].join("\n\n")
-    }
-
-    emitInstanceDefinition(definition: DInstance): String {
-        let name = makeDictionaryName(definition.traitName, firstTypeName(definition.typeArguments))
-        let methods = definition.methods.map {self.emitFunctionDefinition(_, False)}.map {_.dropFirst("function ".size())} // TODO
-        let asyncMethods = self.withEmittingAsync {
-            definition.methods.map {self.emitFunctionDefinition(_, True)}.map {"async " + _.dropFirst("async function ".size())} // TODO
-        }
-        let body = "{\n" + [...methods, ...asyncMethods].join(",\n") + "\n}"
-        definition.constraints.{
-            | [] =>
-                "export const " + name + " = " + body + ";"
-            | constraints =>
-                let dictionaries = constraints.map {c =>
-                    makeDictionaryName(c.name, firstTypeName(c.generics))
-                }
-                "export function " + name + "(" + dictionaries.join(", ") + ") { return " + body + "}"
-        }
-    }
-
-    emitFunctionDefinition(definition: DFunction, async: Bool, suffix: String = ""): String {
-        let signature = self.emitSignature(definition.signature, async, suffix)
-        definition.body.{
-            | Lambda(_, effect, [matchCase]) {
-                matchCase.patterns.all {
-                    | PVariable(_, None) => True
-                    | _ => False
-                }
-            } =>
-                let body = self.emitTailCall {self.emitStatements(matchCase.body, True, False, async)}
-                signature + " {\n" + body + "\n}"
-            | Lambda(_, effect, cases) =>
-                Patterns.convertAndCheck(self.otherModules, cases)
-                let escapedArguments = definition.signature.parameters.map {_.name + "_a"}
-                let shadowingWorkaround = definition.signature.parameters.map {p =>
-                    "const " + p.name + "_a = " + escapeKeyword(p.name) + ";"
-                }.join("\n")
-                let body = self.emitTailCall {
-                    let casesString = cases.pairs().map {| Pair(i, c) =>
-                        let lastCase = i == cases.size() - 1
-                        self.emitCase(escapedArguments, c, [], [], True, True, False, lastCase, async)
-                    }.join("\n")
-                    shadowingWorkaround + "\n" + casesString
-                }
-                signature + " {\n" + body + "\n}"
-        }
-    }
-
-    emitTailCall(body: () => String): String {
-        let outerTailCallUsed = self.tailCallUsed
-        self.tailCallUsed = False
-        let result = body()
-        let tailCallUsed = self.tailCallUsed
-        self.tailCallUsed = outerTailCallUsed
-        if(tailCallUsed) {
-            "_tailcall: for(;;) {\n" + result + "\nreturn\n}"
-        } else {
-            result
-        }
-    }
-
-    emitSignature(signature: Signature, async: Bool, suffix: String = ""): String {
-        let parameterStrings = signature.parameters.map {self.emitParameter(_, async)}
-        let dictionaryStrings = signature.constraints.map {c =>
-            makeDictionaryName(c.name, firstTypeName(c.generics))
-        }
-        let controller = if(async) {["$task"]} else {[]}
-        let parameters = "(" + [...parameterStrings, ...dictionaryStrings, ...controller].join(", ") + ")"
-        let prefix = if(async) {"async "} else {""}
-        let asyncSuffix = if(async) {"$"} else {""}
-        prefix + "function " + escapeKeyword(signature.name) + suffix + asyncSuffix + parameters
-    }
-
-    emitParameter(parameter: Parameter, async: Bool): String {
-        let defaultValue = parameter.default.map {" = " + self.emitTerm(_, async) }.else {""}
-        escapeKeyword(parameter.name) + defaultValue
-    }
-
-    emitTypeDefinition(definition: DType): String {
-        if(definition.newtype) {"// newtype " + definition.name} else:
-        "// type " + definition.name + "\n" +
-        definition.variants.map {self.emitVariantDefinition(definition, _)}.join("\n")
-    }
-
-    emitVariantDefinition(typeDefinition: DType, definition: Variant): String {
-        let allFields = [...typeDefinition.commonFields, ...definition.fields]
-        let fields = allFields.map {escapeKeyword(_.name)}.join(", ")
-        if(allFields.isEmpty()) {
-            "const " + definition.name + "$ = {" + definition.name + ": true};\n" +
-            "export function " + definition.name + "(" + fields + ") {\n" +
-            "return " + definition.name + "$;\n" +
-            "}"
-        } elseIf {typeDefinition.variants.size() == 1} {
-            "export function " + definition.name + "(" + fields + ") {\n" +
-            "return {" + fields + "};\n" +
-            "}"
-        } else {
-            "export function " + definition.name + "(" + fields + ") {\n" +
-            "return {" + definition.name + ": true, " + fields + "};\n" +
-            "}"
-        }
-    }
-
-    emitTerm(term: Term, async: Bool): String {term.{
-        | EString(at, value) {value.startsWith("\"\"\"")} =>
-            "`" + value.dropFirst(3).dropLast(3).replace("`", "\\`") + "`" // TODO: Fix escaping
-        | EString(at, value) => value
-        | EChar(at, value) => charLiteralToNumber(value)
-        | EInt(at, value) => value
-        | EFloat(at, value) => value
-        | EVariable(at, name) => escapeResolved(name)
-        | EList(at, _, items) =>
-            self.emitList(items, async)
-        | EVariant(at, "ff:core/Bool.False", _, _) =>
-            "false"
-        | EVariant(at, "ff:core/Bool.True", _, _) =>
-            "true"
-        | EVariant(at, "ff:core/Unit.Unit", _, _) =>
-            "(void 0)"
-        | EVariant(at, name, _, arguments) =>
-            let argumentsString = arguments.toList().flatten().map {self.emitArgument(at, _, async)}.join(", ")
-            let newtype = self.processVariant(name)
-            if(newtype) {argumentsString} else:
-            escapeResolved(name) + "(" + argumentsString + ")"
-        | EVariantIs(at, "ff:core/Bool.False", _) =>
-            "function(_v) { return !_v ? ff_core_Option.Some(_v) : ff_core_Option.None(); }"
-        | EVariantIs(at, "ff:core/Bool.True", _) =>
-            "function(_v) { return _v ? ff_core_Option.Some(_v) : ff_core_Option.None(); }"
-        | EVariantIs(at, "ff:core/Unit.Unit", _) =>
-            "function(_v) { return ff_core_Option.Some(_v); }"
-        | EVariantIs(at, name, _) =>
-            let n = name.reverse().takeWhile {_ != '.'}.reverse()
-            "(function(_v) { " +
-            "return _v." + escapeResolved(n) + " ? ff_core_Option.Some(_v) : ff_core_Option.None();" +
-            "})"
-        | ECopy(at, name, record, fields) =>
-            let fieldCode = fields.map {f => escapeKeyword(f.name) + " = " + self.emitTerm(f.value, async)}.join(", ")
-            "{..." + self.emitTerm(record, async) + ", " + fieldCode + "}"
-        | EField(at, newtype, record, field) =>
-            if(newtype) {self.emitTerm(record, async)} else:
-            self.emitTerm(record, async) + "." + escapeKeyword(field)
-        | ELambda(at, Lambda(_, effect, [MatchCase(_, patterns, [], body)])) {
-            patterns.all {| PVariable _ => True | _ => False }
-        } =>
-            let newAsync = self.emittingAsync && effectTypeIsAsync(effect)
-            let patternParameters = patterns.map {
-                | PVariable p => p.name.map(escapeKeyword).else {"_"}
-                | _ => panic("!")
-            }
-            let controller = if(newAsync) {["$task"]} else {[]}
-            let parameters = [...patternParameters, ...controller].join(", ")
-            let prefix = if(newAsync) {"async "} else {""}
-            "(" + prefix + "(" + parameters + ") => {\n" + self.emitStatements(body, True, False, newAsync) + "\n})"
-        | ELambda(at, Lambda(_, effect, cases)) =>
-            let newAsync = self.emittingAsync && effectTypeIsAsync(effect)
-            let controller = if(newAsync) {["$task"]} else {[]}
-            Patterns.convertAndCheck(self.otherModules, cases)
-            let arguments = cases.grab(0).patterns.pairs().map {"_" + (_.first + 1)}
-            let escapedArguments = arguments.map(escapeKeyword) // emitCase arguments must be preescaped
-            let caseStrings = cases.pairs().map {| Pair(i, c) =>
-                let lastCase = i == cases.size() - 1
-                self.emitCase(escapedArguments, c, [], [], True, True, False, lastCase, newAsync)
-            }
-            let prefix = if(newAsync) {"async "} else {""}
-            "(" + prefix + "(" + [...escapedArguments, ...controller].join(", ") + ") => " +
-            "{\n" + caseStrings.join("\n") + "\n})"
-        | EPipe(at, value, effect, function) =>
-            let await = async && effectTypeIsAsync(effect)
-            let c = if(await) {", $task"} else {""}
-            let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
-            if(await) {"(await " + call + ")"} else {call}
-        | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
-            self.emitSpecialCall(term, async, name, arguments.map {_.value}, dictionaries) | Some(code)
-        } =>
-            code
-        | ECall(at, StaticCall(name, _, True), effect, typeArguments, arguments, dictionaries) =>
-            let await = async && effectTypeIsAsync(effect)
-            let dictionaryStrings = dictionaries.map {self.emitDictionary(_)}
-            let ds = dictionaryStrings.dropFirst()
-            let d = dictionaryStrings.grabFirst()
-            let asyncSuffix = if(await) {"$"} else {""}
-            let n = escapeKeyword(name.reverse().takeWhile {_ != '.'}.reverse()) + asyncSuffix
-            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
-            let controller = if(await) {["$task"]} else {[]}
-            let call = d + "." + n + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
-            if(await) {"(await " + call + ")"} else {call}
-        | ECall(at, StaticCall(name, _, _), effect, typeArguments, arguments, dictionaries) =>
-            if(name.contains("bundleForBrowser")) { // TODO: Delete this test (for branch arraysonly)
-                if(!arguments.grab(0).name.contains("system")) {
-                    Log.debug("Wrong arguments for bundleForBrowser: " + Show.show(arguments.map {_.name}))
-                    throw(GrabException())
-                }
-            }
-            detectIfElse(term).{
-                | [] =>
-                    let await = async && effectTypeIsAsync(effect)
-                    let ds = dictionaries.map {self.emitDictionary(_)}
-                    let functionCode = escapeResolved(name) + if(await) {"$"} else {""}
-                    let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
-                    let controller = if(await) {["$task"]} else {[]}
-                    let call = functionCode + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
-                    if(await) {"(await " + call + ")"} else {call}
-                | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
-                    "(" + list.foldLeft(self.emitComma(elseBody, async)) {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? " + self.emitComma(body, async) + "\n: " + otherwise
-                    } + ")"
-                | list =>
-                    "(" + list.foldLeft("ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? ff_core_Option.Some(" + self.emitComma(body, async) + ")\n: " + otherwise
-                    } + ")"
-            }
-        | ECall(at, DynamicCall(function, _), effect, typeArguments, arguments, dictionaries) =>
-            let await = async && effectTypeIsAsync(effect)
-            if(!dictionaries.isEmpty()) {fail(at, "Internal error: Dictionaries in lambda call")}
-            let functionCode = self.emitTerm(function, async)
-            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
-            let controller = if(await) {["$task"]} else {[]}
-            let call = functionCode + "(" + [...emittedArguments, ...controller].join(", ") + ")"
-            if(await) {"(await " + call + ")"} else {call}
-        | ERecord(at, fields) =>
-            if(fields.isEmpty()) {"{}"} else {
-                let list = fields.map {f => escapeKeyword(f.name) + ": " + self.emitTerm(f.value, async)}
-                "{\n" + list.join(",\n") + "\n}"
-            }
-        | EWildcard(at, index) =>
-            if(index == 0) {fail(at, "Unbound wildcard")}
-            "_w" + index
-        | _ {async} =>
-            "(await (async function() {\n" + self.emitStatements(term, True, False, async) + "\n})())"
-        | _ =>
-            "(function() {\n" + self.emitStatements(term, True, False, async) + "\n})()"
-    }}
-    
-    emitField(term: Term, async: Bool, dot: String = "."): String {
-        term.{
-            | EString(_, q) {safeBare(q) | Some(s)} => dot + s
-            | _ => "[" + self.emitTerm(term, async) + "]"
-        }
-    }
-
-    emitDictionary(d: Dictionary): String {
-        let m = if(d.moduleName != "") {
-            d.packagePair.groupName("_") + "_" + d.moduleName.replace("/", "_") + "."
-        } else {""}
-        let c = m + makeDictionaryName(d.traitName, d.typeName)
-        if(d.dictionaries.isEmpty()) {
-            c
-        } else {
-            c + "(" + d.dictionaries.map {self.emitDictionary(_)}.join(", ") + ")"
-        }
-    }
-
-    emitStatements(term: Term, last: Bool, break: Bool, async: Bool): String {
-        term.{
-            | EFunctions(at, functions, body) =>
-                let functionStrings = functions.map {f =>
-                    let newAsync = self.emittingAsync && effectTypeIsAsync(f.signature.effect)
-                    self.emitFunctionDefinition(f, newAsync)
-                }
-                functionStrings.join("\n") + "\n" + self.emitStatements(body, last, break, async)
-            | ELet(at, mutable, name, valueType, value, body) =>
-                self.emitLetDefinition(DLet(at, name, valueType, value), mutable, async) + "\n" +
-                self.emitStatements(body, last, break, async)
-            | EVariant(at, "ff:core/Unit.Unit", _, _) =>
-                ""
-            | ESequential(_, EVariant(_, "ff:core/Unit.Unit", _, _), after) =>
-                self.emitStatements(after, last, break, async)
-            | ESequential(_, before, EVariant(_, "ff:core/Unit.Unit", _, _)) =>
-                self.emitStatements(before, False, break, async)
-            | ESequential(at, before, after) =>
-                self.emitStatements(before, False, False, async) + ";\n" + 
-                self.emitStatements(after, last, break, async)
-            | EAssign(at, operator, name, value) =>
-                escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async)
-            | EAssignField(at, operator, record, field, value) =>
-                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
-                self.emitTerm(value, async)
-            | ECall(at, StaticCall(name, True, instanceCall), effect, _, arguments, _) =>
-                if(instanceCall) {throw(CompileError(at, "Not yet implemented: Tail calls on trait methods."))}
-                self.tailCallUsed = True
-                let pair = arguments.map {a =>
-                    Some(Pair(
-                        "const " + escapeKeyword(a.name.grab() + "_r") + " = " + self.emitTerm(a.value, async) + ";"
-                        escapeKeyword(a.name.grab()) + " = " + escapeKeyword(a.name.grab() + "_r")
-                    ))
-                }.collect {_}.unzip()
-                "{\n" + pair.first.join("\n") + "\n" + pair.second.join("\n") + "\ncontinue _tailcall\n}"
-            | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
-                self.emitSpecialStatement(term, last, async, name, arguments.map {_.value}, dictionaries) | Some(code)
-            } =>
-                code
-            | EPipe(at, value, _, ELambda(_, Lambda(_, _, cases))) =>
-                Patterns.convertAndCheck(self.otherModules, cases)
-                if(!last && !break) {"do "}.else {""} +
-                "{\nconst _1 = " + self.emitTerm(value, async) + ";\n" +
-                cases.pairs().map {| Pair(i, c) =>
-                    let lastCase = i == cases.size() - 1
-                    self.emitCase(["_1"], c, [], [], True, last, break, lastCase, async)
-                }.join("\n") +
-                "\n}" + if(!last && !break) {" while(false)"}.else {""}
-            | _ =>
-                detectIfElse(term).{
-                    | [] =>
-                        if(break) {
-                            "if(!" + self.emitComma(term, async) + ") break"
-                        } elseIf {last} {
-                            "return " + self.emitTerm(term, async)
-                        } else {
-                            self.emitTerm(term, async)
-                        }
-                    | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
-                        let initial = "{\n" + self.emitStatements(elseBody, last, break, async) + "\n}"
-                        list.foldLeft(initial) {| otherwise, Pair(condition, body) =>
-                            "if(" + self.emitTerm(condition, async) + ") {\n" +
-                            self.emitStatements(body, last, break, async) + "\n} else " + otherwise
-                        }
-                    | list {!last} =>
-                        list.foldLeft("{}") {| otherwise, Pair(condition, body) =>
-                            "if(" + self.emitTerm(condition, async) + ") {\n" +
-                            self.emitStatements(body, last, break, async) + "\n} else " + otherwise
-                        }
-                    | list =>
-                        list.foldLeft("return ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
-                            "if(" + self.emitTerm(condition, async) + ") {\n" +
-                            "return ff_core_Option.Some(" + self.emitTerm(body, async) + ")\n} else " + otherwise
-                        }
-                }
-        }
-    }
-    
-    emitSpecialCall(
-        term: Term
-        async: Bool
-        name: String
-        arguments: List[Term]
-        dictionaries: List[Dictionary]
-    ): Option[String] {
-        name.{
-            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [value]} =>
-                Some("(" + operator + self.emitTerm(value, async) + ")")
-            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [left, right]}  =>
-                Some("(" + self.emitTerm(left, async) + " " + operator + " " + self.emitTerm(right, async) + ")")
-            | "ff:core/List.List_grab" {arguments | [e1, e2]} {noSideEffects(e1) && noSideEffects(e2)} =>
-                let code1 = self.emitTerm(e1, async)
-                let code2 = self.emitTerm(e2, async)
-                Some(
-                    "(" + code1 + "[" + code2 + "] ?? " + 
-                    "ff_core_List.List_grab(" + code1 + ", " + code2 + "))"
-                )
-            | "ff:core/Array.Array_grab" {arguments | [e1, e2]} {noSideEffects(e1) && noSideEffects(e2)} =>
-                let code1 = self.emitTerm(e1, async)
-                let code2 = self.emitTerm(e2, async)
-                Some(
-                    "(" + code1 + ".array[" + code2 + "] ?? " + 
-                    "ff_core_Array.Array_grab(" + code1 + ", " + code2 + "))"
-                )
-            | "ff:core/List.List_size" {arguments | [e]} =>
-                Some(
-                    self.emitTerm(e, async) + ".length"
-                )
-            | "ff:core/Array.Array_size" {arguments | [e]} =>
-                Some(
-                    self.emitTerm(e, async) + ".array.length"
-                )
-            | "ff:core/String.String_size" {arguments | [e]} =>
-                Some(
-                    self.emitTerm(e, async) + ".length"
-                )
-            | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
-            } =>
-                Some("(" + self.emitTerm(left, async) + " === " + self.emitTerm(right, async) + ")")
-            | "ff:core/Equal.notEquals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
-            } =>
-                Some("(" + self.emitTerm(left, async) + " !== " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.before" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName)
-            } =>
-                Some("(" + self.emitTerm(left, async) + " < " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.notBefore" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName)
-            } =>
-                Some("(" + self.emitTerm(left, async) + " >= " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.after" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName)
-            } =>
-                Some("(" + self.emitTerm(left, async) + " > " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.notAfter" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
-                primitiveTypes.contains(typeName)
-            } =>
-                Some("(" + self.emitTerm(left, async) + " <= " + self.emitTerm(right, async) + ")")
-            | "ff:core/List.fillBy" {term | ECall call} {arguments | [size, ELambda(at,
-                Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)@c])@l
-            )]} {
-                !effectTypeIsAsync(call.effect)
-            } =>
-                let n = name.map {escapeResolved(_)}.else {"i"}
-                let newAsync = self.emittingAsync && effectTypeIsAsync(call.effect)
-                let await = if(newAsync) {"await "} else {""}
-                Some(
-                    await + "((() => {\n" +
-                    "const size = " + self.emitTerm(size, async) + ";\n" + // Not correct if async and body isn't
-                    "const result = [];\n" +
-                    "for(let " + n + " = 0; " + n + " < size; " + n + "++) {\n" +
-                    "result.push(" + self.emitTerm(body, newAsync) + ");\n" +
-                    "}\n" +
-                    "return result;\n" +
-                    "})())"
-                )
-            | "ff:core/Js.import" {arguments | [EString(_, url)]} =>
-                self.emitTarget.{
-                    | EmitBrowser => Some("(() => {throw new Error('Node.js imports are not supported in the browser')})()")
-                    | _ => Some(self.jsImporter.add(url.replace("\"", "")))
-                }
-            | "ff:core/Js.browserImport" {arguments | [EString(_, url)]} =>
-                self.emitTarget.{
-                    | EmitBrowser => Some(self.jsImporter.add(url.replace("\"", "")))
-                    | _ => Some("(() => {throw new Error('Browser imports are not supported in Node.js')})()")
-                }
-            | "ff:core/Js.dynamicImport" {arguments | [url]} =>
-                Some("import(" + self.emitTerm(url, async) + ")")
-            | "ff:core/Js.await" {arguments | [body]} =>
-                if(async) {
-                    Some("(await " + self.emitTerm(body, async) + ")")
-                } else {
-                    Some(self.emitTerm(body, async))
-                }
-            | name {name.removeFirst("ff:core/Js.async") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [ELambda(at, Lambda(_, effect, [MatchCase(_, patterns, [], body)]))]
-            } {
-                patterns.all {| PVariable _ => True | _ => False }
-            } =>
-                let patternParameters = patterns.map {
-                    | PVariable p => p.name.map(escapeKeyword).else {"_"}
-                    | _ => panic("!")
-                }
-                Some(
-                    "async (" + patternParameters.join(", ") + ") => {\n" + 
-                    self.emitStatements(body, True, False, False) + 
-                    "\n}"
-                )
-            | name {name.startsWith("ff:core/Js.async")} =>
-                throw(CompileError(term.at, "JS async functions must take a simple parameter list"))
-            | "ff:core/Js.cancelled" =>
-                Some(if(async) {"$task.controller_.signal.aborted"} else {"false"})
-            | "ff:core/Js.throwIfCancelled" =>
-                Some(if(async) {"((() => ff_core_Task.Task_throwIfAborted($task))())"} else {""})
-            | "ff:core/Js.currentTask" =>
-                Some("$task")
-            | "ff:core/Js.controller" =>
-                Some("$task.controller_")
-            | "ff:core/Js.setController" {arguments | [a]} =>
-                Some("($task.controller_ = " + self.emitTerm(a, async) + ")")
-            | "ff:core/Js.inAsync" =>
-                Some(if(self.emittingAsync) {"true"} else {"false"})
-            | "ff:core/Js.inBrowser" =>
-                Some(if(self.emitTarget == EmitBrowser) {"true"} else {"false"})
-            | "ff:core/Js.inNode" =>
-                Some(if(self.emitTarget == EmitNode) {"true"} else {"false"})
-            | "ff:core/Js.inBuild" =>
-                Some(if(self.emitTarget == EmitBuild) {"true"} else {"false"})
-            | "ff:core/Js.value" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Js.fromValue" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Js.rawIdentifier" {arguments | [EString(_, op)]} =>
-                Some(op.replace("\"", ""))
-            | "ff:core/Js.unaryOperator" {arguments | [EString(_, op), a1]} =>
-                Some("(" + op.replace("\"", "") + self.emitTerm(a1, async) + ")")
-            | "ff:core/Js.binaryOperator" {arguments | [EString(_, op), a1, a2]} =>
-                Some("(" + self.emitTerm(a1, async) + " " + op.replace("\"", "") + " " + self.emitTerm(a2, async) + ")")
-            | "ff:core/Js.shortCircuitingOperator" {arguments | [EString(_, op), a1, a2]} =>
-                Some("(" + self.emitTerm(a1, async) + " " + op.replace("\"", "") + " " + self.emitTerm(invokeImmediately(a2), async) + ")")
-            | "ff:core/JsValue.JsValue_spreadToArray" {arguments | [e1]} =>
-                Some("[..." + self.emitTerm(e1, async) + "]")
-            | "ff:core/JsValue.JsValue_typeof" {arguments | [e]} =>
-                Some("(typeof " + self.emitTerm(e, async) + ")")
-            | "ff:core/JsValue.JsValue_instanceof" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " instanceof " + self.emitTerm(e2, async) + ")")
-            | "ff:core/JsValue.JsValue_get" {arguments | [e1, e2]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async))
-            | "ff:core/JsValue.JsValue_equals" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " === " + self.emitTerm(e2, async) + ")")
-            | "ff:core/JsValue.JsValue_notEquals" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " !== " + self.emitTerm(e2, async) + ")")
-            | "ff:core/Int.Int_bitAnd" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " & " + self.emitTerm(e2, async) + ")")
-            | "ff:core/Int.Int_bitRightUnsigned" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " >>> " + self.emitTerm(e2, async) + ")")
-            | "ff:core/Int.Int_bitRight" {arguments | [e1, e2]} =>
-                Some("(" + self.emitTerm(e1, async) + " >> " + self.emitTerm(e2, async) + ")")
-            | name {name.removeFirst("ff:core/JsValue.JsValue_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1, e2, ...es]
-            } =>
-                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + "(" + argumentCode + ")")
-            | name {name.removeFirst("ff:core/JsValue.JsValue_callValue") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1, ...es]
-            } =>
-                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
-                Some(self.emitTerm(e1, async) + "(" + argumentCode + ")")
-            | name {name.removeFirst("ff:core/JsValue.JsValue_new") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1, ...es]
-            } =>
-                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
-                Some("(new " + self.emitTerm(e1, async) + "(" + argumentCode + ")" + ")")
-            | name {name == "ff:core/JsValue.JsValue_with" || name == "ff:core/Json.Json_with"} =>
-                function go(e: Term, fields: List[Pair[Term, Term]]): String {
-                    e.{
-                        | ECall(_, StaticCall(n, _, _), _, _, [a1, a2, a3], _) {n == name} =>
-                            go(a1.value, [Pair(a2.value, a3.value), ...fields])
-                        | ECall(_, StaticCall(n, _, _), _, _, as, _) {
-                            n == "ff:core/JsSystem.JsSystem_object" || 
-                            n == "ff:core/JsSystem.JsSystem_new0" ||
-                            n == "ff:core/Js.object" || 
-                            n == "ff:core/Js.new0" ||
-                            n == "ff:core/Json.Json_object" ||
-                            n == "ff:core/Json.Json_new0"
-                        } {
-                            as.all {noSideEffects(_.value)}
-                        } =>
-                            "{" + fields.map {p =>
-                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
-                            }.join(", ") + "}"
-                        | _ =>
-                            "{..." + self.emitTerm(e, async) + ", " + fields.map {p =>
-                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
-                            }.join(", ") + "}"
-                    }
-                }
-                Some(go(term, []))
-            | name {name.removeFirst("ff:core/JsSystem.JsSystem_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1, EString(_, q)@e2, ...es]
-            } {noSideEffects(e1)} =>
-                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
-                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"} + "(" + argumentCode + ")")
-            | name {name.removeFirst("ff:core/JsSystem.JsSystem_function") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1, e2]
-            } {noSideEffects(e1)} {term | ECall call} {!effectTypeIsAsync(call.effect)} =>
-                Some(self.emitTerm(e2, async))
-            | "ff:core/JsSystem.JsSystem_get" {arguments | [e1, EString(_, q)@e2]} {noSideEffects(e1)} =>
-                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"})
-            | "ff:core/JsSystem.JsSystem_object" {arguments | [e]} {noSideEffects(e)} =>
-                Some("{}")
-            | "ff:core/JsSystem.JsSystem_new0" {arguments | [e]} {noSideEffects(e)} =>
-                Some("{}")
-            | "ff:core/JsSystem.JsSystem_null" {arguments | [e]} {noSideEffects(e)} =>
-                Some("null")
-            | "ff:core/JsSystem.JsSystem_undefined" {arguments | [e]} {noSideEffects(e)} =>
-                Some("(void 0)")
-            | name {name.removeFirst("ff:core/Js.call") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [EString(_, q)@e1, ...es]
-            } =>
-                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
-                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e1, async) + "]"} + "(" + argumentCode + ")")
-            | name {name.removeFirst("ff:core/Js.function") | Some(n)} {n.all {_.isAsciiDigit()}} {
-                arguments | [e1]
-            } {term | ECall call} =>
-                if(self.emittingAsync && effectTypeIsAsync(call.effect)) {
-                    let argumentCode = 1.to(n.grabInt()).map {"a_" + _}.join(", ")
-                    let taskCode = if(argumentCode == "") {"$task"} else {", $task"}
-                    Some("(async (" + argumentCode + ") => await " + self.emitTerm(e1, async) + "(" + argumentCode + taskCode + "))")
-                } else {
-                    Some(self.emitTerm(e1, async))
-                }
-            | "ff:core/Js.get" {arguments | [EString(_, q)@e1]} =>
-                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e1, async) + "]"})
-            | "ff:core/Js.object" =>
-                Some("{}")
-            | "ff:core/Js.new0" =>
-                Some("{}")
-            | "ff:core/Js.null" =>
-                Some("null")
-            | "ff:core/Js.undefined" =>
-                Some("(void 0)")
-            | "ff:core/Js.globalThis" =>
-                Some("globalThis")
-            | "ff:core/BrowserSystem.BrowserSystem_js" {arguments | [e]} {noSideEffects(e)} => 
-                Some("globalThis")
-            | "ff:core/BuildSystem.BuildSystem_js" {arguments | [e]} {noSideEffects(e)} => 
-                Some("globalThis")
-            | "ff:core/NodeSystem.NodeSystem_js" {arguments | [e]} {noSideEffects(e)} => 
-                Some("globalThis")
-            | "ff:core/Js.jsSystem" =>
-                Some("globalThis")
-            | "ff:core/Json.string" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Json.int" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Json.float" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Json.bool" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Json.array" {arguments | [e]} =>
-                Some(self.emitTerm(e, async))
-            | "ff:core/Json.null" {arguments | [e]} =>
-                Some("null")
-            | "ff:core/Json.object" {arguments | [e]} =>
-                Some("{}")
-            | _ =>
-                None
-        }
-    }
-    
-    emitSpecialStatement(
-        term: Term 
-        last: Bool 
-        async: Bool 
-        name: String
-        arguments: List[Term]
-        dictionaries: List[Dictionary]
-    ): Option[String] {
-        name.{
-            | "ff:core/Core.while" {arguments | [condition, body]} =>
-                Some(
-                    "while(" + self.emitComma(invokeImmediately(condition), async) + ") {\n" +
-                    self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
-                )
-            | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
-                invokeImmediately(doWhileBody) | body
-            } =>
-                Some(
-                    "while(true) {\n" +
-                    self.emitStatements(body, False, True, async) +
-                    "\n}"
-                )
-            | "ff:core/Option.Option_each" {arguments | [list, ELambda(_, Lambda(_, _, [
-                MatchCase(_, [PVariable(_, name)], [], body)
-            ]))]} =>
-                Some(
-                    "{\nconst if_o = " + self.emitTerm(list, async) + "\nif(if_o.Some) {\n" +
-                        name.map {"const " + escapeKeyword(_) + " = if_o.value_;\n"}.else {""} +
-                        self.emitStatements(body, last, False, async) +
-                    "\n}\n}"
-                )
-            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
-                ECall(_, StaticCall(r, _, _), _, _, [start, end], _)
-                ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))
-            ]} {r == "ff:core/Int.Int_until" || r == "ff:core/Int.Int_to"} =>
-                let startCode = self.emitTerm(start.value, async)
-                let endCode = self.emitTerm(end.value, async)
-                let op = if(r == "ff:core/Int.Int_until") {"<"} else {"<="}
-                Some(
-                    "for(let " +
-                    "for_i = " + startCode + ", for_e = " + endCode + "; for_i " + op + " for_e; for_i++) {\n" +
-                        name.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
-                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
-                    "\n}"
-                )
-            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
-                ECall(_, StaticCall("ff:core/List.List_reverse", _, _), _, _, [
-                    Argument(_, _, ECall(_, StaticCall(r, _, _), _, _, [start, end], _))
-                ], _)
-                ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))
-            ]} {r == "ff:core/Int.Int_until" || r == "ff:core/Int.Int_to"} =>
-                let startCode = self.emitTerm(start.value, async)
-                let endCode = self.emitTerm(end.value, async)
-                let delta = if(r == "ff:core/Int.Int_until") {" - 1"} else {""}
-                Some(
-                    "for(let " +
-                    "for_e = " + startCode + ", for_i = " + endCode + delta + "; for_i >= for_e; for_i--) {\n" +
-                        name.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
-                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
-                    "\n}"
-                )
-            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
-                ECall(_, StaticCall("ff:core/List.List_zip", _, _), _, _, [list1, list2], _)
-                ELambda(_, Lambda(_, _, [MatchCase(_, [
-                    PVariant(_, "ff:core/Pair.Pair", [PVariable(_, name1), PVariable(_, name2)])
-                ], [], body)]))
-            ]} =>
-                let fusion1 = self.emitLightFusion("for_a", list1.value, async)
-                let fusion2 = self.emitLightFusion("for_a2", list2.value, async)
-                let start1 = fusion1.second.first
-                let end1 = fusion1.second.second
-                let listCode1 = fusion1.first
-                let start2 = fusion2.second.first
-                let end2 = fusion2.second.second
-                let listCode2 = fusion2.first
-                Some(
-                    "for(let for_a = " + listCode1 + ", for_i = " + start1 + ", for_l = " + end1 + ", " +
-                    "for_a2 = " + listCode2 + ", for_i2 = " + start2 + ", for_l2 = " + end2 + 
-                    "; for_i < for_l && for_i2 < for_l2; for_i++, for_i2++) {\n" +
-                        name1.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
-                        name2.map {"const " + escapeKeyword(_) + " = for_a2[for_i2];\n"}.else {""} +
-                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
-                    "\n}"
-                )
-            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
-                ECall(_, StaticCall("ff:core/List.List_pairs", _, _), _, _, [list], _)
-                ELambda(_, Lambda(_, _, [MatchCase(_, [
-                    PVariant(_, "ff:core/Pair.Pair", [PVariable(_, name1), PVariable(_, name2)])
-                ], [], body)]))
-            ]} =>
-                let fusion = self.emitLightFusion("for_a", list.value, async)
-                let start = fusion.second.first
-                let end = fusion.second.second
-                let listCode = fusion.first
-                Some(
-                    "for(let for_a = " + listCode + ", for_i = " + start + ", for_l = " + end + 
-                    "; for_i < for_l; for_i++) {\n" +
-                        name1.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
-                        name2.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
-                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
-                    "\n}"
-                )
-            | n {
-                n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile" || 
-                n == "ff:core/Array.Array_each" || n == "ff:core/Array.Array_eachWhile"
-            } {
-                arguments | [list, ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))]
-            } =>
-                let fusion = self.emitLightFusion("for_a", list, async)
-                let start = fusion.second.first
-                let end = fusion.second.second
-                let listCode = fusion.first + if(n.startsWith("ff:core/Array.")) {".array"} else {""}
-                Some(
-                    "for(let for_a = " + listCode + ", for_i = " + start + ", for_l = " + end + 
-                    "; for_i < for_l; for_i++) {\n" +
-                        name.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
-                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
-                    "\n}"
-                )
-            | "ff:core/Array.Array_push" {arguments | [array, value]} =>
-                Some(self.emitTerm(array, async) + ".array.push(" + self.emitTerm(value, async) + ")")
-            | "ff:core/Core.if" {arguments | [condition, body]} =>
-                Some(
-                    "if(" + self.emitComma(condition, async) + ") {\n" +
-                    if(last) {
-                        "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body), async) +
-                        ")\n} else return ff_core_Option.None()"
-                    } else {
-                        self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
-                    }
-                )
-            | "ff:core/Core.throw" {term | ECall c} {c.arguments | [argument]} {dictionaries | [dictionary]} =>
-                let d = self.emitDictionary(dictionary)
-                let a = self.emitArgument(term.at, argument, async)
-                Some("throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(" + a + ", " + d + ")})")
-            | "ff:core/Try.Try_catch" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
-                Some(code)
-            | "ff:core/Try.Try_catchAny" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
-                Some(code)
-            | "ff:core/Try.Try_finally" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
-                Some(code)
-            | "ff:core/Js.throwIfCancelled" =>
-                Some(if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""})
-            | "ff:core/Js.throw" {term | ECall c} {c.arguments | [argument]} =>
-                Some("throw " + self.emitTerm(argument.value, async))
-            | "ff:core/JsValue.JsValue_set" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_increment" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_decrement" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_set" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_increment" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_decrement" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e3, async))
-            | "ff:core/Js.set" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e2, async))
-            | "ff:core/Js.increment" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e2, async))
-            | "ff:core/Js.decrement" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e2, async))
-            | _ =>
-                None
-        }
-    }
-    
-    emitLightFusion(listName: String, list: Term, async: Bool): Pair[String, Pair[String, String]] {
-        mutable start = "0"
-        mutable end = listName + ".length"
-        let listCode = list.{
-            | ECall(_, StaticCall("ff:core/List.List_dropFirst", _, _), _, _, [a1, a2], _) =>
-                start = self.emitTerm(a2.value, async)
-                if(!start.all {_.isAsciiDigit()}) {
-                    start = "Math.max(" + start + ", 0)"
-                }
-                self.emitTerm(a1.value, async)
-            | ECall(_, StaticCall("ff:core/List.List_dropLast", _, _), _, _, [a1, a2], _) =>
-                let count = self.emitTerm(a2.value, async)
-                if(!count.all {_.isAsciiDigit()}) {
-                    end = end + " - Math.max(" + count + ", 0)"
-                } else {
-                    end = end + " - " + count
-                }
-                self.emitTerm(a1.value, async)
-            | ECall(_, StaticCall("ff:core/List.List_takeFirst", _, _), _, _, [a1, a2], _) =>
-                end = self.emitTerm(a2.value, async)
-                if(!end.all {_.isAsciiDigit()}) {
-                    end = "Math.max(" + end + ", 0)"
-                }
-                end = "Math.min(" + end + ", " + listName + ".length)"
-                self.emitTerm(a1.value, async)
-            | ECall(_, StaticCall("ff:core/List.List_takeLast", _, _), _, _, [a1, a2], _) =>
-                let count = self.emitTerm(a2.value, async)
-                if(!count.all {_.isAsciiDigit()}) {
-                    start = "Math.max(" + listName + ".length - Math.max(" + count + ", 0), 0)"
-                } else {
-                    start = "Math.max(" + listName + ".length - " + count + ", 0)"
-                }
-                self.emitTerm(a1.value, async)
-            | _ => 
-                self.emitTerm(list, async)
-        } 
-        Pair(listCode, Pair(start, end))
-    }
-
-    emitTryCatchFinally(term: Term, last: Bool, async: Bool): Option[String] {
-        function emitCatch(catchEffect: Type, cases: List[MatchCase]): String {
-            let catchAsync = self.emittingAsync && effectTypeIsAsync(catchEffect)
-            Patterns.convertAndCheck(self.otherModules, cases)
-            let arguments = ["_exception.value_", "_error"]
-            cases.{
-                | [case] =>
-                    self.emitCase(arguments, case, [], [], False, last, False, True, catchAsync)
-                | cs =>
-                    let caseStrings = cases.pairs().map {| Pair(i, c) =>
-                        let lastCase = i == cases.size() - 1
-                        self.emitCase(arguments, c, [], [], True, last, False, lastCase, catchAsync)
-                    }
-                    if(last) {caseStrings.join("\n")} else {"do {\n" + caseStrings.join("\n") + "\n} while(false)"}
-            }
-        }
-        term.{
-            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
-                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
-                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
-                ], _))
-                Argument(_, _, ELambda(_, Lambda(_, finallyEffect, [MatchCase(_, [], [], finallyBody)])))
-            ], _) =>
-                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
-                let finallyAsync = self.emittingAsync && effectTypeIsAsync(finallyEffect)
-                Some(
-                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
-                    "\n} finally {\n" + self.emitStatements(finallyBody, last, False, finallyAsync) + "\n}"
-                )
-            | ECall(_, StaticCall("ff:core/Try.Try_catchAny", _, _), _, _, [
-                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
-                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
-                ], _))
-                Argument(_, _, ELambda(_, Lambda(_, catchEffect, [MatchCase(_, [PVariable(_, name)], [], catchBody)])))
-            ], _) =>
-                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
-                Some(
-                    "try {\n" + 
-                        self.emitStatements(tryBody, last, False, tryAsync) +
-                    "\n} catch" + name.map {"(" + escapeKeyword(_) + ")"}.else {""} + " {\n" +
-                        self.emitStatements(catchBody, last, False, tryAsync) +
-                    "\n}"
-                )
-            | ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
-                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
-                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
-                ], _))
-                Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
-            ], [dictionary]) =>
-                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
-                let d = self.emitDictionary(dictionary)
-                Some(
-                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
-                    "\n} catch(_error) {\n" +
-                        "if(!_error.ffException) throw _error\n" +
-                        "const _exception = ff_core_Any.fromAny_(_error.ffException, " + d + ")\n" +
-                        "if(!_exception.Some) throw _error\n" +
-                        emitCatch(catchEffect, cases) +
-                    "\n}"
-                )
-            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
-                Argument(_, _, ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
-                    Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
-                        Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
-                    ], _))
-                    Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
-                ], [dictionary]))
-                Argument(_, _, ELambda(_, Lambda(_, finallyEffect, [MatchCase(_, [], [], finallyBody)])))
-            ], _) =>
-                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
-                let finallyAsync = self.emittingAsync && effectTypeIsAsync(finallyEffect)
-                let d = self.emitDictionary(dictionary)
-                Some(
-                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
-                    "\n} catch(_error) {\n" +
-                        "if(!_error.ffException) throw _error\n" +
-                        "const _exception = ff_core_Any.fromAny_(_error.ffException, " + d + ")\n" +
-                        "if(!_exception.Some) throw _error\n" +
-                        emitCatch(catchEffect, cases) +
-                    "\n} finally {\n" + self.emitStatements(finallyBody, last, False, finallyAsync) + "\n}"
-                )
-            | _ =>
-                None
-        }
-    }
-
-    emitCase(
-        arguments: List[String]
-        matchCase: MatchCase
-        conditions: List[String]
-        variables: List[String]
-        jump: Bool
-        last: Bool
-        break: Bool
-        lastCase: Bool
-        async: Bool
-    ): String {
-        function emitWrapper(code: String): String {
-            if(conditions.isEmpty()) {"{\n"} else {
-                "if(" + conditions.join(" && ") + ") {\n"
-            } +
-            variables.join() +
-            code +
-            "\n}"
-        }
-        Pair(matchCase.patterns, matchCase.guards).{
-            | Pair([p, ...ps], _) =>
-                self.emitPattern(
-                    arguments.grab(0)
-                    p
-                    arguments.dropFirst()
-                    matchCase.MatchCase(patterns = ps)
-                    conditions
-                    variables
-                    jump
-                    last
-                    break
-                    lastCase
-                    async
-                )
-            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) {variables.isEmpty()} =>
-                let newCase = matchCase.MatchCase(patterns = [], guards = [])
-                self.emitCase([], newCase, [...conditions, self.emitTerm(e, async)], [], jump, last, break, lastCase, async)
-            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) =>
-                let newCase = matchCase.MatchCase(patterns = [], guards = [])
-                let code = self.emitCase([], newCase, [self.emitTerm(e, async)], [], jump, last, break, lastCase, async)
-                emitWrapper(code)
-            | Pair([], [guard, ...guards]) =>
-                let guardName = "_guard" + (guards.size() + 1)
-                let newCase = matchCase.MatchCase(patterns = [guard.pattern], guards = guards)
-                let code = 
-                    "const " + guardName + " = " + self.emitTerm(guard.term, async) + ";\n" +
-                    self.emitCase([guardName], newCase, [], [], jump, last, break, lastCase, async)
-                emitWrapper(code)
-            | Pair([], []) =>
-                let statementsCode = self.emitStatements(matchCase.body, last, break, async)
-                let lastLine = statementsCode.reverse().takeWhile {_ != '\n'}.reverse()
-                let returns = 
-                    lastLine.startsWith("return ") || 
-                    lastLine.startsWith("break ") ||
-                    lastLine.startsWith("continue ") ||
-                    lastLine.startsWith("return;") || 
-                    lastLine.startsWith("break;") ||
-                    lastLine.startsWith("continue;") ||
-                    lastLine.startsWith("throw ")
-                let code = statementsCode + if(jump && last && !returns) {
-                    "\nreturn"
-                } elseIf {jump && !returns && !lastCase} {
-                    if(break) {"\ncontinue"} else {"\nbreak"}
-                } else {
-                    ""
-                }
-                emitWrapper(code)
-        }
-    }
-
-    emitPattern(
-        argument: String
-        pattern: MatchPattern
-        arguments: List[String]
-        matchCase: MatchCase
-        conditions: List[String]
-        variables: List[String]
-        jump: Bool
-        last: Bool
-        break: Bool
-        lastCase: Bool
-        async: Bool
-    ): String {
-        function addCondition(condition: String): List[String] {
-            if(lastCase) {conditions} else {[...conditions, condition]}
-        }
-        pattern.{
-            | PString(_, value) =>
-                let newConditions = addCondition(argument + " === " + value)
-                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
-            | PInt(_, value) =>
-                let newConditions = addCondition(argument + " === " + value)
-                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
-            | PChar(_, value) =>
-                let newConditions = addCondition(argument + " === " + charLiteralToNumber(value))
-                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
-            | PVariable(_, None) =>
-                self.emitCase(arguments, matchCase, conditions, variables, jump, last, break, lastCase, async)
-            | PVariable(_, Some(name)) =>
-                let escaped = escapeKeyword(name)
-                let newVariables = if(escaped != argument) {
-                    [...variables, "const " + escaped + " = " + argument + ";\n"]
-                } else {variables}
-                self.emitCase(arguments, matchCase, conditions, newVariables, jump, last, break, lastCase, async)
-            | PVariant(_, "ff:core/Bool.False", []) =>
-                self.emitCase(arguments, matchCase, addCondition("!" + argument), variables, jump, last, break, lastCase, async)
-            | PVariant(_, "ff:core/Bool.True", []) =>
-                self.emitCase(arguments, matchCase, addCondition(argument), variables, jump, last, break, lastCase, async)
-            | PVariant(_, emptyOrLink, _) {emptyOrLink == "List$Empty" || emptyOrLink == "List$Link"} =>
-                mutable restPattern = None
-                function listPatterns(matchPattern: MatchPattern): List[MatchPattern] {
-                    | PVariant(_, "List$Empty", []) => 
-                        []
-                    | PVariant(_, "List$Link", [head, tail]) =>
-                        [head, ...listPatterns(tail)]
-                    | p =>
-                        restPattern = Some(p)
-                        []
-                }
-                let patterns = listPatterns(pattern)
-                let itemArguments = patterns.pairs().map {| Pair(i, _) => argument + "[" + i + "]"}
-                let restArgument = restPattern.map {_ => argument + ".slice(" + patterns.size() + ")"}
-                let newArguments = [...itemArguments, ...restArgument.toList(), ...arguments]
-                let newMatchCase = matchCase.MatchCase(
-                    patterns = [...patterns, ...restPattern.toList(), ...matchCase.patterns]
-                )
-                let operator = restPattern.map {_ => ">="}.else {"==="}
-                let newConditions = addCondition(argument + ".length " + operator + " " + patterns.size())
-                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, break, lastCase, async)
-            | PVariant(_, name, patterns) =>
-                let processed = self.processVariantCase(name, argument)
-                let newMatchCase = matchCase.MatchCase(patterns = [...patterns, ...matchCase.patterns])
-                let newConditions = if(processed.loneVariant || lastCase) {conditions} else {
-                    [...conditions, argument + "." + processed.variantName]
-                }
-                let newArguments = [...processed.arguments, ...arguments]
-                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, break, lastCase, async)
-            | PVariantAs(at, name, variableAt, variable) =>
-                let processed = self.processVariantCase(name, argument)
-                let newConditions = if(processed.loneVariant || lastCase) {conditions} else {
-                    [...conditions, argument + "." + processed.variantName]
-                }
-                let newVariables = variable.map(escapeKeyword).filter {_ != argument}.map {
-                    [...variables, "const " + _ + " = " + argument + ";\n"]
-                }.else {[]}
-                self.emitCase(arguments, matchCase, newConditions, newVariables, jump, last, break, lastCase, async)
-            | PAlias(_, pattern, variable) =>
-                let escaped = escapeKeyword(variable)
-                let newVariables = if(escaped != argument) {
-                    [...variables, "const " + escaped + " = " + argument + ";\n"]
-                } else {variables}
-                self.emitPattern(argument, pattern, arguments, matchCase, conditions, newVariables, jump, last, break, lastCase, async)
-        }
-    }
-
-    emitList(items: List[Pair[Term, Bool]], async: Bool): String {
-        "[" + items.map {
-            | Pair(item, False) => self.emitTerm(item, async)
-            | Pair(item, True) => "..." + self.emitTerm(item, async)
-        }.join(", ") + "]"
-    }
-
-    processVariantCase(name: String, argument: String): ProcessedVariantCase {
-        let variantNameUnqualified = name.reverse().takeWhile {_ != '.'}.reverse()
-        let variantName = escapeKeyword(variantNameUnqualified)
-        let moduleName = name.dropLast(variantNameUnqualified.size() + 1)
-        let variantModule = self.otherModules.grab(moduleName)
-        mutable newtype = False
-        mutable loneVariant = False
-        let newArguments = variantModule.types.collectFirst {definition =>
-            definition.variants.find {_.name == variantName }.map {variant =>
-                newtype = definition.newtype
-                loneVariant = definition.variants.size() == 1
-                [...definition.commonFields.map {_.name}, ...variant.fields.map {_.name}]
-            }
-        }.grab().map {field => if(newtype) {argument} else {argument + "." + escapeKeyword(field)}}
-        ProcessedVariantCase(variantName, newtype, loneVariant, newArguments)
-    }
-
-    processVariant(name: String): Bool {
-        if(name.startsWith("List$")) {False} else:
-        let variantNameUnqualified = name.reverse().takeWhile {_ != '.'}.reverse()
-        let variantName = escapeKeyword(variantNameUnqualified)
-        let moduleName = name.dropLast(variantNameUnqualified.size() + 1)
-        let variantModule = self.otherModules.grab(moduleName)
-        mutable newtype = False
-        let newArguments = variantModule.types.collectFirst {definition =>
-            definition.variants.find {_.name == variantName}.map {variant =>
-                newtype = definition.newtype
-            }
-        }.grab()
-        newtype
-    }
-
-    emitArgument(callAt: Location, argument: Argument, async: Bool): String {
-        argument.value.{
-            | ECall(_, StaticCall("ff:core/SourceLocation.callSite", _, _), _, _, _, _) => 
-                "\"" + self.moduleName + ":" + callAt.line + ":" + callAt.column + 
-                "," + self.packagePair.group + "," + self.packagePair.name + "\""
-            | value =>
-                self.emitTerm(value, async)
-        }
-    }
-    
-    emitComma(term: Term, async: Bool): String {
-        term.{
-            | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitStatements(before3, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, ESequential(_, before1, before2), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, before, after) {
-                safeCommable(before) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | _ =>
-                self.emitTerm(term, async)
-        }
-    }
-
-}
-
-data ProcessedVariantCase(
-    variantName: String
-    newtype: Bool
-    loneVariant: Bool
-    arguments: List[String]
-)
-
-detectIfElse(term: Term): List[Pair[Term, Term]] {
-    | ECall(at, StaticCall("ff:core/Core.if", _, _), _, _, [condition, body], _) =>
-        [Pair(condition.value, invokeImmediately(body.value))]
-    | ECall(at, StaticCall("ff:core/Option.Option_elseIf", _, _), _, _, [option, condition, body], _) =>
-        let list = detectIfElse(option.value)
-        if(list.isEmpty()) {[]} else:
-        [Pair(invokeImmediately(condition.value), invokeImmediately(body.value)), ...list]
-    | ECall(at, StaticCall("ff:core/Option.Option_else", _, _), _, _, [option, body], _) =>
-        let list = detectIfElse(option.value)
-        if(list.isEmpty()) {[]} else:
-        [Pair(EVariant(at, "ff:core/Bool.True", [], None), invokeImmediately(body.value)), ...list]
-    | _ =>
-        []
-}
-
-invokeImmediately(function: Term): Term {
-    | ELambda(_, Lambda(_, effect, [MatchCase(_, [], [], body)])) =>
-        body
-    | _ =>
-        let effect = TConstructor(function.at, "Q$", []) // Awaits more often than required in async context
-        ECall(function.at, DynamicCall(function, False), effect, [], [], [])
-}
-
-safeCommable(term: Term): Bool {
-    term.{
-        | EField _ => True
-        | EVariable _ => True
-        | EAssign _ => True
-        | EAssignField _ => True
-        | ECall _ => True
-        | ECopy _ => True
-        | EVariant _ => True
-        | EString(_, _) => True
-        | EInt(_, _) => True
-        | EChar(_, _) => True
-        | EFloat(_, _) => True
-        | EList _ => True
-        | EPipe _ => True
-        | ERecord _ => True
-        | EWildcard _ => True 
-        | _ => False
-    }
-}
-
-extractTypeName(type: Type): String {
-    | TVariable(at, index) =>
-        fail(at, "Unexpected type variable: $" + index)
-    | TConstructor t =>
-        t.name
-}
-
-firstTypeName(types: List[Type]): String {
-    types.grabFirst().{
-        | TConstructor t => t.name
-        | TVariable t => fail(t.at, " is still a unification variable")
-    }
-}
-
-makeDictionaryName(traitName: String, typeName: String): String {
-    traitName.replace(".", "_").replace(":", "_").replace("/", "_") + "$" +
-    typeName.replace(".", "_").replace(":", "_").replace("/", "_")
-}
-
-charLiteralToNumber(charLiteral: String): String {
-    | "'\\t'" => "9"
-    | "'\\n'" => "10"
-    | "'\\r'" => "13"
-    | "'\\\"'" => "34"
-    | "'\\''" => "39"
-    | value => "" + value.grab(1).codeUnit
-}
-
-escapeResolved(word: String): String {
-    let parts = word.replace(":", ".").replace("/", ".").split('.')
-    let initialParts = parts.dropLast()
-    if(initialParts.isEmpty()) {
-        escapeKeyword(parts.grabLast())
-    } else {
-        initialParts.join("_") + "." + escapeKeyword(parts.grabLast())
-    }
-}
-
-escapeKeyword(word: String): String {
-    if(word.grabFirst().isAsciiLower()) {word + "_"} else {word}
-}
-
-effectTypeIsAsync(effect: Type): Bool {
-    | TConstructor(_, "Q$", _) => True
-    | _ => False
-}
-
-safeBare(quotedString: String): Option[String] {
-    // TODO: And not a reserved word in JS
-    quotedString.removeFirst("\"").flatMap {_.removeLast("\"")}.filter {s => 
-        s.first().any {_.isAsciiLetter()} && s.all {_.isAsciiLetterOrDigit()}
-    }
-}
-
-noSideEffects(term: Term): Bool {
-    term.{
-        | EField(_, _, e, _) => noSideEffects(e)
-        | EVariable(_, _) => True
-        | ECall(_, StaticCall("ff:core/BrowserSystem.BrowserSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
-        | ECall(_, StaticCall("ff:core/BuildSystem.BuildSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
-        | ECall(_, StaticCall("ff:core/NodeSystem.NodeSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
-        | ECall(_, StaticCall("ff:core/Js.jsSystem", _, _), _, _, _, _) => True
-        | EString(_, _) => True
-        | EInt(_, _) => True
-        | EChar(_, _) => True
-        | EFloat(_, _) => True
-        | _ => False
-    }
-}
-
-primitiveTypes = [
-    "ff:core/Bool.Bool"
-    "ff:core/Char.Char"
-    "ff:core/Int.Int"
-    "ff:core/Float.Float"
-    "ff:core/String.String"
-].toSet()
+import Syntax
+import Patterns
+import JsImporter
+
+class JsEmitter(
+    otherModules: Map[String, Module]
+    jsImporter: JsImporter
+    emitTarget: EmitTarget
+    isMainModule: Bool
+    compilerModuleFileUrl: Option[String]
+    packagePair: PackagePair
+    moduleName: String
+    mutable emittingAsync: Bool
+    mutable tailCallUsed: Bool
+)
+
+data EmitTarget {
+    EmitNode
+    EmitBrowser
+    EmitBuild
+    EmitExecutable
+}
+
+new(
+    otherModules: List[Module]
+    emitTarget: EmitTarget
+    isMainModule: Bool
+    compilerModuleFileUrl: Option[String]
+    packagePair: PackagePair
+    moduleName: String
+): JsEmitter {
+    JsEmitter(
+        otherModules = otherModules.map {m =>
+            let moduleName = m.packagePair.groupName() + "/" + m.file.dropLast(3)
+            Pair(moduleName, m)
+        }.toMap()
+        jsImporter = JsImporter.new()
+        emitTarget = emitTarget
+        isMainModule = isMainModule
+        compilerModuleFileUrl = compilerModuleFileUrl
+        packagePair = packagePair
+        moduleName = moduleName
+        emittingAsync = False
+        tailCallUsed = False
+    )
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}
+
+extend self: JsEmitter {
+
+    emitModule(packagePair: PackagePair, module: Module): String {
+        let selfImport =
+            "import * as " + packagePair.groupName("_") + "_" + module.file.dropLast(3) + " " +
+            "from \"../../" + packagePair.groupName("/") + "/" + module.file.dropLast(3) + ".mjs\""
+        let imports = [
+            self.compilerModuleFileUrl.map {"import * as $firefly_compiler from '" + _ + "'"}.toList()
+            module.imports.sortBy {i => Pair(i.package, i.file) }.map {self.emitImportDefinition(_)}
+        ].flatten()
+        let parts = [
+            if(imports.any {_ == selfImport}) {imports} else {[selfImport, ...imports]}
+            module.types.map {self.emitTypeDefinition(_)}
+            module.lets.map {"export " + self.emitLetDefinition(_, False, False)}
+            module.functions.map {"export " + self.emitFunctionDefinition(_, False)}
+            self.withEmittingAsync {module.functions.map {"export " + self.emitFunctionDefinition(_, True)}}
+            module.extends.map {self.emitExtendsDefinition(_)}
+            module.instances.map {self.emitInstanceDefinition(_)}
+            if(self.isMainModule) {
+                self.emitRun(module.functions, packagePair, packagePair.group == "ff" && packagePair.name == "compiler")
+            } else {[]}
+        ]
+        let ignoreJsImports = if(
+            self.emitTarget == EmitExecutable &&
+            packagePair.group == "ff" &&
+            packagePair.name == "core"
+        ) {["esbuild"]} else {[]}
+        let jsImports = self.jsImporter.generateImports(ignoreJsImports.toSet())
+        [jsImports, ...parts].map {_.join("\n\n")}.join("\n\n") + "\n"
+    }
+
+    withEmittingAsync[T](body: () => T): T {
+        try {
+            self.emittingAsync = True
+            body()
+        } finally {
+            self.emittingAsync = False
+        }
+    }
+
+    emitRun(functions: List[DFunction], mainPackagePair: PackagePair, bootstrapping: Bool): List[String] {
+        let buildMainFunction = functions.find {_.signature.name == "buildMain"}.filter {_ =>
+            self.emitTarget != EmitBrowser && self.emitTarget != EmitExecutable
+        }
+        let willRunOnNode = self.emitTarget != EmitBrowser
+        let targetMain = if(willRunOnNode) {"nodeMain"} else {"browserMain"}
+        let mainFunction =
+            functions.find {_.signature.name == targetMain}.orElse {functions.find {_.signature.name == "main"}}
+        mainFunction.map {_.signature.name}.map {mainName => [[
+            "export async function $run$(fireflyPath_, arguments_) {"
+            "Error.stackTraceLimit = 50"
+            "const $task = {controller_: new AbortController(), subtasks_: new Set(), promise_: new Promise(() => {}), started_: performance.now() * 0.001}"
+            ...if(self.emitTarget != EmitBrowser) {[
+                "let interval = setInterval(() => {}, 24 * 60 * 60 * 1000)" // To prevent deadlocks from exiting node
+            ]} else {[]}
+            "let system = {"
+            "task_: $task,"
+            "array_: arguments_,"
+            "fireflyPath_: fireflyPath_,"
+            "mainPackagePair_: {group_: \"" + mainPackagePair.group + "\", name_: \"" + mainPackagePair.name + "\"},"
+            "executableMode_: " + if(self.emitTarget == EmitExecutable) {"true"} else {"false"} + ","
+            "buildMode_: " + if(self.emitTarget == EmitBuild) {"true"} else {"false"}
+            "}"
+            "try {"
+            ...if(!buildMainFunction.isEmpty()) {[
+                "await buildMain_$(system, $task)"]
+            } else {[]}
+            ...if(self.emitTarget != EmitBuild) {[
+                "await " + mainName + "_$(system, $task)"
+            ]} else {[]}
+            ...if(self.emitTarget == EmitBuild) {[
+                "await $firefly_compiler.internalCreateExecutable_$(system, '.firefly/output/executable/Main.bundle.js', '.firefly/output', ['host'], system.assets_, $task)"
+            ]} else {[]}
+            "} finally {"
+            ...if(self.emitTarget != EmitBrowser) {[
+                "ff_core_Task.Task_abort$($task)"
+                "clearInterval(interval)"
+            ]} else {[]}
+            "}"
+            "}"
+            ...self.emitTarget.{
+                | EmitBrowser => [
+                    "queueMicrotask(async () => {"
+                    "await $run$(null, [])"
+                    "})"
+                ]
+                | EmitNode {bootstrapping} => [
+                    "import * as path from 'node:path'"
+                    "queueMicrotask(async () => {"
+                    "let fireflyPath_ = path.dirname(path.dirname(path.dirname(path.dirname(path.dirname(process.argv[1])))))"
+                    "await $run$(fireflyPath_, process.argv.slice(2))"
+                    "})"
+                ]
+                | EmitExecutable => [
+                    "queueMicrotask(async () => {"
+                    "await $run$(null, process.argv.slice(2))"
+                    "})"
+                ]
+                | _ => []
+            }
+        ].join("\n")]}.else {[]}
+    }
+
+    emitImportDefinition(definition: DImport): String {
+        "import * as " + definition.package.group + "_" + definition.package.name + "_" + definition.file + " " +
+        "from \"../../" + definition.package.group + "/" + definition.package.name + "/" + definition.file + ".mjs\""
+    }
+
+    emitLetDefinition(definition: DLet, mutable: Bool, async: Bool): String {
+        let mutability = if(mutable) {"let"} else {"const"}
+        let valueCode = self.emitTerm(definition.value, async)
+        let assignmentCode = if(!mutable || valueCode != "(void 0)") {" = " + valueCode} else {""}
+        mutability + " " + escapeKeyword(definition.name) + assignmentCode + ";"
+    }
+
+    emitExtendsDefinition(definition: DExtend): String {
+        let typeName = extractTypeName(definition.type).reverse().takeWhile {_ != '.'}.reverse()
+        let methods = definition.methods.map {method =>
+            method.DFunction(
+                signature = method.signature.Signature(
+                    name = typeName + "_" + method.signature.name
+                )
+            )
+        }
+        let syncMethods = methods.map {"export " + self.emitFunctionDefinition(_, False)}
+        let asyncMethods = self.withEmittingAsync {methods.map {"export " + self.emitFunctionDefinition(_, True)}}
+        [...syncMethods, ...asyncMethods].join("\n\n")
+    }
+
+    emitInstanceDefinition(definition: DInstance): String {
+        let name = makeDictionaryName(definition.traitName, firstTypeName(definition.typeArguments))
+        let methods = definition.methods.map {self.emitFunctionDefinition(_, False)}.map {_.dropFirst("function ".size())} // TODO
+        let asyncMethods = self.withEmittingAsync {
+            definition.methods.map {self.emitFunctionDefinition(_, True)}.map {"async " + _.dropFirst("async function ".size())} // TODO
+        }
+        let body = "{\n" + [...methods, ...asyncMethods].join(",\n") + "\n}"
+        definition.constraints.{
+            | [] =>
+                "export const " + name + " = " + body + ";"
+            | constraints =>
+                let dictionaries = constraints.map {c =>
+                    makeDictionaryName(c.name, firstTypeName(c.generics))
+                }
+                "export function " + name + "(" + dictionaries.join(", ") + ") { return " + body + "}"
+        }
+    }
+
+    emitFunctionDefinition(definition: DFunction, async: Bool, suffix: String = ""): String {
+        let signature = self.emitSignature(definition.signature, async, suffix)
+        definition.body.{
+            | Lambda(_, effect, [matchCase]) {
+                matchCase.patterns.all {
+                    | PVariable(_, None) => True
+                    | _ => False
+                }
+            } =>
+                let body = self.emitTailCall {self.emitStatements(matchCase.body, True, False, async)}
+                signature + " {\n" + body + "\n}"
+            | Lambda(_, effect, cases) =>
+                Patterns.convertAndCheck(self.otherModules, cases)
+                let escapedArguments = definition.signature.parameters.map {_.name + "_a"}
+                let shadowingWorkaround = definition.signature.parameters.map {p =>
+                    "const " + p.name + "_a = " + escapeKeyword(p.name) + ";"
+                }.join("\n")
+                let body = self.emitTailCall {
+                    let casesString = cases.pairs().map {| Pair(i, c) =>
+                        let lastCase = i == cases.size() - 1
+                        self.emitCase(escapedArguments, c, [], [], True, True, False, lastCase, async)
+                    }.join("\n")
+                    shadowingWorkaround + "\n" + casesString
+                }
+                signature + " {\n" + body + "\n}"
+        }
+    }
+
+    emitTailCall(body: () => String): String {
+        let outerTailCallUsed = self.tailCallUsed
+        self.tailCallUsed = False
+        let result = body()
+        let tailCallUsed = self.tailCallUsed
+        self.tailCallUsed = outerTailCallUsed
+        if(tailCallUsed) {
+            "_tailcall: for(;;) {\n" + result + "\nreturn\n}"
+        } else {
+            result
+        }
+    }
+
+    emitSignature(signature: Signature, async: Bool, suffix: String = ""): String {
+        let parameterStrings = signature.parameters.map {self.emitParameter(_, async)}
+        let dictionaryStrings = signature.constraints.map {c =>
+            makeDictionaryName(c.name, firstTypeName(c.generics))
+        }
+        let controller = if(async) {["$task"]} else {[]}
+        let parameters = "(" + [...parameterStrings, ...dictionaryStrings, ...controller].join(", ") + ")"
+        let prefix = if(async) {"async "} else {""}
+        let asyncSuffix = if(async) {"$"} else {""}
+        prefix + "function " + escapeKeyword(signature.name) + suffix + asyncSuffix + parameters
+    }
+
+    emitParameter(parameter: Parameter, async: Bool): String {
+        let defaultValue = parameter.default.map {" = " + self.emitTerm(_, async) }.else {""}
+        escapeKeyword(parameter.name) + defaultValue
+    }
+
+    emitTypeDefinition(definition: DType): String {
+        if(definition.newtype) {"// newtype " + definition.name} else:
+        "// type " + definition.name + "\n" +
+        definition.variants.map {self.emitVariantDefinition(definition, _)}.join("\n")
+    }
+
+    emitVariantDefinition(typeDefinition: DType, definition: Variant): String {
+        let allFields = [...typeDefinition.commonFields, ...definition.fields]
+        let fields = allFields.map {escapeKeyword(_.name)}.join(", ")
+        if(allFields.isEmpty()) {
+            "const " + definition.name + "$ = {" + definition.name + ": true};\n" +
+            "export function " + definition.name + "(" + fields + ") {\n" +
+            "return " + definition.name + "$;\n" +
+            "}"
+        } elseIf {typeDefinition.variants.size() == 1} {
+            "export function " + definition.name + "(" + fields + ") {\n" +
+            "return {" + fields + "};\n" +
+            "}"
+        } else {
+            "export function " + definition.name + "(" + fields + ") {\n" +
+            "return {" + definition.name + ": true, " + fields + "};\n" +
+            "}"
+        }
+    }
+
+    emitTerm(term: Term, async: Bool): String {term.{
+        | EString(at, value) {value.startsWith("\"\"\"")} =>
+            "`" + value.dropFirst(3).dropLast(3).replace("`", "\\`") + "`" // TODO: Fix escaping
+        | EString(at, value) => value
+        | EChar(at, value) => charLiteralToNumber(value)
+        | EInt(at, value) => value
+        | EFloat(at, value) => value
+        | EVariable(at, name) => escapeResolved(name)
+        | EList(at, _, items) =>
+            self.emitList(items, async)
+        | EVariant(at, "ff:core/Bool.False", _, _) =>
+            "false"
+        | EVariant(at, "ff:core/Bool.True", _, _) =>
+            "true"
+        | EVariant(at, "ff:core/Unit.Unit", _, _) =>
+            "(void 0)"
+        | EVariant(at, name, _, arguments) =>
+            let argumentsString = arguments.toList().flatten().map {self.emitArgument(at, _, async)}.join(", ")
+            let newtype = self.processVariant(name)
+            if(newtype) {argumentsString} else:
+            escapeResolved(name) + "(" + argumentsString + ")"
+        | EVariantIs(at, "ff:core/Bool.False", _) =>
+            "function(_v) { return !_v ? ff_core_Option.Some(_v) : ff_core_Option.None(); }"
+        | EVariantIs(at, "ff:core/Bool.True", _) =>
+            "function(_v) { return _v ? ff_core_Option.Some(_v) : ff_core_Option.None(); }"
+        | EVariantIs(at, "ff:core/Unit.Unit", _) =>
+            "function(_v) { return ff_core_Option.Some(_v); }"
+        | EVariantIs(at, name, _) =>
+            let n = name.reverse().takeWhile {_ != '.'}.reverse()
+            "(function(_v) { " +
+            "return _v." + escapeResolved(n) + " ? ff_core_Option.Some(_v) : ff_core_Option.None();" +
+            "})"
+        | ECopy(at, name, record, fields) =>
+            let fieldCode = fields.map {f => escapeKeyword(f.name) + " = " + self.emitTerm(f.value, async)}.join(", ")
+            "{..." + self.emitTerm(record, async) + ", " + fieldCode + "}"
+        | EField(at, newtype, record, field) =>
+            if(newtype) {self.emitTerm(record, async)} else:
+            self.emitTerm(record, async) + "." + escapeKeyword(field)
+        | ELambda(at, Lambda(_, effect, [MatchCase(_, patterns, [], body)])) {
+            patterns.all {| PVariable _ => True | _ => False }
+        } =>
+            let newAsync = self.emittingAsync && effectTypeIsAsync(effect)
+            let patternParameters = patterns.map {
+                | PVariable p => p.name.map(escapeKeyword).else {"_"}
+                | _ => panic("!")
+            }
+            let controller = if(newAsync) {["$task"]} else {[]}
+            let parameters = [...patternParameters, ...controller].join(", ")
+            let prefix = if(newAsync) {"async "} else {""}
+            "(" + prefix + "(" + parameters + ") => {\n" + self.emitStatements(body, True, False, newAsync) + "\n})"
+        | ELambda(at, Lambda(_, effect, cases)) =>
+            let newAsync = self.emittingAsync && effectTypeIsAsync(effect)
+            let controller = if(newAsync) {["$task"]} else {[]}
+            Patterns.convertAndCheck(self.otherModules, cases)
+            let arguments = cases.grab(0).patterns.pairs().map {"_" + (_.first + 1)}
+            let escapedArguments = arguments.map(escapeKeyword) // emitCase arguments must be preescaped
+            let caseStrings = cases.pairs().map {| Pair(i, c) =>
+                let lastCase = i == cases.size() - 1
+                self.emitCase(escapedArguments, c, [], [], True, True, False, lastCase, newAsync)
+            }
+            let prefix = if(newAsync) {"async "} else {""}
+            "(" + prefix + "(" + [...escapedArguments, ...controller].join(", ") + ") => " +
+            "{\n" + caseStrings.join("\n") + "\n})"
+        | EPipe(at, value, effect, function) =>
+            let await = async && effectTypeIsAsync(effect)
+            let c = if(await) {", $task"} else {""}
+            let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
+            if(await) {"(await " + call + ")"} else {call}
+        | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
+            self.emitSpecialCall(term, async, name, arguments.map {_.value}, dictionaries) | Some(code)
+        } =>
+            code
+        | ECall(at, StaticCall(name, _, True), effect, typeArguments, arguments, dictionaries) =>
+            let await = async && effectTypeIsAsync(effect)
+            let dictionaryStrings = dictionaries.map {self.emitDictionary(_)}
+            let ds = dictionaryStrings.dropFirst()
+            let d = dictionaryStrings.grabFirst()
+            let asyncSuffix = if(await) {"$"} else {""}
+            let n = escapeKeyword(name.reverse().takeWhile {_ != '.'}.reverse()) + asyncSuffix
+            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
+            let controller = if(await) {["$task"]} else {[]}
+            let call = d + "." + n + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
+            if(await) {"(await " + call + ")"} else {call}
+        | ECall(at, StaticCall(name, _, _), effect, typeArguments, arguments, dictionaries) =>
+            if(name.contains("bundleForBrowser")) { // TODO: Delete this test (for branch arraysonly)
+                if(!arguments.grab(0).name.contains("system")) {
+                    Log.debug("Wrong arguments for bundleForBrowser: " + Show.show(arguments.map {_.name}))
+                    throw(GrabException())
+                }
+            }
+            detectIfElse(term).{
+                | [] =>
+                    let await = async && effectTypeIsAsync(effect)
+                    let ds = dictionaries.map {self.emitDictionary(_)}
+                    let functionCode = escapeResolved(name) + if(await) {"$"} else {""}
+                    let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
+                    let controller = if(await) {["$task"]} else {[]}
+                    let call = functionCode + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
+                    if(await) {"(await " + call + ")"} else {call}
+                | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
+                    "(" + list.foldLeft(self.emitComma(elseBody, async)) {| otherwise, Pair(condition, body) =>
+                        self.emitComma(condition, async) +
+                        "\n? " + self.emitComma(body, async) + "\n: " + otherwise
+                    } + ")"
+                | list =>
+                    "(" + list.foldLeft("ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
+                        self.emitComma(condition, async) +
+                        "\n? ff_core_Option.Some(" + self.emitComma(body, async) + ")\n: " + otherwise
+                    } + ")"
+            }
+        | ECall(at, DynamicCall(function, _), effect, typeArguments, arguments, dictionaries) =>
+            let await = async && effectTypeIsAsync(effect)
+            if(!dictionaries.isEmpty()) {fail(at, "Internal error: Dictionaries in lambda call")}
+            let functionCode = self.emitTerm(function, async)
+            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
+            let controller = if(await) {["$task"]} else {[]}
+            let call = functionCode + "(" + [...emittedArguments, ...controller].join(", ") + ")"
+            if(await) {"(await " + call + ")"} else {call}
+        | ERecord(at, fields) =>
+            if(fields.isEmpty()) {"{}"} else {
+                let list = fields.map {f => escapeKeyword(f.name) + ": " + self.emitTerm(f.value, async)}
+                "{\n" + list.join(",\n") + "\n}"
+            }
+        | EWildcard(at, index) =>
+            if(index == 0) {fail(at, "Unbound wildcard")}
+            "_w" + index
+        | _ {async} =>
+            "(await (async function() {\n" + self.emitStatements(term, True, False, async) + "\n})())"
+        | _ =>
+            "(function() {\n" + self.emitStatements(term, True, False, async) + "\n})()"
+    }}
+    
+    emitField(term: Term, async: Bool, dot: String = "."): String {
+        term.{
+            | EString(_, q) {safeBare(q) | Some(s)} => dot + s
+            | _ => "[" + self.emitTerm(term, async) + "]"
+        }
+    }
+
+    emitDictionary(d: Dictionary): String {
+        let m = if(d.moduleName != "") {
+            d.packagePair.groupName("_") + "_" + d.moduleName.replace("/", "_") + "."
+        } else {""}
+        let c = m + makeDictionaryName(d.traitName, d.typeName)
+        if(d.dictionaries.isEmpty()) {
+            c
+        } else {
+            c + "(" + d.dictionaries.map {self.emitDictionary(_)}.join(", ") + ")"
+        }
+    }
+
+    emitStatements(term: Term, last: Bool, break: Bool, async: Bool): String {
+        term.{
+            | EFunctions(at, functions, body) =>
+                let functionStrings = functions.map {f =>
+                    let newAsync = self.emittingAsync && effectTypeIsAsync(f.signature.effect)
+                    self.emitFunctionDefinition(f, newAsync)
+                }
+                functionStrings.join("\n") + "\n" + self.emitStatements(body, last, break, async)
+            | ELet(at, mutable, name, valueType, value, body) =>
+                self.emitLetDefinition(DLet(at, name, valueType, value), mutable, async) + "\n" +
+                self.emitStatements(body, last, break, async)
+            | EVariant(at, "ff:core/Unit.Unit", _, _) =>
+                ""
+            | ESequential(_, EVariant(_, "ff:core/Unit.Unit", _, _), after) =>
+                self.emitStatements(after, last, break, async)
+            | ESequential(_, before, EVariant(_, "ff:core/Unit.Unit", _, _)) =>
+                self.emitStatements(before, False, break, async)
+            | ESequential(at, before, after) =>
+                self.emitStatements(before, False, False, async) + ";\n" + 
+                self.emitStatements(after, last, break, async)
+            | EAssign(at, operator, name, value) =>
+                escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async)
+            | EAssignField(at, operator, record, field, value) =>
+                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
+                self.emitTerm(value, async)
+            | ECall(at, StaticCall(name, True, instanceCall), effect, _, arguments, _) =>
+                if(instanceCall) {throw(CompileError(at, "Not yet implemented: Tail calls on trait methods."))}
+                self.tailCallUsed = True
+                let pair = arguments.map {a =>
+                    Some(Pair(
+                        "const " + escapeKeyword(a.name.grab() + "_r") + " = " + self.emitTerm(a.value, async) + ";"
+                        escapeKeyword(a.name.grab()) + " = " + escapeKeyword(a.name.grab() + "_r")
+                    ))
+                }.collect {_}.unzip()
+                "{\n" + pair.first.join("\n") + "\n" + pair.second.join("\n") + "\ncontinue _tailcall\n}"
+            | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
+                self.emitSpecialStatement(term, last, async, name, arguments.map {_.value}, dictionaries) | Some(code)
+            } =>
+                code
+            | EPipe(at, value, _, ELambda(_, Lambda(_, _, cases))) =>
+                Patterns.convertAndCheck(self.otherModules, cases)
+                if(!last && !break) {"do "}.else {""} +
+                "{\nconst _1 = " + self.emitTerm(value, async) + ";\n" +
+                cases.pairs().map {| Pair(i, c) =>
+                    let lastCase = i == cases.size() - 1
+                    self.emitCase(["_1"], c, [], [], True, last, break, lastCase, async)
+                }.join("\n") +
+                "\n}" + if(!last && !break) {" while(false)"}.else {""}
+            | _ =>
+                detectIfElse(term).{
+                    | [] =>
+                        if(break) {
+                            "if(!" + self.emitComma(term, async) + ") break"
+                        } elseIf {last} {
+                            "return " + self.emitTerm(term, async)
+                        } else {
+                            self.emitTerm(term, async)
+                        }
+                    | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
+                        let initial = "{\n" + self.emitStatements(elseBody, last, break, async) + "\n}"
+                        list.foldLeft(initial) {| otherwise, Pair(condition, body) =>
+                            "if(" + self.emitTerm(condition, async) + ") {\n" +
+                            self.emitStatements(body, last, break, async) + "\n} else " + otherwise
+                        }
+                    | list {!last} =>
+                        list.foldLeft("{}") {| otherwise, Pair(condition, body) =>
+                            "if(" + self.emitTerm(condition, async) + ") {\n" +
+                            self.emitStatements(body, last, break, async) + "\n} else " + otherwise
+                        }
+                    | list =>
+                        list.foldLeft("return ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
+                            "if(" + self.emitTerm(condition, async) + ") {\n" +
+                            "return ff_core_Option.Some(" + self.emitTerm(body, async) + ")\n} else " + otherwise
+                        }
+                }
+        }
+    }
+    
+    emitSpecialCall(
+        term: Term
+        async: Bool
+        name: String
+        arguments: List[Term]
+        dictionaries: List[Dictionary]
+    ): Option[String] {
+        name.{
+            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [value]} =>
+                Some("(" + operator + self.emitTerm(value, async) + ")")
+            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [left, right]}  =>
+                Some("(" + self.emitTerm(left, async) + " " + operator + " " + self.emitTerm(right, async) + ")")
+            | "ff:core/List.List_grab" {arguments | [e1, e2]} {noSideEffects(e1) && noSideEffects(e2)} =>
+                let code1 = self.emitTerm(e1, async)
+                let code2 = self.emitTerm(e2, async)
+                Some(
+                    "(" + code1 + "[" + code2 + "] ?? " + 
+                    "ff_core_List.List_grab(" + code1 + ", " + code2 + "))"
+                )
+            | "ff:core/Array.Array_grab" {arguments | [e1, e2]} {noSideEffects(e1) && noSideEffects(e2)} =>
+                let code1 = self.emitTerm(e1, async)
+                let code2 = self.emitTerm(e2, async)
+                Some(
+                    "(" + code1 + ".array[" + code2 + "] ?? " + 
+                    "ff_core_Array.Array_grab(" + code1 + ", " + code2 + "))"
+                )
+            | "ff:core/List.List_size" {arguments | [e]} =>
+                Some(
+                    self.emitTerm(e, async) + ".length"
+                )
+            | "ff:core/Array.Array_size" {arguments | [e]} =>
+                Some(
+                    self.emitTerm(e, async) + ".array.length"
+                )
+            | "ff:core/String.String_size" {arguments | [e]} =>
+                Some(
+                    self.emitTerm(e, async) + ".length"
+                )
+            | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
+            } =>
+                Some("(" + self.emitTerm(left, async) + " === " + self.emitTerm(right, async) + ")")
+            | "ff:core/Equal.notEquals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
+            } =>
+                Some("(" + self.emitTerm(left, async) + " !== " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.before" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " < " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.notBefore" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " >= " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.after" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " > " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.notAfter" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " <= " + self.emitTerm(right, async) + ")")
+            | "ff:core/List.fillBy" {term | ECall call} {arguments | [size, ELambda(at,
+                Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)@c])@l
+            )]} {
+                !effectTypeIsAsync(call.effect)
+            } =>
+                let n = name.map {escapeResolved(_)}.else {"i"}
+                let newAsync = self.emittingAsync && effectTypeIsAsync(call.effect)
+                let await = if(newAsync) {"await "} else {""}
+                Some(
+                    await + "((() => {\n" +
+                    "const size = " + self.emitTerm(size, async) + ";\n" + // Not correct if async and body isn't
+                    "const result = [];\n" +
+                    "for(let " + n + " = 0; " + n + " < size; " + n + "++) {\n" +
+                    "result.push(" + self.emitTerm(body, newAsync) + ");\n" +
+                    "}\n" +
+                    "return result;\n" +
+                    "})())"
+                )
+            | "ff:core/Js.import" {arguments | [EString(_, url)]} =>
+                self.emitTarget.{
+                    | EmitBrowser => Some("(() => {throw new Error('Node.js imports are not supported in the browser')})()")
+                    | _ => Some(self.jsImporter.add(url.replace("\"", "")))
+                }
+            | "ff:core/Js.browserImport" {arguments | [EString(_, url)]} =>
+                self.emitTarget.{
+                    | EmitBrowser => Some(self.jsImporter.add(url.replace("\"", "")))
+                    | _ => Some("(() => {throw new Error('Browser imports are not supported in Node.js')})()")
+                }
+            | "ff:core/Js.dynamicImport" {arguments | [url]} =>
+                Some("import(" + self.emitTerm(url, async) + ")")
+            | "ff:core/Js.await" {arguments | [body]} =>
+                if(async) {
+                    Some("(await " + self.emitTerm(body, async) + ")")
+                } else {
+                    Some(self.emitTerm(body, async))
+                }
+            | name {name.removeFirst("ff:core/Js.async") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [ELambda(at, Lambda(_, effect, [MatchCase(_, patterns, [], body)]))]
+            } {
+                patterns.all {| PVariable _ => True | _ => False }
+            } =>
+                let patternParameters = patterns.map {
+                    | PVariable p => p.name.map(escapeKeyword).else {"_"}
+                    | _ => panic("!")
+                }
+                Some(
+                    "async (" + patternParameters.join(", ") + ") => {\n" + 
+                    self.emitStatements(body, True, False, False) + 
+                    "\n}"
+                )
+            | name {name.startsWith("ff:core/Js.async")} =>
+                throw(CompileError(term.at, "JS async functions must take a simple parameter list"))
+            | "ff:core/Js.cancelled" =>
+                Some(if(async) {"$task.controller_.signal.aborted"} else {"false"})
+            | "ff:core/Js.throwIfCancelled" =>
+                Some(if(async) {"((() => ff_core_Task.Task_throwIfAborted($task))())"} else {""})
+            | "ff:core/Js.currentTask" =>
+                Some("$task")
+            | "ff:core/Js.controller" =>
+                Some("$task.controller_")
+            | "ff:core/Js.setController" {arguments | [a]} =>
+                Some("($task.controller_ = " + self.emitTerm(a, async) + ")")
+            | "ff:core/Js.inAsync" =>
+                Some(if(self.emittingAsync) {"true"} else {"false"})
+            | "ff:core/Js.inBrowser" =>
+                Some(if(self.emitTarget == EmitBrowser) {"true"} else {"false"})
+            | "ff:core/Js.inNode" =>
+                Some(if(self.emitTarget == EmitNode) {"true"} else {"false"})
+            | "ff:core/Js.inBuild" =>
+                Some(if(self.emitTarget == EmitBuild) {"true"} else {"false"})
+            | "ff:core/Js.value" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Js.fromValue" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Js.rawIdentifier" {arguments | [EString(_, op)]} =>
+                Some(op.replace("\"", ""))
+            | "ff:core/Js.unaryOperator" {arguments | [EString(_, op), a1]} =>
+                Some("(" + op.replace("\"", "") + self.emitTerm(a1, async) + ")")
+            | "ff:core/Js.binaryOperator" {arguments | [EString(_, op), a1, a2]} =>
+                Some("(" + self.emitTerm(a1, async) + " " + op.replace("\"", "") + " " + self.emitTerm(a2, async) + ")")
+            | "ff:core/Js.shortCircuitingOperator" {arguments | [EString(_, op), a1, a2]} =>
+                Some("(" + self.emitTerm(a1, async) + " " + op.replace("\"", "") + " " + self.emitTerm(invokeImmediately(a2), async) + ")")
+            | "ff:core/JsValue.JsValue_spreadToArray" {arguments | [e1]} =>
+                Some("[..." + self.emitTerm(e1, async) + "]")
+            | "ff:core/JsValue.JsValue_typeof" {arguments | [e]} =>
+                Some("(typeof " + self.emitTerm(e, async) + ")")
+            | "ff:core/JsValue.JsValue_instanceof" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " instanceof " + self.emitTerm(e2, async) + ")")
+            | "ff:core/JsValue.JsValue_get" {arguments | [e1, e2]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async))
+            | "ff:core/JsValue.JsValue_equals" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " === " + self.emitTerm(e2, async) + ")")
+            | "ff:core/JsValue.JsValue_notEquals" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " !== " + self.emitTerm(e2, async) + ")")
+            | "ff:core/Int.Int_bitAnd" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " & " + self.emitTerm(e2, async) + ")")
+            | "ff:core/Int.Int_bitRightUnsigned" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " >>> " + self.emitTerm(e2, async) + ")")
+            | "ff:core/Int.Int_bitRight" {arguments | [e1, e2]} =>
+                Some("(" + self.emitTerm(e1, async) + " >> " + self.emitTerm(e2, async) + ")")
+            | name {name.removeFirst("ff:core/JsValue.JsValue_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, e2, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsValue.JsValue_callValue") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(self.emitTerm(e1, async) + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsValue.JsValue_new") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some("(new " + self.emitTerm(e1, async) + "(" + argumentCode + ")" + ")")
+            | name {name == "ff:core/JsValue.JsValue_with" || name == "ff:core/Json.Json_with"} =>
+                function go(e: Term, fields: List[Pair[Term, Term]]): String {
+                    e.{
+                        | ECall(_, StaticCall(n, _, _), _, _, [a1, a2, a3], _) {n == name} =>
+                            go(a1.value, [Pair(a2.value, a3.value), ...fields])
+                        | ECall(_, StaticCall(n, _, _), _, _, as, _) {
+                            n == "ff:core/JsSystem.JsSystem_object" || 
+                            n == "ff:core/JsSystem.JsSystem_new0" ||
+                            n == "ff:core/Js.object" || 
+                            n == "ff:core/Js.new0" ||
+                            n == "ff:core/Json.Json_object" ||
+                            n == "ff:core/Json.Json_new0"
+                        } {
+                            as.all {noSideEffects(_.value)}
+                        } =>
+                            "{" + fields.map {p =>
+                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
+                            }.join(", ") + "}"
+                        | _ =>
+                            "{..." + self.emitTerm(e, async) + ", " + fields.map {p =>
+                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
+                            }.join(", ") + "}"
+                    }
+                }
+                Some(go(term, []))
+            | name {name.removeFirst("ff:core/JsSystem.JsSystem_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, EString(_, q)@e2, ...es]
+            } {noSideEffects(e1)} =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"} + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsSystem.JsSystem_function") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, e2]
+            } {noSideEffects(e1)} {term | ECall call} {!effectTypeIsAsync(call.effect)} =>
+                Some(self.emitTerm(e2, async))
+            | "ff:core/JsSystem.JsSystem_get" {arguments | [e1, EString(_, q)@e2]} {noSideEffects(e1)} =>
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"})
+            | "ff:core/JsSystem.JsSystem_object" {arguments | [e]} {noSideEffects(e)} =>
+                Some("{}")
+            | "ff:core/JsSystem.JsSystem_new0" {arguments | [e]} {noSideEffects(e)} =>
+                Some("{}")
+            | "ff:core/JsSystem.JsSystem_null" {arguments | [e]} {noSideEffects(e)} =>
+                Some("null")
+            | "ff:core/JsSystem.JsSystem_undefined" {arguments | [e]} {noSideEffects(e)} =>
+                Some("(void 0)")
+            | name {name.removeFirst("ff:core/Js.call") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [EString(_, q)@e1, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e1, async) + "]"} + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/Js.function") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1]
+            } {term | ECall call} =>
+                if(self.emittingAsync && effectTypeIsAsync(call.effect)) {
+                    let argumentCode = 1.to(n.grabInt()).map {"a_" + _}.join(", ")
+                    let taskCode = if(argumentCode == "") {"$task"} else {", $task"}
+                    Some("(async (" + argumentCode + ") => await " + self.emitTerm(e1, async) + "(" + argumentCode + taskCode + "))")
+                } else {
+                    Some(self.emitTerm(e1, async))
+                }
+            | "ff:core/Js.get" {arguments | [EString(_, q)@e1]} =>
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e1, async) + "]"})
+            | "ff:core/Js.object" =>
+                Some("{}")
+            | "ff:core/Js.new0" =>
+                Some("{}")
+            | "ff:core/Js.null" =>
+                Some("null")
+            | "ff:core/Js.undefined" =>
+                Some("(void 0)")
+            | "ff:core/Js.globalThis" =>
+                Some("globalThis")
+            | "ff:core/BrowserSystem.BrowserSystem_js" {arguments | [e]} {noSideEffects(e)} => 
+                Some("globalThis")
+            | "ff:core/BuildSystem.BuildSystem_js" {arguments | [e]} {noSideEffects(e)} => 
+                Some("globalThis")
+            | "ff:core/NodeSystem.NodeSystem_js" {arguments | [e]} {noSideEffects(e)} => 
+                Some("globalThis")
+            | "ff:core/Js.jsSystem" =>
+                Some("globalThis")
+            | "ff:core/Json.string" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Json.int" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Json.float" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Json.bool" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Json.array" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/Json.null" {arguments | [e]} =>
+                Some("null")
+            | "ff:core/Json.object" {arguments | [e]} =>
+                Some("{}")
+            | _ =>
+                None
+        }
+    }
+    
+    emitSpecialStatement(
+        term: Term 
+        last: Bool 
+        async: Bool 
+        name: String
+        arguments: List[Term]
+        dictionaries: List[Dictionary]
+    ): Option[String] {
+        name.{
+            | "ff:core/Core.while" {arguments | [condition, body]} =>
+                Some(
+                    "while(" + self.emitComma(invokeImmediately(condition), async) + ") {\n" +
+                    self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
+                )
+            | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
+                invokeImmediately(doWhileBody) | body
+            } =>
+                Some(
+                    "while(true) {\n" +
+                    self.emitStatements(body, False, True, async) +
+                    "\n}"
+                )
+            | "ff:core/Option.Option_each" {arguments | [list, ELambda(_, Lambda(_, _, [
+                MatchCase(_, [PVariable(_, name)], [], body)
+            ]))]} =>
+                Some(
+                    "{\nconst if_o = " + self.emitTerm(list, async) + "\nif(if_o.Some) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = if_o.value_;\n"}.else {""} +
+                        self.emitStatements(body, last, False, async) +
+                    "\n}\n}"
+                )
+            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
+                ECall(_, StaticCall(r, _, _), _, _, [start, end], _)
+                ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))
+            ]} {r == "ff:core/Int.Int_until" || r == "ff:core/Int.Int_to"} =>
+                let startCode = self.emitTerm(start.value, async)
+                let endCode = self.emitTerm(end.value, async)
+                let op = if(r == "ff:core/Int.Int_until") {"<"} else {"<="}
+                Some(
+                    "for(let " +
+                    "for_i = " + startCode + ", for_e = " + endCode + "; for_i " + op + " for_e; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
+                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
+                    "\n}"
+                )
+            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
+                ECall(_, StaticCall("ff:core/List.List_reverse", _, _), _, _, [
+                    Argument(_, _, ECall(_, StaticCall(r, _, _), _, _, [start, end], _))
+                ], _)
+                ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))
+            ]} {r == "ff:core/Int.Int_until" || r == "ff:core/Int.Int_to"} =>
+                let startCode = self.emitTerm(start.value, async)
+                let endCode = self.emitTerm(end.value, async)
+                let delta = if(r == "ff:core/Int.Int_until") {" - 1"} else {""}
+                Some(
+                    "for(let " +
+                    "for_e = " + startCode + ", for_i = " + endCode + delta + "; for_i >= for_e; for_i--) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
+                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
+                    "\n}"
+                )
+            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
+                ECall(_, StaticCall("ff:core/List.List_zip", _, _), _, _, [list1, list2], _)
+                ELambda(_, Lambda(_, _, [MatchCase(_, [
+                    PVariant(_, "ff:core/Pair.Pair", [PVariable(_, name1), PVariable(_, name2)])
+                ], [], body)]))
+            ]} =>
+                let fusion1 = self.emitLightFusion("for_a", list1.value, async)
+                let fusion2 = self.emitLightFusion("for_a2", list2.value, async)
+                let start1 = fusion1.second.first
+                let end1 = fusion1.second.second
+                let listCode1 = fusion1.first
+                let start2 = fusion2.second.first
+                let end2 = fusion2.second.second
+                let listCode2 = fusion2.first
+                Some(
+                    "for(let for_a = " + listCode1 + ", for_i = " + start1 + ", for_l = " + end1 + ", " +
+                    "for_a2 = " + listCode2 + ", for_i2 = " + start2 + ", for_l2 = " + end2 + 
+                    "; for_i < for_l && for_i2 < for_l2; for_i++, for_i2++) {\n" +
+                        name1.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        name2.map {"const " + escapeKeyword(_) + " = for_a2[for_i2];\n"}.else {""} +
+                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
+                    "\n}"
+                )
+            | n {n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile"} {arguments | [
+                ECall(_, StaticCall("ff:core/List.List_pairs", _, _), _, _, [list], _)
+                ELambda(_, Lambda(_, _, [MatchCase(_, [
+                    PVariant(_, "ff:core/Pair.Pair", [PVariable(_, name1), PVariable(_, name2)])
+                ], [], body)]))
+            ]} =>
+                let fusion = self.emitLightFusion("for_a", list.value, async)
+                let start = fusion.second.first
+                let end = fusion.second.second
+                let listCode = fusion.first
+                Some(
+                    "for(let for_a = " + listCode + ", for_i = " + start + ", for_l = " + end + 
+                    "; for_i < for_l; for_i++) {\n" +
+                        name1.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
+                        name2.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
+                    "\n}"
+                )
+            | n {
+                n == "ff:core/List.List_each" || n == "ff:core/List.List_eachWhile" || 
+                n == "ff:core/Array.Array_each" || n == "ff:core/Array.Array_eachWhile"
+            } {
+                arguments | [list, ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))]
+            } =>
+                let fusion = self.emitLightFusion("for_a", list, async)
+                let start = fusion.second.first
+                let end = fusion.second.second
+                let listCode = fusion.first + if(n.startsWith("ff:core/Array.")) {".array"} else {""}
+                Some(
+                    "for(let for_a = " + listCode + ", for_i = " + start + ", for_l = " + end + 
+                    "; for_i < for_l; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        self.emitStatements(body, last, n.endsWith("eachWhile"), async) +
+                    "\n}"
+                )
+            | "ff:core/Array.Array_push" {arguments | [array, value]} =>
+                Some(self.emitTerm(array, async) + ".array.push(" + self.emitTerm(value, async) + ")")
+            | "ff:core/Core.if" {arguments | [condition, body]} =>
+                Some(
+                    "if(" + self.emitComma(condition, async) + ") {\n" +
+                    if(last) {
+                        "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body), async) +
+                        ")\n} else return ff_core_Option.None()"
+                    } else {
+                        self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
+                    }
+                )
+            | "ff:core/Core.throw" {term | ECall c} {c.arguments | [argument]} {dictionaries | [dictionary]} =>
+                let d = self.emitDictionary(dictionary)
+                let a = self.emitArgument(term.at, argument, async)
+                Some("throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(" + a + ", " + d + ")})")
+            | "ff:core/Try.Try_catch" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/Try.Try_catchAny" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/Try.Try_finally" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/Js.throwIfCancelled" =>
+                Some(if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""})
+            | "ff:core/Js.throw" {term | ECall c} {c.arguments | [argument]} =>
+                Some("throw " + self.emitTerm(argument.value, async))
+            | "ff:core/JsValue.JsValue_set" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
+            | "ff:core/JsValue.JsValue_increment" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
+            | "ff:core/JsValue.JsValue_decrement" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_set" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " = " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_increment" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " += " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_decrement" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " -= " + self.emitTerm(e3, async))
+            | "ff:core/Js.set" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                Some(s + " = " + self.emitTerm(e2, async))
+            | "ff:core/Js.increment" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                Some(s + " += " + self.emitTerm(e2, async))
+            | "ff:core/Js.decrement" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                Some(s + " -= " + self.emitTerm(e2, async))
+            | _ =>
+                None
+        }
+    }
+    
+    emitLightFusion(listName: String, list: Term, async: Bool): Pair[String, Pair[String, String]] {
+        mutable start = "0"
+        mutable end = listName + ".length"
+        let listCode = list.{
+            | ECall(_, StaticCall("ff:core/List.List_dropFirst", _, _), _, _, [a1, a2], _) =>
+                start = self.emitTerm(a2.value, async)
+                if(!start.all {_.isAsciiDigit()}) {
+                    start = "Math.max(" + start + ", 0)"
+                }
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_dropLast", _, _), _, _, [a1, a2], _) =>
+                let count = self.emitTerm(a2.value, async)
+                if(!count.all {_.isAsciiDigit()}) {
+                    end = end + " - Math.max(" + count + ", 0)"
+                } else {
+                    end = end + " - " + count
+                }
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_takeFirst", _, _), _, _, [a1, a2], _) =>
+                end = self.emitTerm(a2.value, async)
+                if(!end.all {_.isAsciiDigit()}) {
+                    end = "Math.max(" + end + ", 0)"
+                }
+                end = "Math.min(" + end + ", " + listName + ".length)"
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_takeLast", _, _), _, _, [a1, a2], _) =>
+                let count = self.emitTerm(a2.value, async)
+                if(!count.all {_.isAsciiDigit()}) {
+                    start = "Math.max(" + listName + ".length - Math.max(" + count + ", 0), 0)"
+                } else {
+                    start = "Math.max(" + listName + ".length - " + count + ", 0)"
+                }
+                self.emitTerm(a1.value, async)
+            | _ => 
+                self.emitTerm(list, async)
+        } 
+        Pair(listCode, Pair(start, end))
+    }
+
+    emitTryCatchFinally(term: Term, last: Bool, async: Bool): Option[String] {
+        function emitCatch(catchEffect: Type, cases: List[MatchCase]): String {
+            let catchAsync = self.emittingAsync && effectTypeIsAsync(catchEffect)
+            Patterns.convertAndCheck(self.otherModules, cases)
+            let arguments = ["_exception.value_", "_error"]
+            cases.{
+                | [case] =>
+                    self.emitCase(arguments, case, [], [], False, last, False, True, catchAsync)
+                | cs =>
+                    let caseStrings = cases.pairs().map {| Pair(i, c) =>
+                        let lastCase = i == cases.size() - 1
+                        self.emitCase(arguments, c, [], [], True, last, False, lastCase, catchAsync)
+                    }
+                    if(last) {caseStrings.join("\n")} else {"do {\n" + caseStrings.join("\n") + "\n} while(false)"}
+            }
+        }
+        term.{
+            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
+                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
+                ], _))
+                Argument(_, _, ELambda(_, Lambda(_, finallyEffect, [MatchCase(_, [], [], finallyBody)])))
+            ], _) =>
+                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
+                let finallyAsync = self.emittingAsync && effectTypeIsAsync(finallyEffect)
+                Some(
+                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
+                    "\n} finally {\n" + self.emitStatements(finallyBody, last, False, finallyAsync) + "\n}"
+                )
+            | ECall(_, StaticCall("ff:core/Try.Try_catchAny", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
+                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
+                ], _))
+                Argument(_, _, ELambda(_, Lambda(_, catchEffect, [MatchCase(_, [PVariable(_, name)], [], catchBody)])))
+            ], _) =>
+                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
+                Some(
+                    "try {\n" + 
+                        self.emitStatements(tryBody, last, False, tryAsync) +
+                    "\n} catch" + name.map {"(" + escapeKeyword(_) + ")"}.else {""} + " {\n" +
+                        self.emitStatements(catchBody, last, False, tryAsync) +
+                    "\n}"
+                )
+            | ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
+                    Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
+                ], _))
+                Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
+            ], [dictionary]) =>
+                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
+                let d = self.emitDictionary(dictionary)
+                Some(
+                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
+                    "\n} catch(_error) {\n" +
+                        "if(!_error.ffException) throw _error\n" +
+                        "const _exception = ff_core_Any.fromAny_(_error.ffException, " + d + ")\n" +
+                        "if(!_exception.Some) throw _error\n" +
+                        emitCatch(catchEffect, cases) +
+                    "\n}"
+                )
+            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
+                    Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
+                        Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
+                    ], _))
+                    Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
+                ], [dictionary]))
+                Argument(_, _, ELambda(_, Lambda(_, finallyEffect, [MatchCase(_, [], [], finallyBody)])))
+            ], _) =>
+                let tryAsync = self.emittingAsync && effectTypeIsAsync(tryEffect)
+                let finallyAsync = self.emittingAsync && effectTypeIsAsync(finallyEffect)
+                let d = self.emitDictionary(dictionary)
+                Some(
+                    "try {\n" + self.emitStatements(tryBody, last, False, tryAsync) +
+                    "\n} catch(_error) {\n" +
+                        "if(!_error.ffException) throw _error\n" +
+                        "const _exception = ff_core_Any.fromAny_(_error.ffException, " + d + ")\n" +
+                        "if(!_exception.Some) throw _error\n" +
+                        emitCatch(catchEffect, cases) +
+                    "\n} finally {\n" + self.emitStatements(finallyBody, last, False, finallyAsync) + "\n}"
+                )
+            | _ =>
+                None
+        }
+    }
+
+    emitCase(
+        arguments: List[String]
+        matchCase: MatchCase
+        conditions: List[String]
+        variables: List[String]
+        jump: Bool
+        last: Bool
+        break: Bool
+        lastCase: Bool
+        async: Bool
+    ): String {
+        function emitWrapper(code: String): String {
+            if(conditions.isEmpty()) {"{\n"} else {
+                "if(" + conditions.join(" && ") + ") {\n"
+            } +
+            variables.join() +
+            code +
+            "\n}"
+        }
+        Pair(matchCase.patterns, matchCase.guards).{
+            | Pair([p, ...ps], _) =>
+                self.emitPattern(
+                    arguments.grab(0)
+                    p
+                    arguments.dropFirst()
+                    matchCase.MatchCase(patterns = ps)
+                    conditions
+                    variables
+                    jump
+                    last
+                    break
+                    lastCase
+                    async
+                )
+            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) {variables.isEmpty()} =>
+                let newCase = matchCase.MatchCase(patterns = [], guards = [])
+                self.emitCase([], newCase, [...conditions, self.emitTerm(e, async)], [], jump, last, break, lastCase, async)
+            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) =>
+                let newCase = matchCase.MatchCase(patterns = [], guards = [])
+                let code = self.emitCase([], newCase, [self.emitTerm(e, async)], [], jump, last, break, lastCase, async)
+                emitWrapper(code)
+            | Pair([], [guard, ...guards]) =>
+                let guardName = "_guard" + (guards.size() + 1)
+                let newCase = matchCase.MatchCase(patterns = [guard.pattern], guards = guards)
+                let code = 
+                    "const " + guardName + " = " + self.emitTerm(guard.term, async) + ";\n" +
+                    self.emitCase([guardName], newCase, [], [], jump, last, break, lastCase, async)
+                emitWrapper(code)
+            | Pair([], []) =>
+                let statementsCode = self.emitStatements(matchCase.body, last, break, async)
+                let lastLine = statementsCode.reverse().takeWhile {_ != '\n'}.reverse()
+                let returns = 
+                    lastLine.startsWith("return ") || 
+                    lastLine.startsWith("break ") ||
+                    lastLine.startsWith("continue ") ||
+                    lastLine.startsWith("return;") || 
+                    lastLine.startsWith("break;") ||
+                    lastLine.startsWith("continue;") ||
+                    lastLine.startsWith("throw ")
+                let code = statementsCode + if(jump && last && !returns) {
+                    "\nreturn"
+                } elseIf {jump && !returns && !lastCase} {
+                    if(break) {"\ncontinue"} else {"\nbreak"}
+                } else {
+                    ""
+                }
+                emitWrapper(code)
+        }
+    }
+
+    emitPattern(
+        argument: String
+        pattern: MatchPattern
+        arguments: List[String]
+        matchCase: MatchCase
+        conditions: List[String]
+        variables: List[String]
+        jump: Bool
+        last: Bool
+        break: Bool
+        lastCase: Bool
+        async: Bool
+    ): String {
+        function addCondition(condition: String): List[String] {
+            if(lastCase) {conditions} else {[...conditions, condition]}
+        }
+        pattern.{
+            | PString(_, value) =>
+                let newConditions = addCondition(argument + " === " + value)
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
+            | PInt(_, value) =>
+                let newConditions = addCondition(argument + " === " + value)
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
+            | PChar(_, value) =>
+                let newConditions = addCondition(argument + " === " + charLiteralToNumber(value))
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, break, lastCase, async)
+            | PVariable(_, None) =>
+                self.emitCase(arguments, matchCase, conditions, variables, jump, last, break, lastCase, async)
+            | PVariable(_, Some(name)) =>
+                let escaped = escapeKeyword(name)
+                let newVariables = if(escaped != argument) {
+                    [...variables, "const " + escaped + " = " + argument + ";\n"]
+                } else {variables}
+                self.emitCase(arguments, matchCase, conditions, newVariables, jump, last, break, lastCase, async)
+            | PVariant(_, "ff:core/Bool.False", []) =>
+                self.emitCase(arguments, matchCase, addCondition("!" + argument), variables, jump, last, break, lastCase, async)
+            | PVariant(_, "ff:core/Bool.True", []) =>
+                self.emitCase(arguments, matchCase, addCondition(argument), variables, jump, last, break, lastCase, async)
+            | PVariant(_, emptyOrLink, _) {emptyOrLink == "List$Empty" || emptyOrLink == "List$Link"} =>
+                mutable restPattern = None
+                function listPatterns(matchPattern: MatchPattern): List[MatchPattern] {
+                    | PVariant(_, "List$Empty", []) => 
+                        []
+                    | PVariant(_, "List$Link", [head, tail]) =>
+                        [head, ...listPatterns(tail)]
+                    | p =>
+                        restPattern = Some(p)
+                        []
+                }
+                let patterns = listPatterns(pattern)
+                let itemArguments = patterns.pairs().map {| Pair(i, _) => argument + "[" + i + "]"}
+                let restArgument = restPattern.map {_ => argument + ".slice(" + patterns.size() + ")"}
+                let newArguments = [...itemArguments, ...restArgument.toList(), ...arguments]
+                let newMatchCase = matchCase.MatchCase(
+                    patterns = [...patterns, ...restPattern.toList(), ...matchCase.patterns]
+                )
+                let operator = restPattern.map {_ => ">="}.else {"==="}
+                let newConditions = addCondition(argument + ".length " + operator + " " + patterns.size())
+                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, break, lastCase, async)
+            | PVariant(_, name, patterns) =>
+                let processed = self.processVariantCase(name, argument)
+                let newMatchCase = matchCase.MatchCase(patterns = [...patterns, ...matchCase.patterns])
+                let newConditions = if(processed.loneVariant || lastCase) {conditions} else {
+                    [...conditions, argument + "." + processed.variantName]
+                }
+                let newArguments = [...processed.arguments, ...arguments]
+                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, break, lastCase, async)
+            | PVariantAs(at, name, variableAt, variable) =>
+                let processed = self.processVariantCase(name, argument)
+                let newConditions = if(processed.loneVariant || lastCase) {conditions} else {
+                    [...conditions, argument + "." + processed.variantName]
+                }
+                let newVariables = variable.map(escapeKeyword).filter {_ != argument}.map {
+                    [...variables, "const " + _ + " = " + argument + ";\n"]
+                }.else {[]}
+                self.emitCase(arguments, matchCase, newConditions, newVariables, jump, last, break, lastCase, async)
+            | PAlias(_, pattern, variable) =>
+                let escaped = escapeKeyword(variable)
+                let newVariables = if(escaped != argument) {
+                    [...variables, "const " + escaped + " = " + argument + ";\n"]
+                } else {variables}
+                self.emitPattern(argument, pattern, arguments, matchCase, conditions, newVariables, jump, last, break, lastCase, async)
+        }
+    }
+
+    emitList(items: List[Pair[Term, Bool]], async: Bool): String {
+        "[" + items.map {
+            | Pair(item, False) => self.emitTerm(item, async)
+            | Pair(item, True) => "..." + self.emitTerm(item, async)
+        }.join(", ") + "]"
+    }
+
+    processVariantCase(name: String, argument: String): ProcessedVariantCase {
+        let variantNameUnqualified = name.reverse().takeWhile {_ != '.'}.reverse()
+        let variantName = escapeKeyword(variantNameUnqualified)
+        let moduleName = name.dropLast(variantNameUnqualified.size() + 1)
+        let variantModule = self.otherModules.grab(moduleName)
+        mutable newtype = False
+        mutable loneVariant = False
+        let newArguments = variantModule.types.collectFirst {definition =>
+            definition.variants.find {_.name == variantName }.map {variant =>
+                newtype = definition.newtype
+                loneVariant = definition.variants.size() == 1
+                [...definition.commonFields.map {_.name}, ...variant.fields.map {_.name}]
+            }
+        }.grab().map {field => if(newtype) {argument} else {argument + "." + escapeKeyword(field)}}
+        ProcessedVariantCase(variantName, newtype, loneVariant, newArguments)
+    }
+
+    processVariant(name: String): Bool {
+        if(name.startsWith("List$")) {False} else:
+        let variantNameUnqualified = name.reverse().takeWhile {_ != '.'}.reverse()
+        let variantName = escapeKeyword(variantNameUnqualified)
+        let moduleName = name.dropLast(variantNameUnqualified.size() + 1)
+        let variantModule = self.otherModules.grab(moduleName)
+        mutable newtype = False
+        let newArguments = variantModule.types.collectFirst {definition =>
+            definition.variants.find {_.name == variantName}.map {variant =>
+                newtype = definition.newtype
+            }
+        }.grab()
+        newtype
+    }
+
+    emitArgument(callAt: Location, argument: Argument, async: Bool): String {
+        argument.value.{
+            | ECall(_, StaticCall("ff:core/SourceLocation.callSite", _, _), _, _, _, _) => 
+                "\"" + self.moduleName + ":" + callAt.line + ":" + callAt.column + 
+                "," + self.packagePair.group + "," + self.packagePair.name + "\""
+            | value =>
+                self.emitTerm(value, async)
+        }
+    }
+    
+    emitComma(term: Term, async: Bool): String {
+        term.{
+            | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
+                safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
+            } =>
+                "(" + self.emitStatements(before1, False, False, async) + ", " + 
+                self.emitStatements(before2, False, False, async) + ", " + 
+                self.emitStatements(before3, False, False, async) + ", " + 
+                self.emitTerm(after, async) + ")"
+            | ESequential(_, ESequential(_, before1, before2), after) {
+                safeCommable(before1) && safeCommable(before2) && safeCommable(after)
+            } =>
+                "(" + self.emitStatements(before1, False, False, async) + ", " + 
+                self.emitStatements(before2, False, False, async) + ", " + 
+                self.emitTerm(after, async) + ")"
+            | ESequential(_, before, after) {
+                safeCommable(before) && safeCommable(after)
+            } =>
+                "(" + self.emitStatements(before, False, False, async) + ", " + 
+                self.emitTerm(after, async) + ")"
+            | _ =>
+                self.emitTerm(term, async)
+        }
+    }
+
+}
+
+data ProcessedVariantCase(
+    variantName: String
+    newtype: Bool
+    loneVariant: Bool
+    arguments: List[String]
+)
+
+detectIfElse(term: Term): List[Pair[Term, Term]] {
+    | ECall(at, StaticCall("ff:core/Core.if", _, _), _, _, [condition, body], _) =>
+        [Pair(condition.value, invokeImmediately(body.value))]
+    | ECall(at, StaticCall("ff:core/Option.Option_elseIf", _, _), _, _, [option, condition, body], _) =>
+        let list = detectIfElse(option.value)
+        if(list.isEmpty()) {[]} else:
+        [Pair(invokeImmediately(condition.value), invokeImmediately(body.value)), ...list]
+    | ECall(at, StaticCall("ff:core/Option.Option_else", _, _), _, _, [option, body], _) =>
+        let list = detectIfElse(option.value)
+        if(list.isEmpty()) {[]} else:
+        [Pair(EVariant(at, "ff:core/Bool.True", [], None), invokeImmediately(body.value)), ...list]
+    | _ =>
+        []
+}
+
+invokeImmediately(function: Term): Term {
+    | ELambda(_, Lambda(_, effect, [MatchCase(_, [], [], body)])) =>
+        body
+    | _ =>
+        let effect = TConstructor(function.at, "Q$", []) // Awaits more often than required in async context
+        ECall(function.at, DynamicCall(function, False), effect, [], [], [])
+}
+
+safeCommable(term: Term): Bool {
+    term.{
+        | EField _ => True
+        | EVariable _ => True
+        | EAssign _ => True
+        | EAssignField _ => True
+        | ECall _ => True
+        | ECopy _ => True
+        | EVariant _ => True
+        | EString(_, _) => True
+        | EInt(_, _) => True
+        | EChar(_, _) => True
+        | EFloat(_, _) => True
+        | EList _ => True
+        | EPipe _ => True
+        | ERecord _ => True
+        | EWildcard _ => True 
+        | _ => False
+    }
+}
+
+extractTypeName(type: Type): String {
+    | TVariable(at, index) =>
+        fail(at, "Unexpected type variable: $" + index)
+    | TConstructor t =>
+        t.name
+}
+
+firstTypeName(types: List[Type]): String {
+    types.grabFirst().{
+        | TConstructor t => t.name
+        | TVariable t => fail(t.at, " is still a unification variable")
+    }
+}
+
+makeDictionaryName(traitName: String, typeName: String): String {
+    traitName.replace(".", "_").replace(":", "_").replace("/", "_") + "$" +
+    typeName.replace(".", "_").replace(":", "_").replace("/", "_")
+}
+
+charLiteralToNumber(charLiteral: String): String {
+    | "'\\t'" => "9"
+    | "'\\n'" => "10"
+    | "'\\r'" => "13"
+    | "'\\\"'" => "34"
+    | "'\\''" => "39"
+    | value => "" + value.grab(1).codeUnit
+}
+
+escapeResolved(word: String): String {
+    let parts = word.replace(":", ".").replace("/", ".").split('.')
+    let initialParts = parts.dropLast()
+    if(initialParts.isEmpty()) {
+        escapeKeyword(parts.grabLast())
+    } else {
+        initialParts.join("_") + "." + escapeKeyword(parts.grabLast())
+    }
+}
+
+escapeKeyword(word: String): String {
+    if(word.grabFirst().isAsciiLower()) {word + "_"} else {word}
+}
+
+effectTypeIsAsync(effect: Type): Bool {
+    | TConstructor(_, "Q$", _) => True
+    | _ => False
+}
+
+safeBare(quotedString: String): Option[String] {
+    // TODO: And not a reserved word in JS
+    quotedString.removeFirst("\"").flatMap {_.removeLast("\"")}.filter {s => 
+        s.first().any {_.isAsciiLetter()} && s.all {_.isAsciiLetterOrDigit()}
+    }
+}
+
+noSideEffects(term: Term): Bool {
+    term.{
+        | EField(_, _, e, _) => noSideEffects(e)
+        | EVariable(_, _) => True
+        | ECall(_, StaticCall("ff:core/BrowserSystem.BrowserSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/BuildSystem.BuildSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/NodeSystem.NodeSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/Js.jsSystem", _, _), _, _, _, _) => True
+        | EString(_, _) => True
+        | EInt(_, _) => True
+        | EChar(_, _) => True
+        | EFloat(_, _) => True
+        | _ => False
+    }
+}
+
+primitiveTypes = [
+    "ff:core/Bool.Bool"
+    "ff:core/Char.Char"
+    "ff:core/Int.Int"
+    "ff:core/Float.Float"
+    "ff:core/String.String"
+].toSet()