@markw65/monkeyc-optimizer 1.1.7 → 1.1.8

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {checkCompilerVersion,collectNamespaces,diagnostic,diagnosticHelper,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,getSuperClasses,hasProperty,isLocal,isLookupCandidate,isStateNode,lookupNext,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,createDocumentationMap,diagnostic,diagnosticHelper,findNamesInScope,findUsingForNode,formatAst,formatAstLongLines,getApiFunctionInfo,getApiMapping,getSuperClasses,hasProperty,isLocal,isLookupCandidate,isStateNode,lookupByFullName,lookupNext,lookupResultContains,lookupWithType,makeToyboxLink,mapVarDeclsByType,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -1372,7 +1372,7 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                 });
             }
             if (wantsAllRefs) {
-                const scope = state.stack[state.stack.length - 1];
+                const scope = state.top().sn;
                 if (scope.node === node &&
                     scope.type === "BlockStatement" &&
                     scope.decls &&
@@ -1934,9 +1934,9 @@ function getArgSafety(state, func, args, requireAll) {
                 // if decl is a local, it also can't be changed
                 // by a call to another function.
                 for (let i = 0;; i++) {
-                    if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                    if (!state.stack[i] || decl.stack[i]?.sn !== state.stack[i].sn)
                         return false;
-                    if (state.stack[i].type === "FunctionDeclaration")
+                    if (state.stack[i].sn.type === "FunctionDeclaration")
                         return true;
                 }
             }
@@ -2073,7 +2073,7 @@ function getArgSafety(state, func, args, requireAll) {
             }
             return null;
         };
-        state.stack = func.stack.concat(func);
+        state.stack = func.stack.concat({ sn: func });
         state.traverse(func.node.body);
     }
     finally {
@@ -2184,7 +2184,7 @@ function processInlineBody(state, func, call, root, params) {
     // lookup determines static-ness of the lookup context based on seeing
     // a static FunctionDeclaration, but the FunctionDeclaration's stack
     // doesn't include the FunctionDeclaration itself.
-    const lookupStack = func.stack.concat(func);
+    const lookupStack = func.stack.concat({ sn: func });
     try {
         state.pre = (node) => {
             if (failed)
@@ -2574,10 +2574,11 @@ function inlineFunction(state, func, call, context) {
     if (!typecheckFalse) {
         return ret;
     }
-    const callerSn = state.stack.find((sn) => sn.type === "FunctionDeclaration");
-    if (!callerSn) {
+    const callerElem = state.stack.find((elem) => elem.sn.type === "FunctionDeclaration");
+    if (!callerElem) {
         return ret;
     }
+    const callerSn = callerElem.sn;
     const caller = callerSn.node;
     if (!caller.attrs) {
         caller.attrs = withLoc({
@@ -2697,6 +2698,1122 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 }
 
 
+/***/ }),
+
+/***/ 5530:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "BJ": () => (/* binding */ analyze)
+/* harmony export */ });
+/* unused harmony exports getFileSources, getFileASTs, reportMissingSymbols, getLiteralFromDecls, optimizeMonkeyC */
+/* harmony import */ var _markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9642);
+/* harmony import */ var _markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(560);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6652);
+/* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(333);
+/* harmony import */ var _optimizer_types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9697);
+/* harmony import */ var _pragma_checker__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(1851);
+/* harmony import */ var _pre__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(9910);
+/* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4859);
+/* harmony import */ var _type_flow_could_be__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(4055);
+/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7161);
+/* harmony import */ var _type_flow_optimize__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(3687);
+/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(9234);
+/* harmony import */ var _unused_exprs__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(424);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_15__);
+/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(4405);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * Map each name to the list of StateNodes that declare that
+ * name (excluding Functions, which are already in allFunctions)
+ */
+function collectDeclarationsByName(state) {
+    state.allDeclarations = {};
+    const allDecls = state.allDeclarations;
+    const helper = (sn) => {
+        if (sn.type === "ClassDeclaration" ||
+            sn.type === "Program" ||
+            sn.type === "ModuleDeclaration") {
+            if (sn.decls) {
+                Object.entries(sn.decls).forEach(([key, decls]) => {
+                    const keyed = [];
+                    decls.forEach((decl) => {
+                        switch (decl.type) {
+                            case "ClassDeclaration":
+                            case "ModuleDeclaration":
+                                helper(decl);
+                            // fall through;
+                            case "VariableDeclarator":
+                            case "EnumStringMember":
+                            case "FunctionDeclaration":
+                                keyed.push(sn);
+                        }
+                    });
+                    if (keyed.length) {
+                        if (!(0,_api__WEBPACK_IMPORTED_MODULE_2__.hasProperty)(allDecls, key)) {
+                            allDecls[key] = keyed;
+                        }
+                        else {
+                            allDecls[key].push(...keyed);
+                        }
+                    }
+                });
+            }
+        }
+    };
+    helper(state.stack[0].sn);
+}
+function collectClassInfo(state) {
+    const toybox = state.stack[0].sn.decls["Toybox"][0];
+    const lang = toybox.decls["Lang"][0];
+    const object = lang.decls["Object"];
+    state.allClasses.forEach((elm) => {
+        if (elm.stack[elm.stack.length - 1].sn.type === "ClassDeclaration") {
+            // nested classes don't get access to their contained
+            // context. Put them in the global scope instead.
+            elm.stack = elm.stack.slice(0, 1);
+        }
+        if (elm.node.superClass) {
+            const [name, lookupDefns] = state.lookup(elm.node.superClass, null, elm.stack);
+            const superClass = lookupDefns &&
+                lookupDefns
+                    .map((lookupDefn) => lookupDefn.results)
+                    .flat()
+                    .filter((c) => (0,_api__WEBPACK_IMPORTED_MODULE_2__.isStateNode)(c) && c.type === "ClassDeclaration");
+            // set it "true" if there is a superClass, but we can't find it.
+            elm.superClass = superClass && superClass.length ? superClass : true;
+            if (name && elm.superClass !== true) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
+        }
+        else if (elm !== object[0]) {
+            elm.superClass = object;
+        }
+    });
+    const markOverrides = (cls, scls) => {
+        if (scls === true)
+            return;
+        scls.forEach((c) => {
+            c.decls &&
+                Object.values(c.decls).forEach((funcs) => {
+                    funcs.forEach((f) => {
+                        if (f.type === "FunctionDeclaration" &&
+                            (0,_api__WEBPACK_IMPORTED_MODULE_2__.hasProperty)(cls.decls, f.name)) {
+                            f.node.hasOverride = true;
+                        }
+                    });
+                });
+            if (c.superClass)
+                markOverrides(cls, c.superClass);
+        });
+    };
+    state.allClasses.forEach((elm) => {
+        if (elm.superClass)
+            markOverrides(elm, elm.superClass);
+        if (elm.hasInvoke && elm.decls) {
+            Object.values(elm.decls).forEach((funcs) => {
+                funcs.forEach((f) => {
+                    if (f.type === "FunctionDeclaration" &&
+                        !(f.attributes & _optimizer_types__WEBPACK_IMPORTED_MODULE_6__/* .StateNodeAttributes.STATIC */ .m.STATIC)) {
+                        (0,_api__WEBPACK_IMPORTED_MODULE_2__.markInvokeClassMethod)(state, f);
+                    }
+                });
+            });
+        }
+    });
+}
+function getFileSources(fnMap) {
+    return Promise.all(Object.entries(fnMap).map(([name, value]) => {
+        return (value.monkeyCSource ||
+            fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile(name)
+                .then((data) => (value.monkeyCSource = data.toString().replace(/\r\n/g, "\n"))));
+    })).then(() => {
+        return;
+    });
+}
+function getFileASTs(fnMap) {
+    return getFileSources(fnMap).then(() => Object.entries(fnMap).reduce((ok, [name, value]) => {
+        if (!value.ast) {
+            try {
+                value.ast = _markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0___default().parsers.monkeyc.parse(value.monkeyCSource, null, {
+                    filepath: name,
+                });
+            }
+            catch (e) {
+                ok = false;
+                if (e instanceof Error) {
+                    value.parserError = e;
+                }
+                else {
+                    value.parserError = new Error("An unknown parser error occurred");
+                }
+            }
+        }
+        return ok;
+    }, true));
+}
+async function analyze(fnMap, resourcesMap, manifestXML, config) {
+    let hasTests = false;
+    let markApi = true;
+    const preState = {
+        fnMap,
+        config,
+        allFunctions: {},
+        allClasses: [],
+        shouldExclude(node) {
+            if ("attrs" in node &&
+                node.attrs &&
+                "attributes" in node.attrs &&
+                node.attrs.attributes &&
+                node.loc?.source) {
+                const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
+                if (excludeAnnotations) {
+                    return node.attrs.attributes.elements.reduce((drop, attr) => {
+                        if (attr.type !== "UnaryExpression")
+                            return drop;
+                        if (attr.argument.type !== "Identifier")
+                            return drop;
+                        if ((0,_api__WEBPACK_IMPORTED_MODULE_2__.hasProperty)(excludeAnnotations, attr.argument.name)) {
+                            return true;
+                        }
+                        if (attr.argument.name === "test") {
+                            hasTests = true;
+                        }
+                        return drop;
+                    }, false);
+                }
+            }
+            return false;
+        },
+        pre(node, state) {
+            switch (node.type) {
+                case "FunctionDeclaration":
+                case "ModuleDeclaration":
+                case "ClassDeclaration": {
+                    const scope = state.top().sn;
+                    scope.stack = state.stackClone().slice(0, -1);
+                    if (scope.type === "FunctionDeclaration") {
+                        if (markApi) {
+                            node.body = null;
+                            scope.info = (0,_api__WEBPACK_IMPORTED_MODULE_2__.getApiFunctionInfo)(state, scope);
+                        }
+                        const allFuncs = state.allFunctions;
+                        if (!(0,_api__WEBPACK_IMPORTED_MODULE_2__.hasProperty)(allFuncs, scope.name)) {
+                            allFuncs[scope.name] = [scope];
+                        }
+                        else {
+                            allFuncs[scope.name].push(scope);
+                        }
+                    }
+                    else if (scope.type === "ClassDeclaration") {
+                        state.allClasses.push(scope);
+                    }
+                    break;
+                }
+            }
+            return null;
+        },
+    };
+    await (0,_api__WEBPACK_IMPORTED_MODULE_2__.getApiMapping)(preState, resourcesMap, manifestXML);
+    markApi = false;
+    const state = preState;
+    await getFileASTs(fnMap);
+    Object.entries(fnMap).forEach(([name, value]) => {
+        const { ast, parserError } = value;
+        if (!ast) {
+            throw parserError || new Error(`Failed to parse ${name}`);
+        }
+        hasTests = false;
+        (0,_api__WEBPACK_IMPORTED_MODULE_2__.collectNamespaces)(ast, state);
+        value.hasTests = hasTests;
+    });
+    delete state.shouldExclude;
+    delete state.pre;
+    collectDeclarationsByName(state);
+    collectClassInfo(state);
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
+    return state;
+}
+function reportMissingSymbols(state, config) {
+    const diagnosticType = config?.checkInvalidSymbols !== "OFF"
+        ? config?.checkInvalidSymbols || "WARNING"
+        : null;
+    const compiler2DiagnosticType = config?.checkCompilerLookupRules !== "OFF"
+        ? config?.checkCompilerLookupRules || "WARNING"
+        : null;
+    if (diagnosticType &&
+        !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
+        const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
+        const report = (ast) => {
+            visitReferences(state, ast, null, false, (node, results, error) => {
+                if (node.type === "BinaryExpression" && node.operator === "has") {
+                    // Its not an error to check whether a property exists...
+                    return undefined;
+                }
+                if (!error) {
+                    if (state.sdkVersion === 4001006 &&
+                        compiler2DiagnosticType &&
+                        node.type === "MemberExpression" &&
+                        (node.object.type === "Identifier" ||
+                            node.object.type === "MemberExpression") &&
+                        results.some((result) => {
+                            const parent = result.parent;
+                            if (!parent || parent.type !== "ClassDeclaration") {
+                                return false;
+                            }
+                            return result.results.some((sn) => {
+                                switch (sn.type) {
+                                    case "VariableDeclarator":
+                                    case "FunctionDeclaration":
+                                        return (sn.attributes &
+                                            (StateNodeAttributes.PRIVATE |
+                                                StateNodeAttributes.PROTECTED));
+                                }
+                                return false;
+                            });
+                        })) {
+                        diagnostic(state, node, `The expression ${formatAst(node)} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
+                    }
+                    return undefined;
+                }
+                let nodeStr;
+                if (state.inType) {
+                    if (!checkTypes || (nodeStr = formatAst(node)).match(/^Void|Null$/)) {
+                        return undefined;
+                    }
+                }
+                diagnostic(state, node, `Undefined symbol ${nodeStr || formatAst(node)}`, diagnosticType);
+                return false;
+            });
+        };
+        Object.values(state.fnMap).forEach((v) => v.ast && report(v.ast));
+        state.rezAst && report(state.rezAst);
+    }
+}
+function compareLiteralLike(a, b) {
+    while (a.type === "BinaryExpression")
+        a = a.left;
+    while (b.type === "BinaryExpression")
+        b = b.left;
+    return a.type === "Literal" && b.type === "Literal" && a.value === b.value;
+}
+function getLiteralFromDecls(lookupDefns) {
+    if (!lookupDefns.length)
+        return null;
+    let result = null;
+    if (lookupDefns.every((lookupDefn) => lookupDefn.results.every((d) => {
+        if (d.type === "EnumStringMember" ||
+            (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+            const init = getLiteralNode(d.type === "EnumStringMember" ? d.init : d.node.init);
+            if (!init)
+                return false;
+            if (!result) {
+                result = init;
+                return true;
+            }
+            else {
+                return compareLiteralLike(init, result);
+            }
+        }
+        return false;
+    }))) {
+        return result;
+    }
+    return null;
+}
+function optimizeNode(istate, node) {
+    if (istate.state.inlining)
+        return null;
+    if (istate.state.inType) {
+        return null;
+    }
+    switch (node.type) {
+        case "UpdateExpression":
+            // we only evaluated any subexpressions of the argument.
+            evaluateNode(istate, node.argument);
+            break;
+        case "AssignmentExpression": {
+            // we only evaluated any subexpressions of the lhs.
+            const right = istate.stack.pop();
+            evaluateNode(istate, node.left);
+            istate.stack.push(right);
+            break;
+        }
+        case "BinaryExpression":
+            if (node.operator === "has" &&
+                node.right.type === "UnaryExpression" &&
+                node.right.operator === ":") {
+                // we skipped this node, so evaluate it now...
+                istate.stack.push(evaluate(istate, node.right));
+            }
+            break;
+    }
+    const before = beforeEvaluate(istate, node);
+    if (before != null)
+        return before;
+    evaluateNode(istate, node);
+    return afterEvaluate(istate, node);
+}
+function evaluateFunction(istate, func, args) {
+    if (!func.body ||
+        istate.state.inlining ||
+        (args && args.length !== func.params.length)) {
+        return false;
+    }
+    const paramValues = args &&
+        Object.fromEntries(func.params.map((p, i) => [
+            variableDeclarationName(p),
+            args[i],
+        ]));
+    let ret = null;
+    const body = args ? cloneDeep(func.body) : func.body;
+    const depth = istate.stack.length;
+    try {
+        traverseAst(body, (node) => {
+            switch (node.type) {
+                case "BlockStatement":
+                case "ReturnStatement":
+                case "UnaryExpression":
+                case "BinaryExpression":
+                case "Literal":
+                case "Identifier":
+                    return;
+                default:
+                    throw new Error("Bad node type");
+            }
+        }, !args
+            ? undefined
+            : (node) => {
+                switch (node.type) {
+                    case "ReturnStatement":
+                        ret = node.argument || null;
+                        return null;
+                    case "BlockStatement":
+                        return null;
+                    case "Identifier":
+                        if (hasProperty(paramValues, node.name)) {
+                            istate.stack.push(evaluate(istate, (node = paramValues[node.name])));
+                            return node;
+                        }
+                    // fall through;
+                    default: {
+                        const repl = optimizeNode(istate, node) || node;
+                        if (repl.type === "Literal")
+                            return repl;
+                        throw new Error("Didn't optimize");
+                    }
+                }
+            });
+        delete istate.state.inlining;
+        istate.stack.length = depth;
+        return ret;
+    }
+    catch (e) {
+        delete istate.state.inlining;
+        istate.stack.length = depth;
+        return false;
+    }
+}
+function markFunctionCalled(state, func) {
+    if (!hasProperty(state.calledFunctions, func.id.name)) {
+        state.calledFunctions[func.id.name] = [func];
+        return;
+    }
+    pushUnique(state.calledFunctions[func.id.name], func);
+}
+async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
+    const state = (await analyze(fnMap, resourcesMap, manifestXML, config));
+    state.localsStack = [{}];
+    state.calledFunctions = {};
+    state.usedByName = {};
+    let again = false;
+    const optimizeCallHelper = (istate, call, node) => {
+        const result = optimizeCall(istate, call, node);
+        if (result) {
+            if (isExpression(result)) {
+                istate.stack[istate.stack.length - 1].node = result;
+            }
+            again = true;
+        }
+        return result;
+    };
+    const topLocals = () => state.localsStack[state.localsStack.length - 1];
+    /*
+     * Might this function be called from somewhere, including
+     * callbacks from the api (eg getSettingsView, etc).
+     */
+    const maybeCalled = (func) => {
+        if (!func.body) {
+            // this is an api.mir function. It can be called
+            return true;
+        }
+        if (hasProperty(state.exposed, func.id.name))
+            return true;
+        if (func.attrs &&
+            func.attrs.attributes &&
+            func.attrs.attributes.elements.some((attr) => {
+                if (attr.type !== "UnaryExpression")
+                    return false;
+                if (attr.argument.type !== "Identifier")
+                    return false;
+                return attr.argument.name === "test";
+            })) {
+            return true;
+        }
+        if (hasProperty(state.calledFunctions, func.id.name)) {
+            return (state.calledFunctions[func.id.name].find((f) => f === func) !== null);
+        }
+        return false;
+    };
+    /*
+     * Does elm (a class) have a maybeCalled function called name,
+     * anywhere in its superClass chain.
+     */
+    const checkInherited = (elm, name) => elm.superClass === true ||
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
+                sc.decls[name].some((f) => isStateNode(f) &&
+                    f.type === "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
+    const renamer = (idnode) => {
+        const ident = idnode.type === "Identifier" ? idnode : idnode.left;
+        const locals = topLocals();
+        const { map } = locals;
+        if (map) {
+            const declName = ident.name;
+            const name = renameVariable(state, locals, declName);
+            if (name) {
+                const [, results] = state.lookupValue(ident);
+                if (!results) {
+                    throw new Error(`Didn't find local ${declName} which needed renaming`);
+                }
+                if (results.length !== 1) {
+                    throw new Error(`Lookup of local ${declName} found more than one result`);
+                }
+                const parent = results[0].parent;
+                if (!parent) {
+                    throw new Error(`No parent in lookup of local ${declName}`);
+                }
+                const decls = parent.decls;
+                if (!decls || !hasProperty(decls, declName)) {
+                    throw new Error(`Missing decls in lookup of local ${declName}`);
+                }
+                if (hasProperty(decls, name)) {
+                    throw new Error(`While renaming ${declName} to ${name}, there was already a variable ${name}`);
+                }
+                if (decls[declName].length === 1) {
+                    decls[name] = decls[declName];
+                    delete decls[declName];
+                }
+                else {
+                    let i = decls[declName].length;
+                    while (i--) {
+                        const decl = decls[declName][i];
+                        if (decl === idnode ||
+                            (decl.type === "VariableDeclarator" && decl.node.id === idnode)) {
+                            decls[declName].splice(i, 1);
+                            decls[name] = [decl];
+                            break;
+                        }
+                    }
+                    if (i < 0) {
+                        throw new Error(`While renaming ${declName} to ${name}: Didn't find original declaration`);
+                    }
+                }
+                ident.name = name;
+            }
+            else {
+                map[declName] = true;
+            }
+        }
+    };
+    // use this when optimizing initializer expressions,
+    // outside of any function.
+    const gistate = { state, stack: [] };
+    if (state.config?.checkTypes !== "OFF" &&
+        state.config?.trustDeclaredTypes &&
+        state.config.propagateTypes) {
+        gistate.typeChecker =
+            state.config.typeCheckLevel?.toLowerCase() === "strict"
+                ? subtypeOf
+                : couldBeWeak;
+        gistate.checkTypes = state.config?.checkTypes || "WARNING";
+    }
+    // use this when type inference is enabled, and we're
+    // inside a function.
+    let istate = gistate;
+    state.pre = (node) => {
+        const ret = preEvaluate(istate, node);
+        switch (node.type) {
+            case "EnumDeclaration":
+                return [];
+            case "ForStatement": {
+                const map = topLocals().map;
+                if (map) {
+                    state.localsStack.push({ node, map: { ...map } });
+                }
+                break;
+            }
+            case "VariableDeclarator": {
+                renamer(node.id);
+                break;
+            }
+            case "CatchClause":
+                if (node.param) {
+                    state.localsStack.push({ node, map: { ...(topLocals().map || {}) } });
+                    renamer(node.param);
+                }
+                break;
+            case "BinaryExpression":
+                if (node.operator === "has" &&
+                    node.right.type === "UnaryExpression" &&
+                    node.right.operator === ":") {
+                    // Using `expr has :symbol` doesn't "expose"
+                    // symbol, and the rhs of an "as" isn't an
+                    // expression. In both cases, skip the rhs
+                    return ["left"];
+                }
+                break;
+            case "Identifier": {
+                const map = topLocals().map;
+                if (map) {
+                    if (hasProperty(map, node.name)) {
+                        const name = map[node.name];
+                        if (typeof name === "string") {
+                            node.name = name;
+                        }
+                        const [, results] = state.lookupValue(node);
+                        if (results) {
+                            if (results.length !== 1 || results[0].results.length !== 1) {
+                                throw new Error(`Local ${node.name} had multiple lookup results`);
+                            }
+                            const parent = results[0].parent;
+                            if (!parent) {
+                                throw new Error(`Local ${node.name} had no parent`);
+                            }
+                            const decl = results[0].results[0];
+                            if (parent.type === "FunctionDeclaration" ||
+                                decl.type !== "VariableDeclarator") {
+                                // we can't optimize away function or catch parameters
+                                return [];
+                            }
+                            if (parent.type !== "BlockStatement") {
+                                throw new Error(`Local ${node.name} was not declared at block scope(??)`);
+                            }
+                            decl.used = true;
+                        }
+                    }
+                }
+                return [];
+            }
+            case "AssignmentExpression":
+            case "UpdateExpression": {
+                const lhs = node.type === "AssignmentExpression" ? node.left : node.argument;
+                if (lhs.type === "Identifier") {
+                    const map = topLocals().map;
+                    if (map) {
+                        if (hasProperty(map, lhs.name)) {
+                            const name = map[lhs.name];
+                            if (typeof name === "string") {
+                                lhs.name = name;
+                            }
+                        }
+                    }
+                }
+                else if (lhs.type === "MemberExpression") {
+                    const object = state.traverse(lhs.object);
+                    if (object) {
+                        lhs.object = object;
+                    }
+                    if (!isLookupCandidate(lhs)) {
+                        const property = state.traverse(lhs.property);
+                        if (property) {
+                            lhs.property = property;
+                        }
+                    }
+                }
+                return node.type === "AssignmentExpression" ? ["right"] : [];
+            }
+            case "BlockStatement": {
+                const map = topLocals().map;
+                if (map) {
+                    state.localsStack.push({
+                        node,
+                        map: { ...map },
+                    });
+                }
+                break;
+            }
+            case "FunctionDeclaration": {
+                const map = {};
+                node.params &&
+                    node.params.forEach((p) => (map[variableDeclarationName(p)] = true));
+                state.localsStack.push({ node, map });
+                const [{ sn: parent }, { sn: self }] = state.stack.slice(-2);
+                if (state.currentFunction) {
+                    throw new Error(`Nested functions: ${self.fullName} was activated during processing of ${state.currentFunction.fullName}`);
+                }
+                state.currentFunction = self;
+                const is = !state.config?.propagateTypes ||
+                    node.attrs?.attributes?.elements.find((attr) => attr.type === "UnaryExpression" &&
+                        attr.argument.name === "noConstProp")
+                    ? null
+                    : buildTypeInfo(state, state.currentFunction, true);
+                if (is) {
+                    /*
+                     * istate contains a copy of state, but we need the real
+                     * thing, because "state" is captured here.
+                     *
+                     * A better solution will be to separate out a
+                     * "lookup context", which will be a stack, plus a couple
+                     * of fields from state, and then pass that around.
+                     */
+                    is.state = state;
+                    if (state.config?.checkTypes !== "OFF" &&
+                        state.config?.trustDeclaredTypes) {
+                        is.typeChecker = gistate.typeChecker;
+                        is.checkTypes = state.config?.checkTypes || "WARNING";
+                    }
+                    istate = is;
+                }
+                if (parent.type === "ClassDeclaration" && !maybeCalled(node)) {
+                    let used = false;
+                    if (node.id.name === "initialize") {
+                        used = true;
+                    }
+                    else if (parent.superClass) {
+                        used = checkInherited(parent, node.id.name);
+                    }
+                    if (used) {
+                        markFunctionCalled(state, node);
+                    }
+                }
+                // We dont want to call evaluateNode on
+                // id, args or returnType
+                return ["body"];
+            }
+            case "ClassDeclaration":
+            case "ModuleDeclaration":
+                // We dont want to call evaluateNode on
+                // id, or superClass
+                return ["body"];
+        }
+        return ret;
+    };
+    state.post = (node) => {
+        const locals = topLocals();
+        if (locals.node === node) {
+            state.localsStack.pop();
+        }
+        const opt = optimizeNode(istate, node);
+        if (opt != null) {
+            return opt;
+        }
+        switch (node.type) {
+            case "FunctionDeclaration":
+                if (node.body && evaluateFunction(istate, node, null) !== false) {
+                    node.optimizable = true;
+                }
+                if (!state.currentFunction) {
+                    throw new Error(`Finished function ${state.top().sn.fullName}, but it was not marked current`);
+                }
+                state.currentFunction.info = state.currentFunction.next_info || false;
+                delete state.currentFunction.next_info;
+                delete state.currentFunction;
+                if (istate.stack.length) {
+                    throw new Error("Stack was not empty");
+                }
+                istate = gistate;
+                if (again) {
+                    again = false;
+                    const top = state.stack.pop();
+                    state.traverse(node);
+                    state.stack.push(top);
+                }
+                break;
+            case "BlockStatement":
+            case "ForStatement":
+                if (locals.map && cleanupUnusedVars(state, node)) {
+                    again = true;
+                }
+                break;
+            case "IfStatement": {
+                const call = inlinableSubExpression(node.test);
+                if (call) {
+                    return optimizeCallHelper(istate, call, node);
+                }
+                break;
+            }
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return optimizeCallHelper(istate, node.argument, node);
+                }
+                break;
+            case "Identifier":
+                if (hasProperty(state.index, node.name)) {
+                    state.usedByName[node.name] = true;
+                }
+                break;
+            case "MemberExpression": {
+                const property = isLookupCandidate(node);
+                if (property) {
+                    if (hasProperty(state.index, property.name)) {
+                        state.usedByName[property.name] = true;
+                    }
+                }
+                break;
+            }
+            case "NewExpression":
+                if (state.currentFunction) {
+                    const [, results] = state.lookup(node.callee);
+                    if (results) {
+                        recordCalledFuncs(state.currentFunction, findCalleesForNew(results));
+                    }
+                    else {
+                        recordModifiedUnknown(state.currentFunction);
+                    }
+                }
+                break;
+            case "CallExpression": {
+                return optimizeCallHelper(istate, node, null);
+            }
+            case "VariableDeclaration": {
+                const locals = topLocals();
+                if (locals.map &&
+                    locals.node &&
+                    locals.node.type === "BlockStatement") {
+                    let results;
+                    const declarations = node.declarations;
+                    let i = 0;
+                    let j = 0;
+                    while (i < node.declarations.length) {
+                        const decl = declarations[i++];
+                        if (!decl.init)
+                            continue;
+                        const call = inlinableSubExpression(decl.init);
+                        if (call) {
+                            const inlined = optimizeCallHelper(istate, call, decl);
+                            if (!inlined)
+                                continue;
+                            if (Array.isArray(inlined) || inlined.type !== "BlockStatement") {
+                                throw new Error("Unexpected inlined result");
+                            }
+                            if (!results) {
+                                results = [];
+                            }
+                            delete decl.init;
+                            results.push(withLoc({
+                                ...node,
+                                declarations: declarations.slice(j, i),
+                            }, j ? declarations[j] : null, decl.id));
+                            results.push(inlined);
+                            j = i;
+                        }
+                    }
+                    if (results) {
+                        if (j < i) {
+                            results.push({
+                                ...node,
+                                declarations: declarations.slice(j, i),
+                            });
+                        }
+                        return results;
+                    }
+                }
+                break;
+            }
+            case "ExpressionStatement":
+                if (node.expression.type === "CallExpression") {
+                    return optimizeCallHelper(istate, node.expression, node);
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    const call = inlinableSubExpression(node.expression.right);
+                    if (call) {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if (hasProperty(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
+                        }
+                        if (!ok && node.expression.operator === "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            ok = !!result;
+                        }
+                        if (ok) {
+                            return optimizeCallHelper(istate, call, node.expression);
+                        }
+                    }
+                }
+                else {
+                    return unused(state, node.expression, true);
+                }
+                break;
+            case "AssignmentExpression":
+            case "UpdateExpression":
+                if (state.currentFunction) {
+                    const lhs = node.type === "AssignmentExpression" ? node.left : node.argument;
+                    const [, results] = state.lookup(lhs);
+                    if (results) {
+                        recordModifiedDecls(state.currentFunction, results);
+                    }
+                    else {
+                        const id = lhs.type === "Identifier" ? lhs : isLookupCandidate(lhs);
+                        if (id) {
+                            recordModifiedName(state.currentFunction, id.name);
+                        }
+                        else {
+                            recordModifiedUnknown(state.currentFunction);
+                        }
+                    }
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        collectNamespaces(f.ast, state);
+    });
+    state.usedByName = {};
+    state.calledFunctions = {};
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
+    Object.values(fnMap).forEach((f) => {
+        collectNamespaces(f.ast, state);
+    });
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
+    delete state.pre;
+    delete state.post;
+    Object.values(state.allFunctions).forEach((fns) => fns.forEach((fn) => sizeBasedPRE(state, fn)));
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "ThisExpression":
+                node.text = "self";
+                break;
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return (hasProperty(state.index, name) &&
+                        !hasProperty(state.exposed, name) &&
+                        !hasProperty(state.usedByName, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
+                }
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
+                        return false;
+                    if (!node.body.enumType) {
+                        throw new Error("Missing enumType on optimized enum");
+                    }
+                    return {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: {
+                                type: "TypeSpecList",
+                                ts: [
+                                    node.body.enumType,
+                                ],
+                            },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    };
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = variableDeclarationName(d.id);
+                    return (!hasProperty(state.index, name) ||
+                        hasProperty(state.exposed, name) ||
+                        hasProperty(state.usedByName, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
+            }
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    if (node.attrs &&
+                        node.attrs.attributes &&
+                        node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
+                        break;
+                    }
+                    return false;
+                }
+                break;
+            case "ClassDeclaration":
+            case "ModuleDeclaration":
+                // none of the attributes means anything on classes and
+                // modules, and the new compiler complains about some
+                // of them. Just drop them all.
+                if (node.attrs && node.attrs.access) {
+                    if (node.attrs.attributes) {
+                        delete node.attrs.access;
+                    }
+                    else {
+                        delete node.attrs;
+                    }
+                }
+        }
+        return null;
+    };
+    Object.entries(fnMap).forEach(([, f]) => {
+        traverseAst(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
+        });
+    });
+    reportMissingSymbols(state, config);
+    if (state.inlineDiagnostics) {
+        if (!state.diagnostics) {
+            state.diagnostics = state.inlineDiagnostics;
+        }
+        else {
+            Object.entries(state.inlineDiagnostics).forEach(([key, diags]) => {
+                if (!hasProperty(state.diagnostics, key)) {
+                    state.diagnostics[key] = diags;
+                }
+                else {
+                    state.diagnostics[key].push(...diags);
+                }
+            });
+        }
+        delete state.inlineDiagnostics;
+    }
+    Object.entries(fnMap).forEach(([name, f]) => {
+        if (state.config && state.config.checkBuildPragmas) {
+            pragmaChecker(state, f.ast, state.diagnostics?.[name]);
+        }
+    });
+    return state.diagnostics;
+}
+function optimizeCall(istate, node, context) {
+    const state = istate.state;
+    const [name, results] = state.lookupNonlocal(node.callee);
+    const callees = results ? findCallees(results) : null;
+    if (!callees || !callees.length) {
+        const n = name ||
+            ("name" in node.callee && node.callee.name) ||
+            ("property" in node.callee &&
+                node.callee.property &&
+                "name" in node.callee.property &&
+                node.callee.property.name);
+        if (n) {
+            if (hasProperty(state.allFunctions, n)) {
+                if (state.currentFunction) {
+                    recordCalledFuncs(state.currentFunction, state.allFunctions[n]);
+                }
+                state.allFunctions[n].forEach((fn) => markFunctionCalled(state, fn.node));
+            }
+        }
+        else if (state.currentFunction) {
+            // I don't think this can happen: foo[x](args)
+            // doesn't parse, so you can't even do things like
+            // $.Toybox.Lang[:format]("fmt", [])
+            recordModifiedUnknown(state.currentFunction);
+        }
+        return null;
+    }
+    if (state.currentFunction) {
+        recordCalledFuncs(state.currentFunction, callees);
+    }
+    if (callees.length === 1 && callees[0].type === "FunctionDeclaration") {
+        const callee = callees[0].node;
+        if (!context &&
+            callee.optimizable &&
+            !callee.hasOverride &&
+            node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
+            const ret = evaluateFunction(istate, callee, node.arguments);
+            if (ret) {
+                return withLoc(ret, node, node);
+            }
+        }
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
+            if (ret) {
+                return ret;
+            }
+        }
+    }
+    callees.forEach((c) => markFunctionCalled(state, c.node));
+    return null;
+}
+
+
 /***/ }),
 
 /***/ 4499:
@@ -2780,6 +3897,900 @@ var StateNodeAttributes;
 })(StateNodeAttributes || (StateNodeAttributes = {}));
 
 
+/***/ }),
+
+/***/ 1851:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export pragmaChecker */
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+
+
+function pragmaChecker(state, ast, diagnostics) {
+    const comments = ast.comments;
+    if (!comments)
+        return;
+    diagnostics = diagnostics
+        ?.slice()
+        .sort((d1, d2) => d1.loc.start.offset - d2.loc.start.offset);
+    let diagIndex = 0;
+    let index = -1;
+    let comment;
+    let matchers;
+    const next = () => {
+        while (++index < comments.length) {
+            comment = comments[index];
+            let match = comment.value.match(/^\s*@(match|expect)\s+(.+)/);
+            if (!match)
+                continue;
+            const kind = match[1];
+            let str = match[2];
+            const verCheck = checkCompilerVersion(str.replace(/\s.*/, ""), state.sdkVersion || 0);
+            if (verCheck === false)
+                continue;
+            if (verCheck === true) {
+                str = str.replace(/^\S+\s+/, "");
+            }
+            matchers = [];
+            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
+                matchers.push({ kind, quote: match[1], needle: match[2] });
+                str = str.substring(match[0].length);
+                if (!str.length)
+                    break;
+            }
+            if (!str.length)
+                break;
+            if (!matchers.length) {
+                match = str.match(/^(\S+)\s+$/);
+                if (match) {
+                    matchers.push({ kind, quote: '"', needle: match[1] });
+                    break;
+                }
+            }
+            diagnostic(state, comment, `Build pragma '${comment.value}' is invalid`, "ERROR");
+        }
+    };
+    const matcher = (quote, needle, haystack) => {
+        if (quote === '"') {
+            return haystack.includes(needle);
+        }
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
+        return re.test(haystack);
+    };
+    next();
+    traverseAst(ast, (node) => {
+        if (index >= comments.length ||
+            node.type === "Line" ||
+            node.type === "Block" ||
+            node.type === "MultiLine") {
+            return false;
+        }
+        if (node.start && node.start >= (comment.end || Infinity)) {
+            const { kind, quote, needle } = matchers.shift();
+            if (kind === "match") {
+                const haystack = formatAst(node).replace(/([\r\n]|\s)+/g, " ");
+                if (!matcher(quote, needle, haystack)) {
+                    matcher(quote, needle, haystack);
+                    diagnostic(state, comment, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
+                }
+            }
+            else if (kind === "expect") {
+                const locCmp = (a, b) => {
+                    if (!b)
+                        return -1;
+                    if (a.start.line < b.start.line)
+                        return -1;
+                    if (a.start.line === b.start.line &&
+                        a.start.column < b.start.column) {
+                        return -1;
+                    }
+                    if (a.end.line > b.end.line)
+                        return 1;
+                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
+                        return 1;
+                    }
+                    return 0;
+                };
+                let found = false;
+                if (diagnostics) {
+                    while (true) {
+                        if (diagIndex >= diagnostics.length) {
+                            diagnostics = null;
+                            break;
+                        }
+                        const diag = diagnostics[diagIndex];
+                        const cmp = locCmp(diag.loc, node.loc);
+                        if (cmp > 0) {
+                            break;
+                        }
+                        diagIndex++;
+                        if (cmp < 0)
+                            continue;
+                        if (matcher(quote, needle, diag.message)) {
+                            found = true;
+                            diag.type = "INFO";
+                        }
+                    }
+                }
+                if (!found) {
+                    diagnostic(state, comment, `Missing error message '${needle}`, "ERROR");
+                }
+            }
+            if (matchers.length) {
+                // if we're checking a series of nodes, we need
+                // to skip over this one.
+                return false;
+            }
+            next();
+        }
+        return null;
+    });
+}
+
+
+/***/ }),
+
+/***/ 9910:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export sizeBasedPRE */
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
+/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
+/* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_5__);
+
+
+
+
+
+
+/**
+ * This implements a pseudo Partial Redundancy Elimination
+ * pass. It isn't quite like traditional PRE because we're
+ * aiming to minimize size, not dynamic instructions. So
+ * for us, its worthwhile to take something like:
+ *
+ * switch (x) {
+ *   case 1: foo(A.B); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(A.B); break;
+ * }
+ *
+ * and rewrite it as
+ *
+ * var tmp = A.B;
+ * switch (x) {
+ *   case 1: foo(tmp); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(tmp); break;
+ * }
+ *
+ * because even though A.B wasn't used on all paths where we
+ * inserted the temporary, we still reduced the code size.
+ */
+const logging = false;
+function logAntState(s, decl) {
+    const defs = Array.from(s.ant).reduce((defs, event) => {
+        if (event.type === "def" || event.type === "mod")
+            defs++;
+        return defs;
+    }, 0);
+    console.log(`  - ${declFullName(decl)}: ${candidateCost(s)} bytes, ${s.ant.size - defs} refs, ${defs} defs, ${s.live ? "" : "!"}live, ${s.isIsolated ? "" : "!"}isolated`);
+    console.log(`    - members: ${Array.from(s.members)
+        .map(([block, live]) => block.order + (live ? "t" : "f"))
+        .join(", ")}`);
+}
+function logAntDecls(antDecls) {
+    antDecls.forEach(logAntState);
+}
+function sizeBasedPRE(state, func) {
+    if (!func.node.body)
+        return;
+    if (!state.config ||
+        !state.config.sizeBasedPRE ||
+        (typeof state.config.sizeBasedPRE === "string" &&
+            state.config.sizeBasedPRE !== func.fullName)) {
+        return;
+    }
+    const { graph: head, identifiers } = buildPREGraph(state, func);
+    const candidates = computeAttributes(state, head);
+    if (candidates) {
+        if (logging) {
+            console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
+            logAntDecls(candidates);
+        }
+        const nodeMap = new Map();
+        const declMap = new Map();
+        const variableDecl = withLoc({
+            type: "VariableDeclaration",
+            declarations: [],
+            kind: "var",
+        }, func.node.body);
+        variableDecl.end = variableDecl.start;
+        variableDecl.loc.end = variableDecl.loc.start;
+        Array.from(candidates.keys())
+            .map((decl) => [declFullName(decl), decl])
+            .sort()
+            .forEach(([, decl]) => {
+            let name;
+            let i = 0;
+            do {
+                name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
+                if (!identifiers.has(name)) {
+                    identifiers.add(name);
+                    break;
+                }
+                i++;
+            } while (true);
+            declMap.set(decl, name);
+            const s = candidates.get(decl);
+            variableDecl.declarations.push(withLoc({
+                type: "VariableDeclarator",
+                id: withLoc({ type: "Identifier", name }, variableDecl),
+                kind: "var",
+            }, variableDecl));
+            s.ant.forEach((event) => {
+                const events = nodeMap.get(event.node);
+                if (!events) {
+                    nodeMap.set(event.node, [event]);
+                }
+                else {
+                    events.push(event);
+                }
+            });
+        });
+        applyReplacements(func.node, nodeMap, declMap);
+        func.node.body.body.unshift(variableDecl);
+    }
+}
+function buildPREGraph(state, func) {
+    const result = buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+    // Split blocks that contains refs and defs to the same thing,
+    // to make it easier to pick and choose which refs are converted
+    postOrderTraverse(result.graph, (block) => {
+        if (!block.events) {
+            return;
+        }
+        let modSeen = false;
+        const refs = new Set();
+        const defs = new Set();
+        const splitBlock = (eventIndex) => {
+            const newBlock = { ...block };
+            delete newBlock.node;
+            newBlock.events = block.events?.splice(eventIndex);
+            newBlock.succs?.forEach((succ) => {
+                const i = succ.preds.findIndex((b) => b === block);
+                succ.preds[i] = newBlock;
+                if (succ.expreds?.includes(block)) {
+                    succ.expreds.push(newBlock);
+                }
+            });
+            block.succs = [newBlock];
+            newBlock.preds = [block];
+            delete newBlock.expreds;
+            modSeen = false;
+            refs.clear();
+            defs.clear();
+        };
+        for (let i = block.events.length; i--;) {
+            const event = block.events[i];
+            switch (event.type) {
+                case "ref":
+                    if (some(event.decl, (decl) => decl.type === "Literal" ||
+                        (decl.type === "VariableDeclarator" &&
+                            decl.node.kind === "const"))) {
+                        break;
+                    }
+                    if (modSeen || defs.has(event.decl)) {
+                        splitBlock(i + 1);
+                    }
+                    refs.add(event.decl);
+                    break;
+                case "def":
+                    if (refs.has(event.decl)) {
+                        splitBlock(i + 1);
+                    }
+                    defs.add(event.decl);
+                    break;
+                case "mod":
+                    if (event.callees &&
+                        every(event.callees, (callee) => callee.info === false)) {
+                        // calls known to have no side effects can be
+                        // dropped.
+                        block.events.splice(i, 1);
+                        break;
+                    }
+                    if (refs.size) {
+                        splitBlock(i + 1);
+                    }
+                    modSeen = true;
+                    break;
+            }
+        }
+    });
+    return result;
+}
+function anticipatedDecls() {
+    return new Map();
+}
+function equalSet(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+function equalMap(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [item, value] of a) {
+        if (b.get(item) !== value)
+            return false;
+    }
+    return true;
+}
+function anticipatedState(node, events) {
+    return { ant: events || new Set(), live: true, node, members: new Map() };
+}
+function cloneAnticipatedState(as) {
+    return {
+        ant: cloneSet(as.ant),
+        live: as.live,
+        node: as.node,
+        members: new Map(as.members),
+    };
+}
+function mergeAnticipatedState(ae, be) {
+    mergeSet(ae.ant, be.ant);
+    be.members.forEach((live, block) => ae.members.set(block, live));
+    if (be.live)
+        ae.live = true;
+}
+function cloneAnticipatedDecls(ad) {
+    const copy = anticipatedDecls();
+    for (const [k, v] of ad) {
+        if (!v.isIsolated) {
+            copy.set(k, cloneAnticipatedState(v));
+        }
+    }
+    return copy;
+}
+function mergeAnticipatedDecls(a, b) {
+    for (const [k, v] of b) {
+        if (v.isIsolated)
+            continue;
+        const ae = a.get(k);
+        if (ae) {
+            mergeAnticipatedState(ae, v);
+        }
+        else {
+            a.set(k, cloneAnticipatedState(v));
+        }
+    }
+}
+function equalStates(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [k, ae] of a) {
+        const be = b.get(k);
+        if (!be ||
+            be.live !== ae.live ||
+            be.isIsolated !== ae.isIsolated ||
+            !equalSet(ae.ant, be.ant) ||
+            !equalMap(ae.members, be.members)) {
+            return false;
+        }
+    }
+    return true;
+}
+const LocalRefCost = 2;
+function refCost(node) {
+    if (node.type === "Literal") {
+        switch (typeof node.value) {
+            case "string":
+                return 5;
+            case "bigint":
+            case "number":
+                return 5;
+            case "boolean":
+                return 2;
+            default:
+                if (node.value === null) {
+                    return 2;
+                }
+                return 0;
+        }
+    }
+    // A read from a non-local identifier takes 8 bytes
+    let cost = 8;
+    if (node.type === "Identifier")
+        return cost;
+    while (true) {
+        const next = node.object;
+        if (next.type !== "MemberExpression") {
+            if (next.type !== "ThisExpression") {
+                cost += next.type === "Identifier" && next.name === "$" ? 4 : 6;
+            }
+            return cost;
+        }
+        node = next;
+        cost += 6;
+    }
+}
+function defCost(node) {
+    return refCost(node) + 2;
+}
+function candidateBoundary(candState) {
+    const boundary = new Set();
+    candState.members.forEach((live, block) => {
+        if (live && block !== candState.head) {
+            if (block.preds) {
+                block.preds.forEach((pred) => candState.members.has(pred) || boundary.add(pred));
+            }
+        }
+    });
+    if (candState.live) {
+        if (!candState.head) {
+            throw new Error(`Missing head`);
+        }
+        boundary.add(candState.head);
+    }
+    return boundary;
+}
+function candidateCost(candState) {
+    let cost = 0;
+    candState.ant.forEach((event) => {
+        if (event.type === "ref") {
+            cost -= refCost(candState.node) - LocalRefCost;
+        }
+        else {
+            cost += defCost(candState.node);
+        }
+    });
+    const boundarySize = candidateBoundary(candState).size;
+    cost += defCost(candState.node) * boundarySize;
+    return cost;
+}
+function computeAttributes(state, head) {
+    const order = getPostOrder(head);
+    order.forEach((block, i) => {
+        block.order = i;
+    });
+    if (logging) {
+        order.forEach((block) => {
+            console.log(block.order, `(${block.node ? block.node.loc?.start.line : "??"})`, `Preds: ${(block.preds || [])
+                .map((block) => block.order)
+                .join(", ")}`);
+            if (block.events) {
+                block.events.forEach((event) => event.type !== "exn" &&
+                    console.log(`    ${event.type}: ${event.decl
+                        ? declFullName(event.decl)
+                        : event.node
+                            ? formatAst(event.node)
+                            : "??"}`));
+            }
+            console.log(`Succs: ${(block.succs || [])
+                .map((block) => block.order)
+                .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
+        });
+    }
+    const queue = new DataflowQueue();
+    const blockStates = [];
+    /*
+      Algorithm
+      =========
+  
+      Process blocks in post-order, and the events in reverse
+      order to collect the AnticipatedState at the start of each
+      Block.
+  
+      Then for each EventDecl find the best starting block.
+    */
+    const modMap = new Map();
+    const getMod = (event, decl, id) => {
+        if (id.type !== "Identifier" && id.type !== "MemberExpression") {
+            throw new Error("Trying to modify a non-variable");
+        }
+        let eventMap = modMap.get(event);
+        if (!eventMap) {
+            modMap.set(event, (eventMap = new Map()));
+        }
+        let result = eventMap.get(decl);
+        if (!result) {
+            result = {
+                type: "mod",
+                node: event.node,
+                decl,
+                id,
+                mayThrow: event.mayThrow,
+            };
+            eventMap.set(decl, result);
+        }
+        return result;
+    };
+    order.forEach((block) => queue.enqueue(block));
+    while (!queue.empty()) {
+        const top = queue.dequeue();
+        if (top.order === undefined) {
+            throw new Error(`Unreachable block was visited!`);
+        }
+        const curState = (top.succs &&
+            top.succs.reduce((blockState, succ) => {
+                const succState = blockStates[succ.order];
+                if (succState) {
+                    if (!blockState) {
+                        blockState = cloneAnticipatedDecls(succState);
+                    }
+                    else {
+                        mergeAnticipatedDecls(blockState, succState);
+                    }
+                }
+                return blockState;
+            }, null)) ||
+            anticipatedDecls();
+        if (top.events) {
+            for (let i = top.events.length; i--;) {
+                const event = top.events[i];
+                if (event.mayThrow && top.exsucc) {
+                    const succState = blockStates[top.exsucc.order];
+                    if (succState) {
+                        mergeAnticipatedDecls(curState, succState);
+                    }
+                }
+                switch (event.type) {
+                    case "ref": {
+                        let candidates = curState.get(event.decl);
+                        if (!candidates) {
+                            candidates = anticipatedState(event.node);
+                            curState.set(event.decl, candidates);
+                        }
+                        candidates.ant.add(event);
+                        candidates.live = true;
+                        break;
+                    }
+                    case "mod": {
+                        curState.forEach((candidates, decls) => {
+                            if (some(decls, (decl) => decl.type === "VariableDeclarator" &&
+                                decl.node.kind === "var" &&
+                                candidates.live &&
+                                (!event.callees ||
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl))))) {
+                                candidates.ant.add(getMod(event, decls, candidates.node));
+                                candidates.live = false;
+                            }
+                        });
+                        break;
+                    }
+                    case "def": {
+                        let candidates = curState.get(event.decl);
+                        const isUpdate = event.node.type === "UpdateExpression" ||
+                            (event.node.type === "AssignmentExpression" &&
+                                event.node.operator !== "=");
+                        if (!candidates) {
+                            const target = event.node.type === "AssignmentExpression"
+                                ? event.node.left
+                                : event.node.type === "UpdateExpression"
+                                    ? event.node.argument
+                                    : event.node.id.type === "BinaryExpression"
+                                        ? event.node.id.left
+                                        : event.node.id;
+                            candidates = anticipatedState(target);
+                            curState.set(event.decl, candidates);
+                        }
+                        if (isUpdate || candidates.live) {
+                            candidates.ant.add(event);
+                        }
+                        candidates.live = isUpdate;
+                        break;
+                    }
+                }
+            }
+        }
+        curState.forEach((antState) => {
+            antState.head = top;
+            antState.members.set(top, antState.live);
+            if (!antState.live && candidateBoundary(antState).size === 0) {
+                // we found a group that's isolated from the rest
+                // of the function. Don't merge it with earlier
+                // refs and defs, because we can take it or leave
+                // it based on its own cost.
+                antState.isIsolated = true;
+            }
+        });
+        const oldState = blockStates[top.order];
+        if (oldState && equalStates(oldState, curState)) {
+            continue;
+        }
+        blockStates[top.order] = curState;
+        if (logging) {
+            console.log(`Updated block ${top.order}`);
+            logAntDecls(curState);
+        }
+        if (top.preds) {
+            top.preds.forEach((pred) => queue.enqueue(pred));
+        }
+    }
+    const candidateDecls = anticipatedDecls();
+    blockStates.forEach((blockState, i) => {
+        blockState &&
+            blockState.forEach((events, decl) => {
+                const cost = candidateCost(events);
+                if (cost >= 0)
+                    return;
+                const existing = candidateDecls.get(decl);
+                if (!existing ||
+                    existing.isIsolated ||
+                    candidateCost(existing) > cost) {
+                    const boundary = candidateBoundary(events);
+                    if (!Array.from(boundary).every((block) => {
+                        if (block !== events.head && block.events) {
+                            if (events.node.type === "Literal") {
+                                return false;
+                            }
+                            let i = block.events.length;
+                            while (i--) {
+                                const event = block.events[i];
+                                if (event.type === "def" || event.type === "mod") {
+                                    events.ant.add({
+                                        type: "mod",
+                                        node: event.node,
+                                        decl,
+                                        id: events.node,
+                                        mayThrow: false,
+                                    });
+                                    events.members.set(block, false);
+                                    return true;
+                                }
+                            }
+                        }
+                        const node = block.node;
+                        if (!node)
+                            return false;
+                        events.ant.add({
+                            type: "mod",
+                            node: node.type === "FunctionDeclaration" ? node.body : node,
+                            before: true,
+                            decl,
+                            id: events.node,
+                            mayThrow: false,
+                        });
+                        events.members.set(block, false);
+                        return true;
+                    })) {
+                        return;
+                    }
+                    events.live = false;
+                    if (existing && existing.isIsolated) {
+                        delete existing.isIsolated;
+                        mergeAnticipatedState(events, existing);
+                    }
+                    else if (candidateCost(events) !== cost) {
+                        throw new Error(`cost of block ${i} changed`);
+                    }
+                    candidateDecls.set(decl, events);
+                }
+            });
+    });
+    if (candidateDecls.size) {
+        return candidateDecls;
+    }
+    return null;
+}
+/*
+ * Determine the cost of fixing a def under a statement.
+ *
+ * eg:
+ *
+ *   if (foo()) {
+ *      bar(X.y);
+ *   } else {
+ *      baz(X.y);
+ *   }
+ *
+ * Here, we could pull out X.y as a local, but if foo might modify
+ * X.y, we have nowhere to insert the temporary. But we can rewrite
+ * it as:
+ *
+ *   var tmp = foo();
+ *   if (tmp) {
+ *      bar(X.y);
+ *   } else {
+ *      baz(X.y);
+ *   }
+ *
+ * and now we can insert a temporary before the if, but it costs
+ * 4 bytes to do so.
+ *
+ * We can do the same for switch statements unless (ugh!)
+ * the cases might modify the decl too.
+ *
+ * eg
+ *
+ *   switch (foo()) {
+ *     case bar(): ...
+ *   }
+ *
+ */
+function _isFixableStmt(node) {
+    switch (node.type) {
+        case "IfStatement":
+            return 4;
+        case "SwitchStatement":
+            if (node.cases.every((c) => !c.test ||
+                c.test.type === "Literal" ||
+                c.test.type === "Identifier" ||
+                c.test.type === "InstanceOfCase" ||
+                (c.test.type === "UnaryExpression" && c.test.operator === ":"))) {
+                return 4;
+            }
+            break;
+    }
+    return false;
+}
+function applyReplacements(func, nodeMap, declMap) {
+    const ident = (name, node) => {
+        return withLoc({ type: "Identifier", name }, node);
+    };
+    const pendingMap = new Map();
+    const stmtStack = [func];
+    traverseAst(func, (node) => {
+        if (isStatement(node)) {
+            stmtStack.push(node);
+        }
+    }, (node) => {
+        const stmt = stmtStack[stmtStack.length - 1];
+        if (stmt === node)
+            stmtStack.pop();
+        const events = nodeMap.get(node);
+        if (events) {
+            const ret = events.reduce((ret, event) => {
+                if (event.type === "ref") {
+                    if (ret) {
+                        throw new Error(`ref found when there was already a replacement for this node`);
+                    }
+                    if (node.type !== "Identifier" &&
+                        node.type !== "MemberExpression" &&
+                        node.type !== "Literal") {
+                        throw new Error(`Ref found, but wrong type of node: ${node.type}`);
+                    }
+                    const name = declMap.get(event.decl);
+                    if (!name) {
+                        throw new Error(`No replacement found for "${formatAst(node)}"`);
+                    }
+                    return ident(name, node);
+                }
+                if (event.type === "def") {
+                    if (ret) {
+                        throw new Error(`def found when there was already a replacement for this node`);
+                    }
+                    if (node.type !== "AssignmentExpression" &&
+                        node.type !== "UpdateExpression") {
+                        throw new Error(`Def found, but wrong type of node: ${node.type}`);
+                    }
+                    const target = node.type === "AssignmentExpression"
+                        ? node.left
+                        : node.argument;
+                    const name = declMap.get(event.decl);
+                    if (!name) {
+                        throw new Error(`No replacement found for "${formatAst(target)}"`);
+                    }
+                    const id = ident(name, target);
+                    const assign = withLoc({
+                        type: "AssignmentExpression",
+                        left: target,
+                        right: { ...id },
+                        operator: "=",
+                    }, node);
+                    if (node.type === "AssignmentExpression") {
+                        node.left = id;
+                    }
+                    else {
+                        node.argument = id;
+                    }
+                    return withLoc({ type: "SequenceExpression", expressions: [node, assign] }, node);
+                }
+                if (event.type === "mod") {
+                    if (!event.decl) {
+                        throw new Error(`Unexpected null decl on mod event`);
+                    }
+                    let pending = pendingMap.get(stmt);
+                    if (!pending) {
+                        pendingMap.set(stmt, (pending = new Set()));
+                    }
+                    pending.add(event);
+                }
+                else {
+                    throw new Error(`Unexpected ${event.type} found`);
+                }
+                return ret;
+            }, null);
+            if (ret) {
+                return ret;
+            }
+        }
+        const pending = pendingMap.get(node);
+        if (node.type === "SequenceExpression") {
+            if (pending) {
+                throw new Error(`Unexpected pending list at SequenceExpression`);
+            }
+            for (let i = node.expressions.length; i--;) {
+                const ni = node.expressions[i];
+                if (ni.type === "SequenceExpression") {
+                    node.expressions.splice(i, 1, ...ni.expressions);
+                }
+            }
+        }
+        const applyPending = (results, locNode) => {
+            const target = results.length === 1 && results[0].type === "BlockStatement"
+                ? results[0]
+                : null;
+            pendingMap.delete(node);
+            pending.forEach((event) => {
+                const decl = event.decl;
+                const name = declMap.get(decl);
+                if (!name) {
+                    throw new Error(`No replacement found for "${declFullName(decl)}"`);
+                }
+                if (!event.id) {
+                    throw new Error(`Missing id for mod event for "${declFullName(decl)}"`);
+                }
+                const rhs = withLocDeep(event.id, locNode, locNode);
+                rhs.end = rhs.start;
+                if (rhs.loc) {
+                    rhs.loc.end = rhs.loc.start;
+                }
+                const insertion = withLoc({
+                    type: "ExpressionStatement",
+                    expression: withLoc({
+                        type: "AssignmentExpression",
+                        left: ident(name, rhs),
+                        right: rhs,
+                        operator: "=",
+                    }, rhs),
+                }, rhs);
+                if (event.type === "mod" && event.before) {
+                    if (target) {
+                        target.body.unshift(insertion);
+                    }
+                    else {
+                        results.unshift(insertion);
+                    }
+                }
+                else {
+                    results.push(insertion);
+                }
+            });
+            return results.length === 1 ? null : results;
+        };
+        if (node.type === "ExpressionStatement" &&
+            node.expression.type === "SequenceExpression") {
+            const results = [];
+            node.expression.expressions.forEach((expression) => {
+                results.push({ ...node, expression });
+            });
+            if (!pending) {
+                return results;
+            }
+            return applyPending(results, node);
+        }
+        if (pending) {
+            return applyPending([node], node);
+        }
+        return null;
+    });
+}
+
+
 /***/ }),
 
 /***/ 4859:
@@ -3089,7 +5100,7 @@ function filterDecls(decls, possible, name) {
                     const stack = d.stack;
                     possible.forEach((poss) => {
                         for (let i = stack.length; i--;) {
-                            const sn = stack[i];
+                            const sn = stack[i].sn;
                             if (sn.decls === poss.decls) {
                                 if (!cur[0]) {
                                     cur = [new Set(), new Set()];
@@ -3310,9 +5321,21 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         if (Array.isArray(decl) ||
             (decl.type !== "MemberDecl" && decl.type !== "Unknown")) {
             if (!clearEquiv) {
+                /*
+                 * If we're not clearing the equivalencies then this update
+                 * must be applied to every element of the set
+                 */
                 const v = blockState.get(decl);
                 if (v?.equivSet) {
-                    blockState.set(decl, { ...v, curType: value });
+                    let s = decl;
+                    do {
+                        const next = blockState.get(s);
+                        if (!next || !next.equivSet) {
+                            throw new Error(`Inconsistent equivSet for ${tsKey(decl)}: missing value for ${tsKey(s)}`);
+                        }
+                        blockState.set(s, { ...next, curType: value });
+                        s = next.equivSet.next;
+                    } while (s !== decl);
                     return;
                 }
             }
@@ -3418,7 +5441,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 return tmpState;
             }
             if (isExact(right) &&
-                right.type & SingleTonTypeTagsConst &&
+                right.type & SingletonTypeTagsConst &&
                 left.type & right.type) {
                 // left is not equal to right, and right is one of the
                 // singleton types; so we can remove that type from left.
@@ -4336,7 +6359,7 @@ function common_types(left, right, allowed) {
     }
     if (lt & 8 /* TypeTag.Number */) {
         result |=
-            rt & 6 /* TypeTag.Boolean */ ? 6 /* TypeTag.Boolean */ : rt & ~SingleTonTypeTagsConst;
+            rt & 6 /* TypeTag.Boolean */ ? 6 /* TypeTag.Boolean */ : rt & ~SingletonTypeTagsConst;
     }
     if (lt & 16 /* TypeTag.Long */) {
         if (rt & 6 /* TypeTag.Boolean */) {
@@ -4746,7 +6769,7 @@ function calleeObjectType(istate, callee) {
     }
     if (callee.type === "Identifier" && istate.func) {
         const func = istate.func;
-        const [self] = func.stack.slice(-1);
+        const [{ sn: self }] = func.stack.slice(-1);
         return typeFromTypeStateNode(istate.state, self, (func.attributes & StateNodeAttributes.STATIC) !== 0 ||
             self.type !== "ClassDeclaration");
     }
@@ -4878,14 +6901,14 @@ function checkCallArgs(istate, node, callees, args) {
     return resultType;
 }
 function isOverride(cur, funcs) {
-    const cls = cur.stack?.[cur.stack.length - 1];
+    const cls = cur.stack?.[cur.stack.length - 1]?.sn;
     if (cls?.type === "ClassDeclaration" && cls.superClasses) {
         const supers = getSuperClasses(cls);
         if (supers &&
             some(funcs, (func) => {
                 if (func === cur)
                     return false;
-                const fcls = func.stack?.[func.stack.length - 1];
+                const fcls = func.stack?.[func.stack.length - 1].sn;
                 return fcls ? supers.has(fcls) : false;
             })) {
             return true;
@@ -5659,7 +7682,7 @@ function evaluateNode(istate, node) {
         case "ThisExpression": {
             const self = (() => {
                 for (let i = state.stack.length; i--;) {
-                    const si = state.stack[i];
+                    const si = state.stack[i].sn;
                     if (si.type === "ClassDeclaration") {
                         const klass = { type: 16384 /* TypeTag.Class */, value: si };
                         if ((istate.func?.attributes || 0) & StateNodeAttributes.STATIC) {
@@ -5869,7 +7892,7 @@ function evaluateNode(istate, node) {
             if (node.init) {
                 const init = popIstate(istate, node.init);
                 if (node.id.type === "BinaryExpression" && istate.typeChecker) {
-                    const top = istate.state.stack[istate.state.stack.length - 1];
+                    const top = istate.state.top().sn;
                     if (top.type !== "BlockStatement") {
                         const declType = typeFromTypespec(istate.state, node.id.right);
                         if (!istate.typeChecker(init.value, declType)) {
@@ -6458,58 +8481,692 @@ function restrictExactTypesByEquality(a, b) {
         default:
             unhandledType(a);
     }
-    return { type: 0 /* TypeTag.Never */ };
+    return { type: 0 /* TypeTag.Never */ };
+}
+function restrictByEqualityByComponent(a, b) {
+    let bits = a.type;
+    if (a.value == null && (b.type & bits) === b.type) {
+        // shortcut:
+        // if b.type is contained in a.type, and a has no
+        // specialization, the result is just b.
+        return b;
+    }
+    let br = null;
+    do {
+        const next = bits & (bits - 1);
+        const bit = bits - next;
+        const brt = restrictExactTypesByEquality({
+            type: bit,
+            value: getUnionComponent(a, bit) || undefined,
+        }, b);
+        if (brt.type !== 0 /* TypeTag.Never */) {
+            if (!br) {
+                br = cloneType(brt);
+            }
+            else {
+                unionInto(br, brt);
+            }
+        }
+        bits = next;
+    } while (bits);
+    if (!br) {
+        return { type: 0 /* TypeTag.Never */ };
+    }
+    return br;
+}
+/*
+ * Given that a == b, reutnr what we can deduce about b's
+ * type.
+ *
+ * Note that this is similar to intersection. In many cases, it
+ * is intersection. eg if a is the type (Null or "Hello" or Menu)
+ * then we know b's type must be a subtype of intersection(a, b).
+ *
+ * But eg if it was a == 5, and a is known to be Char, String,
+ * Number or Float, we can only eliminate String, because
+ * 5.0 == 5, and 5.toChar() == 5.
+ */
+function restrictByEquality(a, b) {
+    if (a.type === 0 /* TypeTag.Never */)
+        return a;
+    if (isExact(a)) {
+        return restrictExactTypesByEquality(a, b);
+    }
+    return restrictByEqualityByComponent(a, b);
+}
+
+
+/***/ }),
+
+/***/ 3687:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony exports optimizeFunction, beforeEvaluate, afterEvaluate, tryDeEnumerate */
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(333);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+/* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4859);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(7161);
+/* harmony import */ var _interp_binary__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4706);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7255);
+
+
+
+
+
+
+
+function optimizeFunction(state, func) {
+    const istate = buildTypeInfo(state, func, true);
+    if (!istate)
+        return;
+    evaluate({
+        ...istate,
+        pre(node) {
+            return beforeEvaluate(this, node);
+        },
+        post(node) {
+            return afterEvaluate(this, node);
+        },
+    }, func.node.body);
+}
+function beforeEvaluate(istate, node) {
+    switch (node.type) {
+        case "ConditionalExpression": {
+            let alternate = tryPop(istate, node.alternate);
+            let consequent = tryPop(istate, node.consequent);
+            const test = popIstate(istate, node.test);
+            const result = mustBeTrue(test.value)
+                ? true
+                : mustBeFalse(test.value)
+                    ? false
+                    : null;
+            if (result !== null) {
+                if (!test.embeddedEffects) {
+                    const arg = result ? consequent : alternate;
+                    istate.stack.push(arg);
+                    return result ? node.consequent : node.alternate;
+                }
+            }
+            if (node.alternate &&
+                node.test.type === "UnaryExpression" &&
+                node.test.operator === "!" &&
+                test.value.type === 6 /* TypeTag.Boolean */) {
+                const alternateNode = node.alternate;
+                node.alternate = node.consequent;
+                node.consequent = alternateNode;
+                const tmp = alternate;
+                alternate = consequent;
+                consequent = tmp;
+                test.node = node.test = node.test.argument;
+            }
+            if (test.value.type === 6 /* TypeTag.Boolean */ &&
+                ((consequent.value.type === 4 /* TypeTag.True */ &&
+                    alternate.value.type === 2 /* TypeTag.False */) ||
+                    (consequent.value.type === 2 /* TypeTag.False */ &&
+                        alternate.value.type === 4 /* TypeTag.True */)) &&
+                !consequent.embeddedEffects &&
+                !alternate.embeddedEffects) {
+                if (consequent.value.type === 2 /* TypeTag.False */) {
+                    test.node = wrap({
+                        type: "UnaryExpression",
+                        operator: "!",
+                        argument: node.test,
+                        prefix: true,
+                    }, test.node.loc);
+                }
+                istate.stack.push(test);
+                return test.node;
+            }
+            istate.stack.push(test, consequent, alternate);
+            break;
+        }
+        case "IfStatement": {
+            if (node.alternate &&
+                node.alternate.type === "BlockStatement" &&
+                !node.alternate.body.length) {
+                delete node.alternate;
+            }
+            const test = popIstate(istate, node.test);
+            if (!node.alternate &&
+                node.consequent.type === "BlockStatement" &&
+                !node.consequent.body.length) {
+                const ret = withLoc(node.consequent, node.test, node.test);
+                const u = test.embeddedEffects && unused(istate.state, node.test);
+                if (u) {
+                    node.consequent.body = u;
+                }
+                return ret;
+            }
+            const result = mustBeTrue(test.value)
+                ? true
+                : mustBeFalse(test.value)
+                    ? false
+                    : null;
+            if (result !== null) {
+                const rep = result ? node.consequent : node.alternate || false;
+                if (!test.embeddedEffects) {
+                    return rep;
+                }
+                const estmt = wrap({ type: "ExpressionStatement", expression: node.test }, node.loc);
+                if (!rep) {
+                    return estmt;
+                }
+                if (rep.type === "BlockStatement") {
+                    rep.body.unshift(estmt);
+                    return rep;
+                }
+            }
+            if (node.alternate &&
+                node.test.type === "UnaryExpression" &&
+                node.test.operator === "!" &&
+                test.value.type === 6 /* TypeTag.Boolean */) {
+                const alternate = node.alternate;
+                node.alternate = node.consequent;
+                node.consequent = alternate;
+                test.node = node.test = node.test.argument;
+            }
+            istate.stack.push(test);
+            break;
+        }
+        case "WhileStatement":
+        case "DoWhileStatement": {
+            const test = popIstate(istate, node.test);
+            if (!test.embeddedEffects) {
+                if (mustBeFalse(test.value)) {
+                    return node.type === "WhileStatement" ? false : node.body;
+                }
+            }
+            istate.stack.push(test);
+            break;
+        }
+        case "BinaryExpression":
+            if (node.operator === "has" &&
+                node.right.type === "UnaryExpression" &&
+                node.right.operator === ":") {
+                const [left, right] = istate.stack.slice(-2);
+                if (left.embeddedEffects ||
+                    right.embeddedEffects ||
+                    !hasValue(left.value) ||
+                    !hasValue(right.value) ||
+                    !(left.value.type & (4096 /* TypeTag.Module */ | 16384 /* TypeTag.Class */))) {
+                    break;
+                }
+                const id = node.right.argument;
+                if (every(left.value.value, (m) => {
+                    if (hasProperty(m.decls, id.name))
+                        return false;
+                    // This is overkill, since we've already looked up
+                    // node.left, but the actual lookup rules are complicated,
+                    // and embedded within state.lookup; so just defer to that.
+                    return (istate.state.lookup({
+                        type: "MemberExpression",
+                        object: node.left,
+                        property: id,
+                        computed: false,
+                    })[1] == null);
+                })) {
+                    popIstate(istate, node.right);
+                    popIstate(istate, node.left);
+                    const rep = wrap({ type: "Literal", value: false, raw: "false" }, node.loc);
+                    istate.stack.push({
+                        value: { type: 2 /* TypeTag.False */ },
+                        embeddedEffects: false,
+                        node: rep,
+                    });
+                    return rep;
+                }
+            }
+            else {
+                if (node.operator !== "as") {
+                    const left = tryDeEnumerate(istate, node.left, -2);
+                    if (left)
+                        node.left = left;
+                    const right = tryDeEnumerate(istate, node.right, -1);
+                    if (right)
+                        node.right = right;
+                }
+                const rep = tryCommuteAndAssociate(istate, node);
+                if (rep)
+                    return rep;
+            }
+            break;
+        case "LogicalExpression": {
+            const right = tryPop(istate, node.right);
+            const left = popIstate(istate, node.left);
+            const isAnd = node.operator === "&&" || node.operator === "and";
+            if (isAnd ? mustBeFalse(left.value) : mustBeTrue(left.value)) {
+                istate.stack.push(left);
+                return node.left;
+            }
+            if (
+            // bail if left could be anything other than bool/integer
+            (left.value.type &
+                (6 /* TypeTag.Boolean */ | 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */)) !==
+                left.value.type ||
+                // bail if left could be boolean AND it could be integer
+                (left.value.type & 6 /* TypeTag.Boolean */ &&
+                    left.value.type & (8 /* TypeTag.Number */ | 16 /* TypeTag.Long */)) ||
+                // bail if right doesn't match left
+                (right.value.type &
+                    (left.value.type & 6 /* TypeTag.Boolean */
+                        ? 6 /* TypeTag.Boolean */
+                        : 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */)) !==
+                    right.value.type) {
+                istate.stack.push(left);
+                istate.stack.push(right);
+                break;
+            }
+            if (right.value.type === (isAnd ? 4 /* TypeTag.True */ : 2 /* TypeTag.False */) &&
+                !right.embeddedEffects &&
+                (left.value.type & 6 /* TypeTag.Boolean */) === left.value.type) {
+                istate.stack.push(left);
+                return node.left;
+            }
+            if (right.value.type === (isAnd ? 2 /* TypeTag.False */ : 4 /* TypeTag.True */) &&
+                !left.embeddedEffects &&
+                (left.value.type & 6 /* TypeTag.Boolean */) === left.value.type) {
+                istate.stack.push(right);
+                return node.right;
+            }
+            istate.stack.push(left);
+            istate.stack.push(right);
+            if (isAnd ? !mustBeTrue(left.value) : !mustBeFalse(left.value)) {
+                break;
+            }
+            if (!(left.value.type & ~6 /* TypeTag.Boolean */)) {
+                // the left type is boolean, so the
+                // `&` or `|` would be a no-op. We
+                // need to check that its side-effect
+                // free. Just cheap checks for now.
+                if (!left.embeddedEffects) {
+                    istate.stack.splice(-2, 2, right);
+                    return node.right;
+                }
+            }
+            const rep = node;
+            rep.type = "BinaryExpression";
+            rep.operator = isAnd ? "&" : "|";
+            break;
+        }
+        case "ForStatement": {
+            if (node.update?.type === "Literal" ||
+                (node.update?.type === "SequenceExpression" &&
+                    node.update.expressions.length === 0)) {
+                popIstate(istate, node.update);
+                delete node.update;
+            }
+            if (node.init?.type === "Literal" ||
+                (node.init?.type === "SequenceExpression" &&
+                    node.init.expressions.length === 0)) {
+                delete node.init;
+                const depth = -1 - (node.update ? 1 : 0) - (node.test ? 1 : 0);
+                istate.stack.splice(depth, 1);
+            }
+            break;
+        }
+        case "BlockStatement": {
+            for (let i = node.body.length; i--;) {
+                const stmt = node.body[i];
+                if (stmt.type === "VariableDeclaration" && !stmt.declarations.length) {
+                    node.body.splice(i, 1);
+                }
+                else if (stmt.type === "BlockStatement" &&
+                    stmt.body.every((s) => s.type !== "VariableDeclaration")) {
+                    node.body.splice(i, 1, ...stmt.body);
+                }
+            }
+            break;
+        }
+        case "SequenceExpression": {
+            for (let i = node.expressions.length; i--;) {
+                const expr = node.expressions[i];
+                if (expr.type === "Literal") {
+                    istate.stack.splice(i - node.expressions.length, 1);
+                    node.expressions.splice(i, 1);
+                }
+            }
+            break;
+        }
+        case "AssignmentExpression": {
+            if (node.operator === "=") {
+                let selfAssign = false;
+                if (node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    selfAssign = true;
+                }
+                else {
+                    const [left, right] = istate.stack.slice(-2);
+                    if (!left.embeddedEffects &&
+                        !right.embeddedEffects &&
+                        mustBeIdentical(left.value, right.value)) {
+                        selfAssign = true;
+                    }
+                }
+                if (selfAssign) {
+                    popIstate(istate, node.right);
+                    popIstate(istate, node.left);
+                    const rep = withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
+                    istate.stack.push({
+                        value: { type: 1 /* TypeTag.Null */ },
+                        embeddedEffects: false,
+                        node: rep,
+                    });
+                    return rep;
+                }
+            }
+            break;
+        }
+    }
+    return null;
+}
+function afterEvaluate(istate, node) {
+    if (isExpression(node) && node.type !== "Literal") {
+        const top = istate.stack[istate.stack.length - 1];
+        if (!top.embeddedEffects && hasValue(top.value)) {
+            const rep = mcExprFromType(top.value);
+            if (rep) {
+                top.node = rep;
+                return withLoc(rep, node, node);
+            }
+        }
+    }
+    return null;
+}
+function identity(istate, node, left, right, allowedTypes, target) {
+    if (hasValue(right.value) &&
+        right.value.type & allowedTypes &&
+        !(left.value.type & ~allowedTypes) &&
+        Number(right.value.value) === target) {
+        // a +/- 0 => a
+        // but we still need to check that the type of the zero
+        // doesn't change the type of the result.
+        if (right.value.type === 8 /* TypeTag.Number */ ||
+            (right.value.type === 16 /* TypeTag.Long */ &&
+                !(left.value.type & ~(16 /* TypeTag.Long */ | 64 /* TypeTag.Double */))) ||
+            (right.value.type === 32 /* TypeTag.Float */ &&
+                !(left.value.type & ~(32 /* TypeTag.Float */ | 64 /* TypeTag.Double */))) ||
+            (right.value.type === 64 /* TypeTag.Double */ &&
+                left.value.type === 64 /* TypeTag.Double */)) {
+            istate.stack.pop();
+            return node.left;
+        }
+    }
+    return null;
+}
+function zero(istate, node, left, right, allowedTypes, target) {
+    if (hasValue(right.value) &&
+        right.value.type & allowedTypes &&
+        !(left.value.type & ~allowedTypes) &&
+        Number(right.value.value) === target) {
+        // a * 0 => 0
+        // but we still need to check that the type of a
+        // doesn't change the type of the zero.
+        if ((right.value.type === 8 /* TypeTag.Number */ &&
+            left.value.type === 8 /* TypeTag.Number */) ||
+            (right.value.type === 16 /* TypeTag.Long */ &&
+                !(left.value.type & ~(16 /* TypeTag.Long */ | 8 /* TypeTag.Number */))) ||
+            (right.value.type === 32 /* TypeTag.Float */ &&
+                !(left.value.type & ~(32 /* TypeTag.Float */ | 8 /* TypeTag.Number */))) ||
+            right.value.type === 64 /* TypeTag.Double */) {
+            istate.stack.splice(-2, 1);
+            return node.right;
+        }
+    }
+    return null;
+}
+function tryIdentity(istate, node, left, right) {
+    switch (node.operator) {
+        case "+":
+        case "-": {
+            const rep = identity(istate, node, left, right, 120 /* TypeTag.Numeric */, 0);
+            if (rep)
+                return rep;
+            if (node.right.type === "UnaryExpression" &&
+                node.right.operator === "-") {
+                // We can convert a +/- -b to a -/+ b, but we have to know
+                // something about the types. eg if b is Number, with the
+                // value -2^31, negating b will leave the value as -2^31.
+                // This doesn't matter if the a is also Number, but if
+                // a might be Long, Float or Double, we would change the
+                // result. Similarly for Long and -2^63
+                if (!((left.value.type | right.value.type) & ~120 /* TypeTag.Numeric */) &&
+                    (right.value.type & 8 /* TypeTag.Number */ // Negating -2^31 goes wrong if left is a wider type
+                        ? !(left.value.type &
+                            (16 /* TypeTag.Long */ | 32 /* TypeTag.Float */ | 64 /* TypeTag.Double */))
+                        : right.value.type & 16 /* TypeTag.Long */ // Negating -2^63 goes wrong if left is a float/double
+                            ? !(left.value.type & (32 /* TypeTag.Float */ | 64 /* TypeTag.Double */))
+                            : true)) {
+                    right.value = evaluateBinaryTypes("-", { type: 8 /* TypeTag.Number */, value: 0 }, right.value);
+                    right.node = node.right.argument;
+                    node.right = right.node;
+                    node.operator = node.operator === "+" ? "-" : "+";
+                }
+            }
+            break;
+        }
+        case "*": {
+            const rep = zero(istate, node, left, right, 120 /* TypeTag.Numeric */, 0);
+            if (rep)
+                return rep;
+            // fall through
+        }
+        case "/": {
+            const rep = identity(istate, node, left, right, 120 /* TypeTag.Numeric */, 1);
+            if (rep)
+                return rep;
+            break;
+        }
+        case "|": {
+            const rep = zero(istate, node, left, right, 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */, -1);
+            if (rep)
+                return rep;
+            // fall through
+        }
+        case "^": {
+            const rep = identity(istate, node, left, right, 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */, 0);
+            if (rep)
+                return rep;
+            break;
+        }
+        case "&": {
+            const rep = zero(istate, node, left, right, 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */, 0) ||
+                identity(istate, node, left, right, 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */, -1);
+            if (rep)
+                return rep;
+            break;
+        }
+    }
+    return null;
 }
-function restrictByEqualityByComponent(a, b) {
-    let bits = a.type;
-    if (a.value == null && (b.type & bits) === b.type) {
-        // shortcut:
-        // if b.type is contained in a.type, and a has no
-        // specialization, the result is just b.
-        return b;
+function tryCommuteAndAssociate(istate, node) {
+    let [left, right] = istate.stack.slice(-2);
+    // no need to do anything if both sides are constants
+    if (!right || (hasValue(left.value) && hasValue(right.value))) {
+        return null;
     }
-    let br = null;
-    do {
-        const next = bits & (bits - 1);
-        const bit = bits - next;
-        const brt = restrictExactTypesByEquality({
-            type: bit,
-            value: getUnionComponent(a, bit) || undefined,
-        }, b);
-        if (brt.type !== 0 /* TypeTag.Never */) {
-            if (!br) {
-                br = cloneType(brt);
+    switch (node.operator) {
+        case "+":
+            // Addition is only commutative/associative if both arguments
+            // are numeric, or one argument is Number, and the other is Char
+            if (left.value.type & ~(120 /* TypeTag.Numeric */ | 128 /* TypeTag.Char */) ||
+                right.value.type & ~(120 /* TypeTag.Numeric */ | 128 /* TypeTag.Char */) ||
+                left.value.type & right.value.type & 128 /* TypeTag.Char */) {
+                break;
             }
-            else {
-                unionInto(br, brt);
+        // fallthrough
+        case "*":
+        case "&":
+        case "|":
+        case "^":
+            // flip the left argument to the right if the left has
+            // a known value, but the right does not, or if the
+            // top operator is additive, and the left operand is
+            // negated, and the right operand is not.
+            if (!left.embeddedEffects &&
+                (hasValue(left.value) ||
+                    (!right.embeddedEffects &&
+                        node.operator === "+" &&
+                        node.left.type === "UnaryExpression" &&
+                        node.left.operator === "-" &&
+                        (node.right.type !== "UnaryExpression" ||
+                            node.right.operator !== "-")))) {
+                const l = node.left;
+                node.left = node.right;
+                node.right = l;
+                istate.stack.splice(-2, 2, right, left);
+                const r = right;
+                right = left;
+                left = r;
+            }
+        // fallthrough
+        case "-":
+            if (tryReAssociate(istate, node, left, right)) {
+                [left, right] = istate.stack.slice(-2);
             }
-        }
-        bits = next;
-    } while (bits);
-    if (!br) {
-        return { type: 0 /* TypeTag.Never */ };
     }
-    return br;
+    return tryIdentity(istate, node, left, right);
 }
 /*
- * Given that a == b, reutnr what we can deduce about b's
- * type.
+ * Try to reorder (a op K1) op K2 => a op (K1 op K2),
+ * and fold K1 op K2.
  *
- * Note that this is similar to intersection. In many cases, it
- * is intersection. eg if a is the type (Null or "Hello" or Menu)
- * then we know b's type must be a subtype of intersection(a, b).
+ * Failing that,
+ * Try to reorder (a op K1) op (b op K2) as
+ * (a op b) op (K1 op K2), and fold K1 op K2.
  *
- * But eg if it was a == 5, and a is known to be Char, String,
- * Number or Float, we can only eliminate String, because
- * 5.0 == 5, and 5.toChar() == 5.
+ * Failing that,
+ * Try to reorder (a op K) op b => (a op b) op K
+ * so that constants float up and to the right.
+ * This helps because now ((a op K1) op b) op K2
+ * becomes ((a op b) op K1) op K2, and we can
+ * fold K1 op K2 by the first transformation.
+ *
+ * Floating point arithmetic isn't really associative
+ * though, so we mostly suppress this when Floats
+ * and Doubles may be involved; except that
+ * (a + K1) + K2 can be safely converted to
+ * a + (K1 + K2) if K1 and K2 have the same sign.
  */
-function restrictByEquality(a, b) {
-    if (a.type === 0 /* TypeTag.Never */)
-        return a;
-    if (isExact(a)) {
-        return restrictExactTypesByEquality(a, b);
+function tryReAssociate(istate, node, left, right) {
+    if (node.left.type !== "BinaryExpression" ||
+        (node.left.operator !== node.operator &&
+            !(node.operator === "+" && node.left.operator === "-") &&
+            !(node.operator === "-" && node.left.operator === "+"))) {
+        return false;
     }
-    return restrictByEqualityByComponent(a, b);
+    const lr = getLiteralNode(node.left.right);
+    if (!lr)
+        return false;
+    const leftRight = evaluate(istate, lr);
+    if (!hasValue(leftRight.value))
+        return false;
+    if (hasValue(right.value)) {
+        // (ll + lr) + r => ll + (r + lr)
+        // (ll - lr) - r => ll - (r + lr)
+        // (ll + lr) - r => ll + (r - lr)
+        // (ll - lr) + r => ll - (r - lr)
+        const tmpNode = {
+            type: "BinaryExpression",
+            operator: node.operator === "+" || node.operator === "-"
+                ? node.operator === node.left.operator
+                    ? "+"
+                    : "-"
+                : node.operator,
+            left: node.right,
+            right: node.left.right,
+        };
+        if (tmpNode.operator === "+" || tmpNode.operator === "-") {
+            if (leftRight.value.type & (32 /* TypeTag.Float */ | 64 /* TypeTag.Double */) ||
+                right.value.type & (32 /* TypeTag.Float */ | 64 /* TypeTag.Double */)) {
+                // we don't want to fold "a + 1.0 - 1.0" because
+                // it could be there for rounding purposes
+                const lsign = right.value.value < 0;
+                const rsign = leftRight.value.value < 0 === (tmpNode.operator === "+");
+                if (lsign !== rsign)
+                    return false;
+            }
+        }
+        const repType = evaluate(istate, tmpNode);
+        if (!hasValue(repType.value))
+            return false;
+        const repNode = mcExprFromType(repType.value);
+        if (!repNode)
+            return false;
+        left.node = node.left = node.left.left;
+        node.right = repNode;
+        istate.stack.splice(-1, 1, repType);
+        repType.node = repNode;
+        return true;
+    }
+    if (leftRight.value.type !== left.value.type ||
+        leftRight.value.type !== right.value.type ||
+        leftRight.value.type & (32 /* TypeTag.Float */ | 64 /* TypeTag.Double */)) {
+        return false;
+    }
+    if (node.right.type === "BinaryExpression" &&
+        (node.right.operator === node.operator ||
+            ((node.operator === "+" || node.operator === "-") &&
+                (node.right.operator === "+" || node.right.operator === "-")))) {
+        // (a + K1) + (b + K2) => (a + b) + (K1 + K2)
+        const rr = getLiteralNode(node.right.right);
+        if (!rr)
+            return false;
+        const rightRight = evaluate(istate, rr);
+        if (!hasValue(rightRight.value))
+            return false;
+        const rightOp = node.operator === "+" || node.operator === "-"
+            ? ((node.left.operator === "+") === (node.right.operator === "+")) ===
+                (node.operator === "+")
+                ? "+"
+                : "-"
+            : node.operator;
+        const topOp = node.left.operator;
+        const leftOp = node.operator;
+        const rightType = evaluateBinaryTypes(rightOp, leftRight.value, rightRight.value);
+        if (!hasValue(rightType))
+            return false;
+        const repNode = mcExprFromType(rightType);
+        if (!repNode)
+            return false;
+        node.left.right = node.right.left;
+        node.right = repNode;
+        node.left.operator = leftOp;
+        node.operator = topOp;
+        istate.stack.splice(-1, 1, {
+            value: rightType,
+            node: repNode,
+            embeddedEffects: false,
+        });
+        return true;
+    }
+    const op = node.operator;
+    node.operator = node.left.operator;
+    node.left.operator = op;
+    leftRight.node = node.left.right;
+    node.left.right = node.right;
+    node.right = leftRight.node;
+    istate.stack.splice(-1, 1, leftRight);
+    return true;
+}
+function tryDeEnumerate(istate, node, elem) {
+    if (node.type === "BinaryExpression" &&
+        node.operator === "as" &&
+        node.right.ts.length === 1 &&
+        typeof node.right.ts[0] === "string") {
+        elem += istate.stack.length;
+        const item = istate.stack[elem];
+        istate.stack[elem] = {
+            value: deEnumerate(item.value),
+            embeddedEffects: item.embeddedEffects,
+            node: node.left,
+        };
+        return node.left;
+    }
+    return null;
 }
 
 
@@ -6755,7 +9412,7 @@ function printBlockTrailer(block) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "iX": () => (/* binding */ getStateNodeDeclsFromType)
 /* harmony export */ });
-/* unused harmony exports typeTagName, LastTypeTag, SingleTonTypeTagsConst, UnionDataTypeTagsConst, ValueTypeTagsConst, ObjectLikeTagsConst, EnumTagsConst, isExact, isUnion, isSingleton, hasValue, hasNoData, lookupByFullName, cloneType, typeFromTypeStateNode, typeFromTypeStateNodes, typeFromSingleTypeSpec, typeFromTypespec, typeFromLiteral, mcExprFromType, castType, TruthyTypes, mustBeTrue, mustBeFalse, display, hasUnionData, getObjectValue, forEachUnionComponent, getUnionComponent, setUnionComponent */
+/* unused harmony exports typeTagName, LastTypeTag, SingletonTypeTagsConst, UnionDataTypeTagsConst, ValueTypeTagsConst, ObjectLikeTagsConst, EnumTagsConst, isExact, isUnion, isSingleton, hasValue, hasNoData, cloneType, typeFromTypeStateNode, typeFromTypeStateNodes, typeFromSingleTypeSpec, typeFromTypespec, typeFromLiteral, mcExprFromType, castType, TruthyTypes, mustBeTrue, mustBeFalse, display, hasUnionData, getObjectValue, forEachUnionComponent, getUnionComponent, setUnionComponent */
 /* harmony import */ var _markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9642);
 /* harmony import */ var _markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_markw65_prettier_plugin_monkeyc__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8180);
@@ -6830,7 +9487,7 @@ function typeTagName(tag) {
     }
 }
 const LastTypeTag = 262144 /* TypeTag.Typedef */;
-const SingleTonTypeTagsConst = 1 /* TypeTag.Null */ | 2 /* TypeTag.False */ | 4 /* TypeTag.True */;
+const SingletonTypeTagsConst = 1 /* TypeTag.Null */ | 2 /* TypeTag.False */ | 4 /* TypeTag.True */;
 const UnionDataTypeTagsConst = 512 /* TypeTag.Array */ |
     1024 /* TypeTag.Dictionary */ |
     2048 /* TypeTag.Method */ |
@@ -6853,7 +9510,7 @@ const ObjectLikeTagsConst = 6 /* TypeTag.Boolean */ |
     1024 /* TypeTag.Dictionary */ |
     2048 /* TypeTag.Method */ |
     65536 /* TypeTag.Enum */;
-const EnumTagsConst = SingleTonTypeTagsConst | (ValueTypeTagsConst & ~131072 /* TypeTag.Symbol */);
+const EnumTagsConst = SingletonTypeTagsConst | (ValueTypeTagsConst & ~131072 /* TypeTag.Symbol */);
 function isExact(v) {
     // check that there is exactly one bit set
     return v.type !== 0 && !(v.type & (v.type - 1));
@@ -6862,27 +9519,18 @@ function isUnion(v) {
     return v.type !== 0 && !isExact(v);
 }
 function isSingleton(v) {
-    return isExact(v) && (v.type & SingleTonTypeTagsConst) !== 0;
+    return isExact(v) && (v.type & SingletonTypeTagsConst) !== 0;
 }
 function hasValue(v) {
     return (isExact(v) &&
-        ((v.type & SingleTonTypeTagsConst) !== 0 || v.value !== undefined));
+        ((v.type & SingletonTypeTagsConst) !== 0 || v.value !== undefined));
 }
 function hasNoData(v, t) {
     if (v.value == null)
         return true;
     return ((hasUnionData(v.type)
         ? v.value.mask & t
-        : v.type & t & ~SingleTonTypeTagsConst) === 0);
-}
-function lookupByFullName(state, fullName) {
-    return fullName.split(".").reduce((results, part) => {
-        return results
-            .flatMap((result) => (0,_api__WEBPACK_IMPORTED_MODULE_2__.isStateNode)(result)
-            ? result.decls?.[part] || result.type_decls?.[part]
-            : null)
-            .filter((sn) => !!sn);
-    }, [state.stack[0]]);
+        : v.type & t & ~SingletonTypeTagsConst) === 0);
 }
 function cloneType(t) {
     return { ...t };
@@ -7451,7 +10099,7 @@ function getObjectValue(t) {
 }
 function forEachUnionComponent(v, bits, fn) {
     // never iterate the singleton bits, because they don't have data
-    bits &= ~SingleTonTypeTagsConst;
+    bits &= ~SingletonTypeTagsConst;
     if (!bits)
         return;
     if ((v.type | bits) & UnionDataTypeTagsConst) {
@@ -7481,7 +10129,7 @@ function forEachUnionComponent(v, bits, fn) {
 function getUnionComponent(v, tag) {
     if (v.value == null)
         return null;
-    let bits = v.type & ~SingleTonTypeTagsConst;
+    let bits = v.type & ~SingletonTypeTagsConst;
     if (!bits)
         return null;
     if (bits & (bits - 1)) {
@@ -7555,7 +10203,7 @@ function getStateNodeDeclsFromType(state, object) {
                 next &= ~6 /* TypeTag.Boolean */;
             }
             const name = `Toybox.Lang.${typeTagName(bit)}`;
-            const sns = lookupByFullName(state, name);
+            const sns = (0,_api__WEBPACK_IMPORTED_MODULE_2__.lookupByFullName)(state, name);
             sns.forEach((sn) => (0,_api__WEBPACK_IMPORTED_MODULE_2__.isStateNode)(sn) && decls.push(sn));
             bits = next;
         } while (bits);
@@ -7596,7 +10244,7 @@ function unionInto(to, from) {
         return true;
     }
     const newTags = to.type | from.type;
-    if (!(from.type & ~SingleTonTypeTagsConst)) {
+    if (!(from.type & ~SingletonTypeTagsConst)) {
         // - Adding singletons never affects the data.
         if (newTags === to.type)
             return false;
@@ -7858,7 +10506,7 @@ function clearValuesUnder(v, tag, clearTag = false) {
     const newTag = clearTag ? v.type & ~tag : v.type | tag;
     // If the incoming type consists of singletons,
     // we can always merge it without affecting our data.
-    tag &= ~SingleTonTypeTagsConst;
+    tag &= ~SingletonTypeTagsConst;
     if (!tag || v.value == null) {
         v.type = newTag;
         return;
@@ -7979,6 +10627,193 @@ function widenType(t) {
 }
 
 
+/***/ }),
+
+/***/ 424:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export cleanupUnusedVars */
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(333);
+
+
+
+function cleanupUnusedVars(state, node) {
+    const parent = state.stack.slice(-1).pop().sn;
+    if (parent.node !== node) {
+        return false;
+    }
+    if (parent.type !== "BlockStatement") {
+        throw new Error(`Unexpected parent type '${parent.type}' for local declaration`);
+    }
+    if (!parent.decls)
+        return false;
+    let toRemove = null;
+    Object.values(parent.decls).forEach((decls) => {
+        if (decls.length === 1 &&
+            decls[0].type === "VariableDeclarator" &&
+            !decls[0].used) {
+            if (!toRemove)
+                toRemove = {};
+            toRemove[decls[0].name] = decls[0];
+        }
+    });
+    if (!toRemove)
+        return false;
+    const varDeclarations = new Map();
+    const stack = [];
+    let changes = false;
+    traverseAst(node, (node) => {
+        switch (node.type) {
+            case "SwitchCase":
+                stack.push(node.consequent);
+                break;
+            case "BlockStatement":
+                stack.push(node.body);
+                break;
+        }
+    }, (node) => {
+        switch (node.type) {
+            case "SwitchCase":
+            case "BlockStatement":
+                stack.pop();
+                break;
+            case "VariableDeclaration": {
+                node.declarations.forEach((decl, i) => {
+                    const name = variableDeclarationName(decl.id);
+                    if (hasProperty(toRemove, name)) {
+                        const info = varDeclarations.get(node);
+                        if (info) {
+                            info.indices.push(i);
+                        }
+                        else {
+                            varDeclarations.set(node, {
+                                parent: stack[stack.length - 1],
+                                indices: [i],
+                            });
+                        }
+                    }
+                });
+                break;
+            }
+            case "ExpressionStatement":
+                if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.left.type === "Identifier" &&
+                        hasProperty(toRemove, node.expression.left.name)) {
+                        changes = true;
+                        return unused(state, node.expression.right);
+                    }
+                }
+                else if (node.expression.type === "UpdateExpression" &&
+                    node.expression.argument.type === "Identifier" &&
+                    hasProperty(toRemove, node.expression.argument.name)) {
+                    return false;
+                }
+                break;
+            case "SequenceExpression": {
+                for (let i = node.expressions.length; i--;) {
+                    const expr = node.expressions[i];
+                    if (expr.type === "AssignmentExpression") {
+                        if (expr.left.type === "Identifier" &&
+                            hasProperty(toRemove, expr.left.name)) {
+                            const rep = unused(state, expr.right);
+                            if (!rep.length) {
+                                changes = true;
+                                node.expressions.splice(i, 1);
+                            }
+                            else {
+                                // Sequence expressions can only be assignments
+                                // or update expressions. Even calls aren't allowed
+                                toRemove[expr.left.name] = null;
+                                expr.operator = "=";
+                            }
+                        }
+                    }
+                    else if (expr.type === "UpdateExpression" &&
+                        expr.argument.type === "Identifier" &&
+                        hasProperty(toRemove, expr.argument.name)) {
+                        changes = true;
+                        node.expressions.splice(i, 1);
+                    }
+                }
+                break;
+            }
+        }
+        return null;
+    });
+    varDeclarations.forEach((info, decl) => {
+        let index = -1;
+        for (let ii = info.indices.length, j = decl.declarations.length; ii--;) {
+            const i = info.indices[ii];
+            const vdecl = decl.declarations[i];
+            const name = variableDeclarationName(vdecl.id);
+            if (hasProperty(toRemove, name)) {
+                const rep = vdecl.init ? unused(state, vdecl.init) : [];
+                if (rep.length) {
+                    if ((state.sdkVersion || 0) < 4001007 &&
+                        rep.find((s) => s.type === "ExpressionStatement" &&
+                            (s.expression.type === "NewExpression" ||
+                                (s.expression.type === "MemberExpression" &&
+                                    !s.expression.computed &&
+                                    s.expression.object.type === "NewExpression")))) {
+                        // prior to 4.1.7 vanilla new expressions were discarded,
+                        // so don't create top level new expressions.
+                        continue;
+                    }
+                    if (parent.node.type === "ForStatement") {
+                        // declarations whose inits have side effects
+                        // can't be deleted from for statements.
+                        continue;
+                    }
+                    changes = true;
+                    if (index < 0) {
+                        index = info.parent.findIndex((s) => s === decl);
+                        if (index < 0) {
+                            throw new Error(`Failed to find variable declaration for ${variableDeclarationName(vdecl.id)}`);
+                        }
+                    }
+                    if (j > i + 1) {
+                        const tail = {
+                            ...decl,
+                            declarations: decl.declarations.slice(i + 1, j),
+                        };
+                        if (decl.loc && vdecl.loc) {
+                            tail.loc = { ...decl.loc, start: vdecl.loc.end };
+                            tail.start = vdecl.end;
+                        }
+                        rep.push(tail);
+                    }
+                    if (decl.loc && vdecl.loc) {
+                        decl.loc = { ...decl.loc, end: vdecl.loc.start };
+                        decl.end = vdecl.start;
+                    }
+                    decl.declarations.splice(i);
+                    info.parent.splice(index + 1, 0, ...rep);
+                    j = i;
+                    continue;
+                }
+                if (toRemove[name]) {
+                    changes = true;
+                    j--;
+                    decl.declarations.splice(i, 1);
+                    if (i === j && decl.loc && vdecl.loc) {
+                        decl.loc = { ...decl.loc, end: vdecl.loc.start };
+                        decl.end = vdecl.start;
+                    }
+                }
+                else {
+                    delete vdecl.init;
+                }
+            }
+        }
+    });
+    return changes;
+}
+
+
 /***/ }),
 
 /***/ 4405:
@@ -8028,7 +10863,7 @@ function renameVariable(state, locals, declName) {
             let ok = false;
             let i;
             for (i = state.stack.length; i--;) {
-                const elm = state.stack[i];
+                const elm = state.stack[i].sn;
                 if (ok) {
                     if (hasProperty(elm.decls, name)) {
                         break;
@@ -8163,10 +10998,13 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   "checkCompilerVersion": () => (/* binding */ checkCompilerVersion),
   "collectNamespaces": () => (/* binding */ collectNamespaces),
+  "createDocumentationMap": () => (/* binding */ createDocumentationMap),
   "diagnostic": () => (/* binding */ diagnostic),
   "diagnosticHelper": () => (/* binding */ diagnosticHelper),
+  "findNamesInScope": () => (/* binding */ findNamesInScope),
   "findUsingForNode": () => (/* binding */ findUsingForNode),
   "formatAst": () => (/* binding */ formatAst),
+  "formatAstLongLines": () => (/* binding */ formatAstLongLines),
   "getApiFunctionInfo": () => (/* binding */ getApiFunctionInfo),
   "getApiMapping": () => (/* binding */ getApiMapping),
   "getSuperClasses": () => (/* binding */ getSuperClasses),
@@ -8174,7 +11012,12 @@ __webpack_require__.d(__webpack_exports__, {
   "isLocal": () => (/* binding */ isLocal),
   "isLookupCandidate": () => (/* binding */ isLookupCandidate),
   "isStateNode": () => (/* binding */ isStateNode),
+  "lookupByFullName": () => (/* binding */ lookupByFullName),
   "lookupNext": () => (/* binding */ lookupNext),
+  "lookupResultContains": () => (/* binding */ lookupResultContains),
+  "lookupWithType": () => (/* binding */ lookupWithType),
+  "makeToyboxLink": () => (/* binding */ makeToyboxLink),
+  "mapVarDeclsByType": () => (/* binding */ mapVarDeclsByType),
   "markInvokeClassMethod": () => (/* binding */ markInvokeClassMethod),
   "parseSdkVersion": () => (/* binding */ parseSdkVersion),
   "sameLookupResult": () => (/* binding */ sameLookupResult),
@@ -8194,6 +11037,8 @@ var promises_ = __webpack_require__(560);
 const external_prettier_namespaceObject = require("prettier");
 // EXTERNAL MODULE: ./src/ast.ts
 var src_ast = __webpack_require__(6652);
+// EXTERNAL MODULE: ./src/mc-rewrite.ts
+var mc_rewrite = __webpack_require__(5530);
 // EXTERNAL MODULE: ./src/negative-fixups.ts
 var negative_fixups = __webpack_require__(4499);
 // EXTERNAL MODULE: ./src/optimizer-types.ts
@@ -8717,13 +11562,14 @@ function add_one_resource(state, doc, module, e) {
     }
 }
 
-// EXTERNAL MODULE: external "./util.cjs"
-var external_util_cjs_ = __webpack_require__(6906);
 // EXTERNAL MODULE: ./src/type-flow.ts
 var type_flow = __webpack_require__(4859);
+// EXTERNAL MODULE: ./src/type-flow/types.ts
+var types = __webpack_require__(7255);
+// EXTERNAL MODULE: external "./util.cjs"
+var external_util_cjs_ = __webpack_require__(6906);
 ;// CONCATENATED MODULE: ./src/visitor.ts
 
-
 function visitorNode(node) {
     if (node.type === "Identifier") {
         return node;
@@ -8742,28 +11588,11 @@ function visitorNode(node) {
     }
     return node;
 }
-function visitReferences(state, ast, name, defn, callback, includeDefs = false, filter = null, typeMap = null) {
-    const lookup = (node, nonLocal = false) => {
-        const results = nonLocal ? state.lookupNonlocal(node) : state.lookup(node);
-        if (results[1] || !typeMap)
-            return results;
-        if (node.type === "MemberExpression" && !node.computed) {
-            const objectType = typeMap.get(node.object);
-            if (!objectType)
-                return results;
-            const [, decls] = (0,type_flow/* findObjectDeclsByProperty */.nK)(state, objectType, node);
-            if (decls) {
-                const next = (0,external_api_cjs_.lookupNext)(state, [{ parent: null, results: decls }], "decls", node.property);
-                if (next) {
-                    return [node.property.name, next];
-                }
-            }
-        }
-        return results;
-    };
+function visitReferences(state, ast, name, defn, callback, includeDefs = false, filter = null, typeMap = null, findSingleDefinition = false) {
+    const lookup = (node, nonLocal = false) => (0,external_api_cjs_.lookupWithType)(state, node, typeMap, nonLocal);
     const checkResults = ([name, results], node) => {
         if (name && results) {
-            if (!defn || (0,external_api_cjs_.sameLookupResult)(results, defn)) {
+            if (!defn || (0,external_api_cjs_.lookupResultContains)(results, defn)) {
                 if (callback(node, results, false) === false) {
                     return [];
                 }
@@ -8776,6 +11605,35 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
         }
         return null;
     };
+    const visitDef = (node, def, decls = "decls") => {
+        const id = node.type === "BinaryExpression" ? node.left : node;
+        if (filter && !filter(id))
+            return;
+        let [scope, parent] = state.stack.slice(-2).reverse();
+        let results;
+        if (def) {
+            if (scope.sn.node !== def) {
+                parent = scope;
+            }
+            results = parent.sn[decls]?.[id.name];
+            if (!results)
+                return;
+            const thisDefn = results.find((decl) => decl.node === def);
+            if (!thisDefn) {
+                return;
+            }
+            if (findSingleDefinition) {
+                results = [thisDefn];
+            }
+        }
+        else {
+            if (!parent) {
+                return;
+            }
+            results = [scope.sn];
+        }
+        checkResults([id.name, [{ parent: parent.sn, results }]], id);
+    };
     state.pre = (node) => {
         if (filter && !filter(node))
             return [];
@@ -8812,7 +11670,8 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
                 // it will be ignored, and the lookup will start as if the
                 // call had been written self.foo() rather than foo().
                 if (node.callee.type === "Identifier") {
-                    if (!name || node.callee.name === name) {
+                    if ((!name || node.callee.name === name) &&
+                        (!filter || filter(node.callee))) {
                         /* ignore return value */
                         checkResults(lookup(node.callee, true), node.callee);
                     }
@@ -8848,29 +11707,47 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
                 return ["returnType"];
             }
             case "ModuleDeclaration":
-                if (includeDefs)
-                    break;
+                if (includeDefs) {
+                    visitDef(node.id);
+                }
                 return ["body"];
             case "ClassDeclaration":
-                if (includeDefs)
-                    break;
+                if (includeDefs) {
+                    visitDef(node.id, node);
+                }
                 return ["body", "superClass"];
             case "FunctionDeclaration":
-                if (includeDefs)
-                    break;
+                if (includeDefs) {
+                    visitDef(node.id, node);
+                }
                 return ["params", "returnType", "body"];
             case "TypedefDeclaration":
-                if (includeDefs)
-                    break;
+                if (includeDefs) {
+                    visitDef(node.id, node, "type_decls");
+                }
                 return ["ts"];
             case "VariableDeclarator":
-                if (includeDefs)
-                    break;
+                if (includeDefs) {
+                    visitDef(node.id, node);
+                }
+                if (node.id.type === "BinaryExpression") {
+                    state.traverse(node.id.right);
+                }
                 return ["init"];
             case "EnumDeclaration":
-                if (includeDefs)
+                if (includeDefs) {
+                    if (node.id) {
+                        visitDef(node.id, node, "type_decls");
+                    }
                     break;
+                }
                 return [];
+            case "EnumStringMember": {
+                if (!filter || filter(node.id)) {
+                    checkResults([node.id.name, [{ parent: state.top().sn, results: [node] }]], node);
+                }
+                break;
+            }
             case "CatchClause":
                 if (includeDefs)
                     break;
@@ -8897,6 +11774,9 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
 
 
 
+
+
+
 /*
  * This is an unfortunate hack. I want to be able to extract things
  * like the types of all of a Class's variables (in particular the type
@@ -9101,6 +11981,19 @@ function sameLookupDefinition(a, b) {
 function sameLookupResult(a, b) {
     return (0,external_util_cjs_.sameArrays)(a, b, sameLookupDefinition);
 }
+function declKey(decl) {
+    return isStateNode(decl)
+        ? decl.type === "ModuleDeclaration"
+            ? decl.fullName
+            : decl.node
+        : decl;
+}
+function lookupResultContains(a, b) {
+    if (!b.length)
+        return false;
+    const bs = new Set(b.flatMap((bdef) => bdef.results.map(declKey)));
+    return a.some((adef) => adef.results.some((adecl) => bs.has(declKey(adecl))));
+}
 function isLookupCandidate(node) {
     return node.computed
         ? node.property.type === "UnaryExpression" &&
@@ -9177,26 +12070,26 @@ function lookup(state, decls, node, name, maybeStack, nonlocal, ignoreImports) {
         }
         case "ThisExpression": {
             for (let i = stack.length;;) {
-                const si = stack[--i];
+                const si = stack[--i].sn;
                 if (si.type === "ModuleDeclaration" ||
                     si.type === "ClassDeclaration" ||
                     !i) {
                     return [
                         name || si.name,
-                        [{ parent: i ? stack[i - 1] : null, results: [si] }],
+                        [{ parent: i ? stack[i - 1].sn : null, results: [si] }],
                     ];
                 }
             }
         }
         case "Identifier": {
             if (node.name === "$") {
-                return [name || node.name, [{ parent: null, results: [stack[0]] }]];
+                return [name || node.name, [{ parent: null, results: [stack[0].sn] }]];
             }
             let inStatic = false;
             let checkedImports = ignoreImports;
             let imports = null;
             for (let i = stack.length; i--;) {
-                const si = stack[i];
+                const si = stack[i].sn;
                 switch (si.type) {
                     case "ClassDeclaration":
                         if (inStatic && state.config?.enforceStatic !== "NO") {
@@ -9293,6 +12186,26 @@ function lookup(state, decls, node, name, maybeStack, nonlocal, ignoreImports) {
     }
     return [false, false];
 }
+function lookupWithType(state, node, typeMap, nonLocal = false, stack = null) {
+    const results = nonLocal
+        ? state.lookupNonlocal(node, null, stack)
+        : state.lookup(node, null, stack);
+    if (results[1] || !typeMap)
+        return results;
+    if (node.type === "MemberExpression" && !node.computed) {
+        const objectType = typeMap.get(node.object);
+        if (!objectType)
+            return results;
+        const [, decls] = (0,type_flow/* findObjectDeclsByProperty */.nK)(state, objectType, node);
+        if (decls) {
+            const next = lookupNext(state, [{ parent: null, results: decls }], "decls", node.property);
+            if (next) {
+                return [node.property.name, next];
+            }
+        }
+    }
+    return results;
+}
 function stateFuncs() {
     let currentEnum = null;
     return {
@@ -9330,9 +12243,10 @@ function stateFuncs() {
             return lookup(this, "type_decls", node, name, stack);
         },
         stackClone() {
-            return this.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
-                ? { ...elm }
-                : elm);
+            return this.stack.slice();
+        },
+        top() {
+            return this.stack[this.stack.length - 1];
         },
         traverse(root) {
             return (0,src_ast/* traverseAst */.lA)(root, (node) => {
@@ -9359,7 +12273,7 @@ function stateFuncs() {
                             if (this.stack.length !== 1) {
                                 throw new Error("Unexpected stack length for Program node");
                             }
-                            this.stack[0].node = node;
+                            this.stack[0].sn.node = node;
                             break;
                         case "TypeSpecList":
                         case "TypeSpecPart":
@@ -9367,10 +12281,9 @@ function stateFuncs() {
                             break;
                         case "ImportModule":
                         case "Using": {
-                            const [parent] = this.stack.slice(-1);
-                            if (!parent.usings) {
-                                parent.usings = {};
-                            }
+                            const parent = { ...this.stack.pop() };
+                            this.stack.push(parent);
+                            parent.usings = parent.usings ? { ...parent.usings } : {};
                             const name = (node.type === "Using" && node.as && node.as.name) ||
                                 (node.id.type === "Identifier"
                                     ? node.id.name
@@ -9382,6 +12295,7 @@ function stateFuncs() {
                                     parent.imports = [using];
                                 }
                                 else {
+                                    parent.imports = parent.imports.slice();
                                     const index = parent.imports.findIndex((using) => (using.node.id.type === "Identifier"
                                         ? using.node.id.name
                                         : using.node.id.property.name) === name);
@@ -9394,35 +12308,39 @@ function stateFuncs() {
                         }
                         case "CatchClause":
                             if (node.param) {
-                                const [parent] = this.stack.slice(-1);
+                                const parent = this.top().sn;
                                 if (!parent.decls)
                                     parent.decls = {};
                                 const id = node.param.type === "Identifier"
                                     ? node.param
                                     : node.param.left;
                                 this.stack.push({
-                                    type: "BlockStatement",
-                                    fullName: parent.fullName,
-                                    name: undefined,
-                                    node: node.body,
-                                    decls: { [id.name]: [id] },
-                                    attributes: 0,
+                                    sn: {
+                                        type: "BlockStatement",
+                                        fullName: parent.fullName,
+                                        name: undefined,
+                                        node: node.body,
+                                        decls: { [id.name]: [id] },
+                                        attributes: 0,
+                                    },
                                 });
                             }
                             break;
                         case "ForStatement":
                             if (node.init && node.init.type === "VariableDeclaration") {
                                 this.stack.push({
-                                    type: "BlockStatement",
-                                    fullName: this.stack.slice(-1).pop().fullName,
-                                    name: undefined,
-                                    node: node,
-                                    attributes: 0,
+                                    sn: {
+                                        type: "BlockStatement",
+                                        fullName: this.top().sn.fullName,
+                                        name: undefined,
+                                        node: node,
+                                        attributes: 0,
+                                    },
                                 });
                             }
                             break;
                         case "BlockStatement": {
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             if (parent.node === node ||
                                 (parent.type !== "FunctionDeclaration" &&
                                     parent.type !== "BlockStatement")) {
@@ -9433,10 +12351,10 @@ function stateFuncs() {
                         case "ClassDeclaration":
                         case "FunctionDeclaration":
                         case "ModuleDeclaration": {
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             const name = "id" in node ? node.id && node.id.name : undefined;
                             const fullName = this.stack
-                                .map((e) => e.name)
+                                .map((e) => e.sn.name)
                                 .concat(name)
                                 .filter((e) => e != null)
                                 .join(".");
@@ -9449,7 +12367,7 @@ function stateFuncs() {
                                     ? 0
                                     : stateNodeAttrs(node.attrs),
                             };
-                            this.stack.push(elm);
+                            this.stack.push({ sn: elm });
                             if (name) {
                                 if (!parent.decls)
                                     parent.decls = {};
@@ -9458,7 +12376,7 @@ function stateFuncs() {
                                     const e = parent.decls[name].find((d) => isStateNode(d) && d[what] === elm[what]);
                                     if (e != null) {
                                         e.node = node;
-                                        this.stack.splice(-1, 1, e);
+                                        this.top().sn = e;
                                         break;
                                     }
                                 }
@@ -9492,7 +12410,7 @@ function stateFuncs() {
                                 this.inType++;
                                 break;
                             }
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
                             node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
                         }
@@ -9500,7 +12418,7 @@ function stateFuncs() {
                         case "TypedefDeclaration": {
                             this.inType++;
                             const name = node.id.name;
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             if (!parent.type_decls)
                                 parent.type_decls = {};
                             if (!(0,src_ast/* hasProperty */.l$)(parent.type_decls, name)) {
@@ -9524,7 +12442,7 @@ function stateFuncs() {
                             break;
                         }
                         case "VariableDeclaration": {
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             if (!parent.decls)
                                 parent.decls = {};
                             const decls = parent.decls;
@@ -9560,7 +12478,7 @@ function stateFuncs() {
                                 throw new Error(`Expected inType to be 1 at EnumStringBody. Got ${this.inType}.`);
                             }
                             this.inType--;
-                            const [parent] = this.stack.slice(-1);
+                            const parent = this.top().sn;
                             const values = parent.decls || (parent.decls = {});
                             let prev = -1;
                             node.members.forEach((m, i) => {
@@ -9652,17 +12570,19 @@ function stateFuncs() {
                                 this.inType++;
                                 break;
                         }
-                        const [parent] = this.stack.slice(-1);
-                        if (parent.node === node ||
+                        const parent = this.top();
+                        if (parent.sn.node === node ||
                             // The pre function might cause node.body to be skipped,
                             // so we need to check here, just in case.
                             // (this actually happens with prettier-extenison-monkeyc's
                             // findItemsByRange)
-                            (node.type === "CatchClause" && parent.node === node.body)) {
-                            delete parent.usings;
-                            delete parent.imports;
-                            if (node.type !== "Program") {
-                                this.stack.pop();
+                            (node.type === "CatchClause" && parent.sn.node === node.body)) {
+                            let top = this.stack.pop();
+                            if (node.type === "Program") {
+                                top = { ...top };
+                                delete top.usings;
+                                delete top.imports;
+                                this.stack.push(top);
                             }
                         }
                     }
@@ -9688,11 +12608,13 @@ function collectNamespaces(ast, stateIn) {
     if (!state.stack) {
         state.stack = [
             {
-                type: "Program",
-                name: "$",
-                fullName: "$",
-                node: undefined,
-                attributes: 0,
+                sn: {
+                    type: "Program",
+                    name: "$",
+                    fullName: "$",
+                    node: undefined,
+                    attributes: 0,
+                },
             },
         ];
     }
@@ -9717,10 +12639,10 @@ function collectNamespaces(ast, stateIn) {
     if (state.stack.length !== 1) {
         throw new Error("Invalid AST!");
     }
-    if (state.stack[0].type !== "Program") {
+    if (state.stack[0].sn.type !== "Program") {
         throw new Error("Bottom of stack was not a Program!");
     }
-    return state.stack[0];
+    return state.stack[0].sn;
 }
 function formatAst(node, monkeyCSource = null, options = null) {
     /*
@@ -9759,10 +12681,152 @@ function formatAst(node, monkeyCSource = null, options = null) {
         endOfLine: "lf",
     });
 }
+function findNamesInExactScope(decl, regexp) {
+    if (!decl.decls)
+        return [];
+    return Object.entries(decl.decls).flatMap(([key, value]) => regexp.test(key) ? value : []);
+}
+function findNamesInScope(declStack, pattern) {
+    const regex = typeof pattern === "string"
+        ? new RegExp(pattern.replace(/\W/g, "").split("").join(".*"), "i")
+        : pattern;
+    const results = new Map();
+    const helper = (decls, depth) => {
+        decls.forEach((parent) => {
+            if (parent.type === "ClassDeclaration") {
+                if (parent.superClass && parent.superClass !== true) {
+                    helper(parent.superClass, depth + 1);
+                }
+            }
+            findNamesInExactScope(parent, regex).forEach((sn) => {
+                results.set(sn, { parent, depth });
+            });
+        });
+    };
+    let depth = 0;
+    while (depth < declStack.length) {
+        helper(declStack[declStack.length - 1 - depth], depth);
+        depth++;
+    }
+    return Array.from(results);
+}
+function mapVarDeclsByType(state, decls, node, typeMap) {
+    return decls.flatMap((decl) => {
+        if (decl.type === "VariableDeclarator" ||
+            decl.type === "Identifier" ||
+            decl.type === "BinaryExpression") {
+            const type = typeMap?.get(node);
+            return type ? (0,types/* getStateNodeDeclsFromType */.iX)(state, type) : [];
+        }
+        return decl;
+    });
+}
+function formatAstLongLines(node) {
+    return formatAst(node, null, { printWidth: 10000 });
+}
+async function createDocumentationMap(functionDocumentation) {
+    const docMap = new Map();
+    const state = await (0,mc_rewrite/* analyze */.BJ)({}, {}, undefined, {});
+    functionDocumentation.forEach((info) => {
+        state.allFunctions[info.name]?.forEach((decl) => decl.node?.loc?.source === "api.mir" &&
+            decl.fullName.endsWith(`.${info.parent}.${info.name}`) &&
+            docMap.set(decl.fullName, info.doc
+                .replace(/(\*.*?)\s*<br\/>\s*(?!\s*\*)/g, "$1\n\n")
+                .replace(/@example(.*?)(@|$)/g, (match, m1, m2) => `\n#### Example\n\`\`\`${m1.replace(/<br\/>/g, "\n")}\`\`\`${m2}`)
+                .replace(/@note/g, "\n#### Note\n")
+                .replace(/@see/, "\n#### See Also:\n$&")
+                .replace(/@see\s+(.*?)(?=<br\/>)/g, "\n  * {$1}")
+                .replace(/@throws/, "\n#### Throws:\n$&")
+                .replace(/@throws\s+(.*?)(?=<br\/>)/g, "\n  * $1")
+                .replace(/@since\s+(.*?)(?=<br\/>)/, "\n#### Since:\nAPI Level $1\n")
+                .replace(/<div class="description">/, "### Description\n")
+                .replace(/<div class="param">/, "\n#### Parameters\n$&")
+                .replace(/<div class="param">/g, "  \n*")
+                .replace(/\s*<div[^>]*>/g, "  \n\n")
+                .replace(/\s*<br\/>\s*([@*])/g, "\n$1")
+                //.replace(/\s\s\s(\s)*(?!\/\/)/g, "  \n")
+                .replace(/<[^>]*>/g, "")
+                .replace(/@/g, "  \n\n@")
+                //.replace(/\s\*/g, "  \n*")
+                .replace(/\+(\w+)\+/g, "`$1`")
+                .trim()
+                .replace(/\[((\s*(\w+::)+\w+\s*,)*(\s*(\w+::)+\w+\s*))\]/g, (arg, a1) => {
+                return a1
+                    .split(",")
+                    .map((s) => {
+                    const name = s.trim().replace(/::/g, ".");
+                    const decl = lookupByFullName(state, name);
+                    if (decl && decl.length === 1) {
+                        const sn = decl[0];
+                        const link = makeToyboxLink(sn);
+                        return `[${sn.name || name}](${link})`;
+                    }
+                    return s;
+                })
+                    .join(" or ");
+            })
+                .replace(/\{(\s*(?:\w+::)+\w+(?:#\w+)?|https:\/\/\S+)\s*(\S.*?)?\s*\}/g, (arg, a1, a2) => {
+                if (a1.startsWith("https://")) {
+                    return `[${a2 || a1}](${a1})`;
+                }
+                let name = a1.trim().replace(/::|#/g, ".");
+                if (!name.startsWith("Toybox")) {
+                    name = `Toybox.${name}`;
+                }
+                const decl = lookupByFullName(state, name);
+                if (decl && decl.length === 1) {
+                    const link = makeToyboxLink(decl[0]);
+                    return `[${a2 || a1}](${link})`;
+                }
+                return arg;
+            })));
+    });
+    return docMap;
+}
+function makeToyboxLink(result) {
+    const make_link = (fullName, fragment) => {
+        const path = fullName.split(".");
+        return (`https://developer.garmin.com/connect-iq/api-docs/${path
+            .slice(1, fragment ? -1 : undefined)
+            .join("/")}.html` +
+            (fragment ? `#${path.slice(-1)[0]}-${fragment}` : ""));
+    };
+    switch (result.type) {
+        case "ClassDeclaration":
+        case "ModuleDeclaration":
+            if (result.fullName.startsWith("$.Toybox")) {
+                return make_link(result.fullName);
+            }
+            break;
+        case "FunctionDeclaration":
+            return make_link(result.fullName, "instance_function");
+        case "EnumStringMember":
+            if (result.init.enumType && typeof result.init.enumType === "string") {
+                return make_link("$." + result.init.enumType, "module");
+            }
+            break;
+        case "EnumDeclaration":
+            return make_link(result.fullName, "module");
+        case "TypedefDeclaration":
+            return make_link(result.fullName, "named_type");
+        case "VariableDeclarator":
+            return make_link(result.fullName, "var");
+    }
+    return null;
+}
+function lookupByFullName(state, fullName) {
+    return fullName.split(".").reduce((results, part) => {
+        return results
+            .flatMap((result) => isStateNode(result)
+            ? result.decls?.[part] || result.type_decls?.[part]
+            : null)
+            .filter((sn) => !!sn);
+    }, [state.stack[0].sn]);
+}
 function handleException(state, node, exception) {
     try {
         const fullName = state.stack
-            .map((e) => e.name)
+            .map((e) => e.sn.name)
             .concat("name" in node && typeof node.name === "string" ? node.name : undefined)
             .filter((e) => e != null)
             .join(".");
@@ -9787,7 +12851,7 @@ function handleException(state, node, exception) {
 function findUsing(state, stack, using) {
     if (using.module)
         return using.module;
-    let module = stack[0];
+    let module = stack[0].sn;
     const find = (node) => {
         let name;
         if (node.type === "Identifier") {
@@ -9835,7 +12899,7 @@ function findUsingForNode(state, stack, i, node) {
                             imports = [];
                         imports.push({
                             name: `${module.fullName}.${node.name}`,
-                            decls: { parent: si, results: module.type_decls[node.name] },
+                            decls: { parent: si.sn, results: module.type_decls[node.name] },
                         });
                     }
                 }
@@ -9857,7 +12921,7 @@ function getApiFunctionInfo(state, func) {
             };
         }
         if (func.name === "initialize") {
-            const top = func.stack[func.stack.length - 1];
+            const top = func.stack[func.stack.length - 1].sn;
             if (top.type === "ClassDeclaration") {
                 top.hasInvoke = true;
             }
@@ -9870,7 +12934,7 @@ function markInvokeClassMethod(state, func) {
     func.info = state.invokeInfo;
 }
 function isLocal(v) {
-    return v.stack[v.stack.length - 1]?.type === "BlockStatement";
+    return v.stack[v.stack.length - 1]?.sn.type === "BlockStatement";
 }
 function diagnostic(state, node, message, type = "INFO", extra) {
     if (!state.diagnostics)