@markw65/monkeyc-optimizer 1.0.28 → 1.0.31

package/build/api.cjs

@@ -1,8 +1,211 @@
-0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiMapping,hasProperty,isStateNode,sameLookupResult,traverseAst,variableDeclarationName,visitReferences});
+0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,sameLookupResult,traverseAst,variableDeclarationName,visitReferences});
 /******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 2789:
+/***/ ((module) => {
+
+/**
+ * Expose `PriorityQueue`.
+ */
+module.exports = PriorityQueue;
+
+/**
+ * Initializes a new empty `PriorityQueue` with the given `comparator(a, b)`
+ * function, uses `.DEFAULT_COMPARATOR()` when no function is provided.
+ *
+ * The comparator function must return a positive number when `a > b`, 0 when
+ * `a == b` and a negative number when `a < b`.
+ *
+ * @param {Function}
+ * @return {PriorityQueue}
+ * @api public
+ */
+function PriorityQueue(comparator) {
+  this._comparator = comparator || PriorityQueue.DEFAULT_COMPARATOR;
+  this._elements = [];
+}
+
+/**
+ * Compares `a` and `b`, when `a > b` it returns a positive number, when
+ * it returns 0 and when `a < b` it returns a negative number.
+ *
+ * @param {String|Number} a
+ * @param {String|Number} b
+ * @return {Number}
+ * @api public
+ */
+PriorityQueue.DEFAULT_COMPARATOR = function(a, b) {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a - b;
+  } else {
+    a = a.toString();
+    b = b.toString();
+
+    if (a == b) return 0;
+
+    return (a > b) ? 1 : -1;
+  }
+};
+
+/**
+ * Returns whether the priority queue is empty or not.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+PriorityQueue.prototype.isEmpty = function() {
+  return this.size() === 0;
+};
+
+/**
+ * Peeks at the top element of the priority queue.
+ *
+ * @return {Object}
+ * @throws {Error} when the queue is empty.
+ * @api public
+ */
+PriorityQueue.prototype.peek = function() {
+  if (this.isEmpty()) throw new Error('PriorityQueue is empty');
+
+  return this._elements[0];
+};
+
+/**
+ * Dequeues the top element of the priority queue.
+ *
+ * @return {Object}
+ * @throws {Error} when the queue is empty.
+ * @api public
+ */
+PriorityQueue.prototype.deq = function() {
+  var first = this.peek();
+  var last = this._elements.pop();
+  var size = this.size();
+
+  if (size === 0) return first;
+
+  this._elements[0] = last;
+  var current = 0;
+
+  while (current < size) {
+    var largest = current;
+    var left = (2 * current) + 1;
+    var right = (2 * current) + 2;
+
+    if (left < size && this._compare(left, largest) >= 0) {
+      largest = left;
+    }
+
+    if (right < size && this._compare(right, largest) >= 0) {
+      largest = right;
+    }
+
+    if (largest === current) break;
+
+    this._swap(largest, current);
+    current = largest;
+  }
+
+  return first;
+};
+
+/**
+ * Enqueues the `element` at the priority queue and returns its new size.
+ *
+ * @param {Object} element
+ * @return {Number}
+ * @api public
+ */
+PriorityQueue.prototype.enq = function(element) {
+  var size = this._elements.push(element);
+  var current = size - 1;
+
+  while (current > 0) {
+    var parent = Math.floor((current - 1) / 2);
+
+    if (this._compare(current, parent) <= 0) break;
+
+    this._swap(parent, current);
+    current = parent;
+  }
+
+  return size;
+};
+
+/**
+ * Returns the size of the priority queue.
+ *
+ * @return {Number}
+ * @api public
+ */
+PriorityQueue.prototype.size = function() {
+  return this._elements.length;
+};
+
+/**
+ *  Iterates over queue elements
+ *
+ *  @param {Function} fn
+ */
+PriorityQueue.prototype.forEach = function(fn) {
+  return this._elements.forEach(fn);
+};
+
+/**
+ * Compares the values at position `a` and `b` in the priority queue using its
+ * comparator function.
+ *
+ * @param {Number} a
+ * @param {Number} b
+ * @return {Number}
+ * @api private
+ */
+PriorityQueue.prototype._compare = function(a, b) {
+  return this._comparator(this._elements[a], this._elements[b]);
+};
+
+/**
+ * Swaps the values at position `a` and `b` in the priority queue.
+ *
+ * @param {Number} a
+ * @param {Number} b
+ * @api private
+ */
+PriorityQueue.prototype._swap = function(a, b) {
+  var aux = this._elements[a];
+  this._elements[a] = this._elements[b];
+  this._elements[b] = aux;
+};
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
 /******/ 	
 /************************************************************************/
 /******/ 	/* webpack/runtime/compat get default export */
@@ -47,6 +250,9 @@
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(() => {
+"use strict";
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
 
@@ -55,9 +261,12 @@ __webpack_require__.d(__webpack_exports__, {
   "collectNamespaces": () => (/* binding */ api_collectNamespaces),
   "findUsingForNode": () => (/* binding */ findUsingForNode),
   "formatAst": () => (/* binding */ api_formatAst),
+  "getApiFunctionInfo": () => (/* binding */ api_getApiFunctionInfo),
   "getApiMapping": () => (/* binding */ api_getApiMapping),
-  "hasProperty": () => (/* binding */ api_hasProperty),
+  "hasProperty": () => (/* reexport */ ast_hasProperty),
+  "isLookupCandidate": () => (/* binding */ api_isLookupCandidate),
   "isStateNode": () => (/* binding */ api_isStateNode),
+  "markInvokeClassMethod": () => (/* binding */ api_markInvokeClassMethod),
   "sameLookupResult": () => (/* binding */ api_sameLookupResult),
   "traverseAst": () => (/* reexport */ ast_traverseAst),
   "variableDeclarationName": () => (/* binding */ api_variableDeclarationName),
@@ -86,62 +295,68 @@ function _check(x) {
     x = y;
 }
 const mctreeTypeInfo = {
-    ArrayExpression: ["elements"],
-    AssignmentExpression: ["left", "right"],
-    AttributeList: ["attributes"],
-    Attributes: ["elements"],
-    BinaryExpression: ["left", "right"],
-    Block: [],
-    BlockStatement: ["body", "innerComments"],
-    BreakStatement: [],
-    CallExpression: ["callee", "arguments"],
-    CatchClause: ["param", "body"],
-    CatchClauses: ["catches"],
-    ClassBody: ["body"],
-    ClassDeclaration: ["attrs", "id", "superClass", "body"],
-    ClassElement: ["item"],
-    ConditionalExpression: ["test", "consequent", "alternate"],
-    ContinueStatement: [],
-    DoWhileStatement: ["body", "test"],
-    EnumDeclaration: ["attrs", "id", "body"],
-    EnumStringBody: ["members"],
-    EnumStringMember: ["id", "init"],
-    ExpressionStatement: ["expression"],
-    ForStatement: ["init", "test", "body", "update"],
-    FunctionDeclaration: ["attrs", "id", "params", "returnType", "body"],
-    Identifier: [],
-    IfStatement: ["test", "consequent", "alternate"],
-    ImportModule: ["id"],
-    InstanceOfCase: ["id"],
-    Line: [],
-    Literal: [],
-    LogicalExpression: ["left", "right"],
-    MemberExpression: ["object", "property"],
-    MethodDefinition: ["params", "returnType"],
-    ModuleDeclaration: ["attrs", "id", "body"],
-    MultiLine: [],
-    NewExpression: ["callee", "arguments"],
-    ObjectExpression: ["properties"],
-    ParenthesizedExpression: ["expression"],
-    Program: ["body", "comments"],
-    Property: ["key", "value"],
-    ReturnStatement: ["argument"],
-    SequenceExpression: ["expressions"],
-    SizedArrayExpression: ["size", "ts"],
-    SwitchCase: ["test", "consequent"],
-    SwitchStatement: ["discriminant", "cases"],
-    ThisExpression: [],
-    ThrowStatement: ["argument"],
-    TryStatement: ["block", "handler", "finalizer"],
-    TypedefDeclaration: ["attrs", "id", "ts"],
-    TypeSpecList: ["ts"],
-    TypeSpecPart: ["name", "body", "callspec", "generics"],
-    UnaryExpression: ["argument"],
-    UpdateExpression: ["argument"],
-    Using: ["id", "as"],
-    VariableDeclaration: ["attrs", "declarations"],
-    VariableDeclarator: ["id", "init"],
-    WhileStatement: ["test", "body"],
+    ArrayExpression: { keys: ["elements"], expr: true },
+    AssignmentExpression: { keys: ["left", "right"], expr: true },
+    AttributeList: { keys: ["attributes"] },
+    Attributes: { keys: ["elements"] },
+    BinaryExpression: { keys: ["left", "right"], expr: true },
+    Block: { keys: [] },
+    BlockStatement: { keys: ["body", "innerComments"], stmt: true },
+    BreakStatement: { keys: [], stmt: true },
+    CallExpression: { keys: ["callee", "arguments"], expr: true },
+    CatchClause: { keys: ["param", "body"] },
+    CatchClauses: { keys: ["catches"] },
+    ClassBody: { keys: ["body"] },
+    ClassDeclaration: { keys: ["attrs", "id", "superClass", "body"], stmt: true },
+    ClassElement: { keys: ["item"] },
+    ConditionalExpression: {
+        keys: ["test", "consequent", "alternate"],
+        expr: true,
+    },
+    ContinueStatement: { keys: [], stmt: true },
+    DoWhileStatement: { keys: ["body", "test"], stmt: true },
+    EnumDeclaration: { keys: ["attrs", "id", "body"], stmt: true },
+    EnumStringBody: { keys: ["members"] },
+    EnumStringMember: { keys: ["id", "init"] },
+    ExpressionStatement: { keys: ["expression"], stmt: true },
+    ForStatement: { keys: ["init", "test", "body", "update"], stmt: true },
+    FunctionDeclaration: {
+        keys: ["attrs", "id", "params", "returnType", "body"],
+        stmt: true,
+    },
+    Identifier: { keys: [], expr: true },
+    IfStatement: { keys: ["test", "consequent", "alternate"], stmt: true },
+    ImportModule: { keys: ["id"] },
+    InstanceOfCase: { keys: ["id"] },
+    Line: { keys: [] },
+    Literal: { keys: [], expr: true },
+    LogicalExpression: { keys: ["left", "right"], expr: true },
+    MemberExpression: { keys: ["object", "property"], expr: true },
+    MethodDefinition: { keys: ["params", "returnType"] },
+    ModuleDeclaration: { keys: ["attrs", "id", "body"], stmt: true },
+    MultiLine: { keys: [] },
+    NewExpression: { keys: ["callee", "arguments"], expr: true },
+    ObjectExpression: { keys: ["properties"], expr: true },
+    ParenthesizedExpression: { keys: ["expression"], expr: true },
+    Program: { keys: ["body", "comments"] },
+    Property: { keys: ["key", "value"] },
+    ReturnStatement: { keys: ["argument"], stmt: true },
+    SequenceExpression: { keys: ["expressions"], expr: true },
+    SizedArrayExpression: { keys: ["size", "ts"], expr: true },
+    SwitchCase: { keys: ["test", "consequent"] },
+    SwitchStatement: { keys: ["discriminant", "cases"], stmt: true },
+    ThisExpression: { keys: [], expr: true },
+    ThrowStatement: { keys: ["argument"], stmt: true },
+    TryStatement: { keys: ["block", "handler", "finalizer"], stmt: true },
+    TypedefDeclaration: { keys: ["attrs", "id", "ts"], stmt: true },
+    TypeSpecList: { keys: ["ts"] },
+    TypeSpecPart: { keys: ["name", "body", "callspec", "generics"] },
+    UnaryExpression: { keys: ["argument"], expr: true },
+    UpdateExpression: { keys: ["argument"], expr: true },
+    Using: { keys: ["id", "as"] },
+    VariableDeclaration: { keys: ["attrs", "declarations"], stmt: true },
+    VariableDeclarator: { keys: ["id", "init"] },
+    WhileStatement: { keys: ["test", "body"], stmt: true },
 };
 function isMCTreeNode(node) {
     return node ? typeof node === "object" && "type" in node : false;
@@ -166,7 +381,7 @@ function ast_traverseAst(node, pre, post) {
     if (!mctreeTypeInfo[node.type]) {
         throw new Error("what?");
     }
-    for (const key of nodes || mctreeTypeInfo[node.type]) {
+    for (const key of nodes || mctreeTypeInfo[node.type].keys) {
         const value = node[key];
         if (!value)
             continue;
@@ -193,13 +408,21 @@ function ast_traverseAst(node, pre, post) {
             }
         }
         else if (isMCTreeNode(value)) {
-            const repl = ast_traverseAst(value, pre, post);
+            let repl = ast_traverseAst(value, pre, post);
             if (repl === false) {
                 delete node[key];
             }
             else if (repl != null) {
                 if (Array.isArray(repl)) {
-                    throw new Error("Array returned by traverseAst in Node context");
+                    if (ast_isStatement(value) && repl.every((s) => ast_isStatement(s))) {
+                        repl = ast_withLoc({
+                            type: "BlockStatement",
+                            body: repl,
+                        }, repl[0], repl[repl.length - 1]);
+                    }
+                    else {
+                        throw new Error("Array returned by traverseAst in Node context");
+                    }
                 }
                 node[key] = repl;
             }
@@ -207,9 +430,187 @@ function ast_traverseAst(node, pre, post) {
     }
     return post && post(node);
 }
+function ast_isStatement(node) {
+    return ast_hasProperty(mctreeTypeInfo[node.type], "stmt");
+}
+function ast_isExpression(node) {
+    return ast_hasProperty(mctreeTypeInfo[node.type], "expr");
+}
+function ast_mayThrow(node) {
+    switch (node.type) {
+        case "BinaryExpression":
+        case "CallExpression":
+        case "ConditionalExpression":
+        case "LogicalExpression":
+        case "NewExpression":
+        case "ThrowStatement":
+        case "UnaryExpression":
+        case "UpdateExpression":
+            return true;
+        default:
+            return false;
+    }
+}
+function ast_hasProperty(obj, prop) {
+    return obj ? Object.prototype.hasOwnProperty.call(obj, prop) : false;
+}
+function ast_withLoc(node, start, end) {
+    if (start && start.loc) {
+        node.start = start.start;
+        if (!node.end)
+            node.end = start.end;
+        node.loc = { ...(node.loc || start.loc), start: start.loc.start };
+    }
+    if (end && end.loc) {
+        node.end = end.end;
+        node.loc = { ...(node.loc || end.loc), end: end.loc.end };
+    }
+    return node;
+}
+function ast_withLocDeep(node, start, end, inplace) {
+    node = ast_withLoc(inplace ? node : { ...node }, start, end);
+    for (const key of mctreeTypeInfo[node.type].keys) {
+        const value = node[key];
+        if (!value)
+            continue;
+        const fix = (v) => isMCTreeNode(v) ? ast_withLocDeep(v, start, end, inplace) : v;
+        const repl = Array.isArray(value) ? value.map(fix) : fix(value);
+        inplace || (node[key] = repl);
+    }
+    return node;
+}
+function ast_cloneDeep(node) {
+    return ast_withLocDeep(node, null);
+}
 
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
+;// CONCATENATED MODULE: ./src/function-info.ts
+
+function function_info_cloneSet(ae) {
+    return new Set(ae);
+}
+function function_info_mergeSet(a, b) {
+    b.forEach((event) => a.add(event));
+}
+function recordModifiedDecl(func, decl) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.modifiedDecls.add(decl);
+    return null;
+}
+function function_info_recordModifiedDecls(func, lookupDefs) {
+    lookupDefs.forEach((lookupDef) => lookupDef.results.forEach((result) => {
+        if (result.type == "VariableDeclarator" && result.node.kind === "var") {
+            recordModifiedDecl(func, result);
+        }
+    }));
+}
+function function_info_recordModifiedName(func, name) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    if (!func.next_info.modifiedNames) {
+        func.next_info.modifiedNames = new Set();
+    }
+    func.next_info.modifiedNames.add(name);
+}
+function function_info_recordModifiedUnknown(func) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.modifiedUnknown = true;
+}
+function recordCalledFunc(func, callee) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.calledFuncs.add(callee);
+    return null;
+}
+function function_info_recordCalledFuncs(func, callees) {
+    callees.forEach((callee) => {
+        recordCalledFunc(func, callee);
+    });
+}
+function function_info_functionMayModify(state, func, decl) {
+    const info = func.info;
+    if (!info || info.modifiedUnknown)
+        return true;
+    if (info.resolvedDecls) {
+        return info.resolvedDecls.has(decl);
+    }
+    if (info.modifiedNames?.has(decl.name))
+        return true;
+    if (info.modifiedDecls.has(decl))
+        return true;
+    const visited = new Set();
+    const resolved = new Set();
+    const resolveDecls = (f) => {
+        if (visited.has(f))
+            return true;
+        if (!f.info)
+            return false;
+        if (f.info.modifiedUnknown) {
+            info.modifiedUnknown = true;
+            return false;
+        }
+        if (f.info.modifiedNames) {
+            if (info.modifiedNames) {
+                function_info_mergeSet(info.modifiedNames, f.info.modifiedNames);
+            }
+            else {
+                info.modifiedNames = function_info_cloneSet(f.info.modifiedNames);
+            }
+        }
+        function_info_mergeSet(resolved, f.info.modifiedDecls);
+        visited.add(f);
+        const q = true;
+        if (q &&
+            f.info.callsExposed &&
+            state.exposed &&
+            !Object.keys(state.exposed).every((key) => !state.allFunctions[key] ||
+                state.allFunctions[key].every(resolveDecls))) {
+            return false;
+        }
+        return Array.from(f.info.calledFuncs).every(resolveDecls);
+    };
+    if (resolveDecls(func)) {
+        info.resolvedDecls = resolved;
+        return resolved.has(decl);
+    }
+    return true;
+}
+function function_info_findCallees(lookupDefs) {
+    const decls = lookupDefs.reduce((decls, r) => (decls ? decls.concat(r.results) : r.results), null);
+    return (decls &&
+        decls.filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
+}
+function function_info_findCalleesForNew(lookupDefs) {
+    const initializer = (decl) => {
+        if (hasProperty(decl.decls, "initialize")) {
+            return decl.decls["initialize"];
+        }
+        if (decl.superClass && decl.superClass !== true) {
+            return decl.superClass.reduce((cur, cls) => {
+                const init = initializer(cls);
+                if (init) {
+                    if (!cur)
+                        return init;
+                    return cur.concat(init);
+                }
+                return cur;
+            }, null);
+        }
+        return null;
+    };
+    return lookupDefs.flatMap((r) => r.results
+        .filter((decl) => decl.type === "ClassDeclaration")
+        .flatMap(initializer)
+        .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
+}
+
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
 
@@ -270,6 +671,7 @@ function variable_renamer_renameVariable(state, locals, declName) {
 
 
 
+
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
@@ -302,8 +704,9 @@ function getArgSafety(state, func, args, requireAll) {
         }
     };
     const safeArgs = [];
+    const argDecls = [];
     let allSafe = true;
-    if (!args.every((arg) => {
+    if (!args.every((arg, i) => {
         switch (arg.type) {
             case "Literal":
                 safeArgs.push(true);
@@ -317,13 +720,17 @@ function getArgSafety(state, func, args, requireAll) {
                     safeArgs.push(null);
                     return !requireAll;
                 }
-                const safety = getSafety(results[0].results[0]);
+                const decl = results[0].results[0];
+                const safety = getSafety(decl);
                 safeArgs.push(safety);
                 if (!safety) {
                     allSafe = false;
                     if (safety === null) {
                         return !requireAll;
                     }
+                    else if (decl.type === "VariableDeclarator") {
+                        argDecls[i] = decl;
+                    }
                 }
                 return true;
             }
@@ -336,34 +743,91 @@ function getArgSafety(state, func, args, requireAll) {
     }
     if (allSafe && requireAll)
         return true;
-    let callSeen = false;
+    const callsSeen = new Set();
+    const modifiedDecls = new Set();
+    let modifiedUnknown = false;
     const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
     // look for uses of "unsafe" args that occur after a call.
     // use post to do the checking, because arguments are evaluated
     // prior to the call, so eg "return f(x.y);" is fine, but
     // "return f()+x.y" is not.
-    traverseAst(func.node.body, null, (node) => {
-        switch (node.type) {
-            case "AssignmentExpression":
-            case "UpdateExpression": {
-                const v = node.type == "UpdateExpression" ? node.argument : node.left;
-                if (v.type === "Identifier" && hasProperty(params, v.name)) {
-                    safeArgs[params[v.name]] = null;
+    const { pre, post, stack } = state;
+    try {
+        delete state.pre;
+        state.post = (node) => {
+            switch (node.type) {
+                case "AssignmentExpression":
+                case "UpdateExpression": {
+                    const v = node.type == "UpdateExpression" ? node.argument : node.left;
+                    if (v.type === "Identifier" && hasProperty(params, v.name)) {
+                        // If a parameter is modified, we can't just substitute the
+                        // argument wherever the parameter is used.
+                        safeArgs[params[v.name]] = null;
+                        break;
+                    }
+                    if (modifiedUnknown)
+                        break;
+                    const [, results] = state.lookup(v);
+                    if (results) {
+                        results.forEach((r) => r.results.forEach((decl) => decl.type === "VariableDeclarator" && modifiedDecls.add(decl)));
+                    }
+                    else {
+                        modifiedUnknown = true;
+                    }
+                    break;
                 }
+                case "CallExpression":
+                case "NewExpression":
+                    if (!modifiedUnknown) {
+                        const [, results] = state.lookup(node.callee, null, 
+                        // calls are looked up as non-locals, but new is not
+                        node.type === "CallExpression" ? func.stack : state.stack);
+                        if (!results) {
+                            const callee_name = node.callee.type === "Identifier"
+                                ? node.callee
+                                : node.callee.type === "MemberExpression"
+                                    ? isLookupCandidate(node.callee)
+                                    : null;
+                            if (callee_name) {
+                                const callees = state.allFunctions[callee_name.name];
+                                if (callees) {
+                                    callees.forEach((callee) => callsSeen.add(callee));
+                                }
+                            }
+                            else {
+                                modifiedUnknown = true;
+                            }
+                        }
+                        else {
+                            const callees = node.type === "CallExpression"
+                                ? findCallees(results)
+                                : findCalleesForNew(results);
+                            if (callees) {
+                                callees.forEach((callee) => callsSeen.add(callee));
+                            }
+                        }
+                    }
+                    break;
+                case "Identifier":
+                    if (hasProperty(params, node.name) &&
+                        !safeArgs[params[node.name]] &&
+                        (modifiedUnknown ||
+                            !argDecls[params[node.name]] ||
+                            modifiedDecls.has(argDecls[params[node.name]]) ||
+                            Array.from(callsSeen).some((callee) => functionMayModify(state, callee, argDecls[params[node.name]])))) {
+                        safeArgs[params[node.name]] = null;
+                    }
             }
-            // fall through
-            case "CallExpression":
-            case "NewExpression":
-                callSeen = true;
-                break;
-            case "Identifier":
-                if (callSeen &&
-                    hasProperty(params, node.name) &&
-                    !safeArgs[params[node.name]]) {
-                    safeArgs[params[node.name]] = null;
-                }
-        }
-    });
+            return null;
+        };
+        state.stack = func.stack;
+        state.traverse(func.node.body);
+    }
+    finally {
+        state.pre = pre;
+        state.post = post;
+        state.stack = stack;
+    }
     return safeArgs;
 }
 function canInline(state, func, args) {
@@ -468,9 +932,6 @@ function processInlineBody(state, func, call, root, params) {
         state.pre = (node) => {
             if (failed)
                 return [];
-            node.start = call.start;
-            node.end = call.end;
-            node.loc = call.loc;
             if (replacements.has(node))
                 return false;
             const result = pre(node, state);
@@ -485,6 +946,7 @@ function processInlineBody(state, func, call, root, params) {
                     if (params[paramName] >= 0)
                         return null;
                     const name = renameVariable(state, locals, paramName) || paramName;
+                    locals.map[name] = true;
                     return {
                         type: "VariableDeclarator",
                         id: { type: "Identifier", name },
@@ -503,31 +965,49 @@ function processInlineBody(state, func, call, root, params) {
             }
             return result;
         };
+        const fixId = (node) => {
+            if (state.inType)
+                return null;
+            if (hasProperty(params, node.name)) {
+                const ix = params[node.name];
+                if (ix >= 0) {
+                    const replacement = { ...call.arguments[ix] };
+                    replacements.add(replacement);
+                    return replacement;
+                }
+                return null;
+            }
+            const replacement = fixNodeScope(state, node, func.stack);
+            if (!replacement) {
+                failed = true;
+                inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+            }
+            return replacement;
+        };
         state.post = (node) => {
             if (failed)
                 return post(node, state);
             let replacement = null;
             switch (node.type) {
-                case "Identifier": {
-                    if (state.inType)
-                        break;
-                    if (hasProperty(params, node.name)) {
-                        const ix = params[node.name];
-                        if (ix >= 0) {
-                            replacement = call.arguments[ix];
-                            replacements.add(replacement);
-                            return replacement;
+                case "AssignmentExpression":
+                    if (node.left.type === "Identifier") {
+                        const rep = fixId(node.left);
+                        if (rep) {
+                            node.left = rep;
                         }
-                        break;
                     }
-                    replacement = fixNodeScope(state, node, func.stack);
-                    if (!replacement) {
-                        failed = true;
-                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
-                        return post(node, state);
+                    break;
+                case "UpdateExpression":
+                    if (node.argument.type === "Identifier") {
+                        const rep = fixId(node.argument);
+                        if (rep) {
+                            node.argument = rep;
+                        }
                     }
                     break;
-                }
+                case "Identifier":
+                    replacement = fixId(node);
+                    break;
             }
             const ret = post(replacement || node, state);
             return ret === false || ret ? ret : replacement;
@@ -553,6 +1033,10 @@ function processInlineBody(state, func, call, root, params) {
     }
 }
 function inliner_unused(expression, top) {
+    const estmt = (expression) => withLoc({
+        type: "ExpressionStatement",
+        expression,
+    }, expression);
     switch (expression.type) {
         case "Literal":
             return [];
@@ -564,9 +1048,50 @@ function inliner_unused(expression, top) {
             if (expression.operator === "as") {
                 return inliner_unused(expression.left);
             }
-        // fall through
-        case "LogicalExpression":
             return inliner_unused(expression.left).concat(inliner_unused(expression.right));
+        case "LogicalExpression": {
+            const right = inliner_unused(expression.right);
+            if (!right.length)
+                return inliner_unused(expression.left);
+            const consequent = withLoc({
+                type: "BlockStatement",
+                body: [estmt(expression.right)],
+            }, expression.right);
+            let alternate;
+            if (expression.operator == "||") {
+                alternate = { ...consequent };
+                consequent.body = [];
+            }
+            return [
+                withLoc({
+                    type: "IfStatement",
+                    test: expression.left,
+                    consequent,
+                    alternate,
+                }, expression),
+            ];
+        }
+        case "ConditionalExpression": {
+            const consequentExprs = inliner_unused(expression.consequent);
+            const alternateExprs = inliner_unused(expression.alternate);
+            if (!consequentExprs.length && !alternateExprs.length) {
+                return inliner_unused(expression.test);
+            }
+            return [
+                withLoc({
+                    type: "IfStatement",
+                    test: expression.test,
+                    consequent: withLoc({
+                        type: "BlockStatement",
+                        body: consequentExprs,
+                    }, expression.consequent),
+                    alternate: withLoc({
+                        type: "BlockStatement",
+                        body: alternateExprs,
+                    }, expression.alternate),
+                }, expression),
+            ];
+        }
         case "UnaryExpression":
             return inliner_unused(expression.argument);
         case "MemberExpression":
@@ -581,17 +1106,7 @@ function inliner_unused(expression, top) {
                 .map((p) => inliner_unused(p.key).concat(inliner_unused(p.value)))
                 .flat(1);
     }
-    return top
-        ? null
-        : [
-            {
-                type: "ExpressionStatement",
-                expression,
-                start: expression.start,
-                end: expression.end,
-                loc: expression.loc,
-            },
-        ];
+    return top ? null : [estmt(expression)];
 }
 function inliner_diagnostic(state, loc, message, type = "INFO") {
     if (!loc || !loc.source)
@@ -624,6 +1139,10 @@ function inlineWithArgs(state, func, call, context) {
     if (!func.node || !func.node.body) {
         return null;
     }
+    const lastStmt = (block) => {
+        const last = block.body.slice(-1)[0];
+        return last.type === "BlockStatement" ? lastStmt(last) : [last, block];
+    };
     let retStmtCount = 0;
     if (context.type === "ReturnStatement") {
         const last = func.node.body.body.slice(-1)[0];
@@ -639,21 +1158,25 @@ function inlineWithArgs(state, func, call, context) {
         if (retStmtCount > 1) {
             inlineDiagnostic(state, func, call, "Function had more than one return statement");
         }
-        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+        else if ((context.type === "AssignmentExpression" ||
+            context.type === "VariableDeclarator") &&
+            retStmtCount !== 1) {
             inlineDiagnostic(state, func, call, "Function did not have a return statement");
             return null;
         }
         if (retStmtCount === 1) {
-            const last = func.node.body.body.slice(-1)[0];
+            const [last] = lastStmt(func.node.body);
             if (!last ||
                 last.type !== "ReturnStatement" ||
-                (context.type === "AssignmentExpression" && !last.argument)) {
+                ((context.type === "AssignmentExpression" ||
+                    context.type === "VariableDeclarator") &&
+                    !last.argument)) {
                 inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
                 return null;
             }
         }
     }
-    const body = JSON.parse(JSON.stringify(func.node.body));
+    const body = cloneDeep(func.node.body);
     const safeArgs = getArgSafety(state, func, call.arguments, false);
     const params = Object.fromEntries(func.node.params.map((param, i) => {
         const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
@@ -667,37 +1190,54 @@ function inlineWithArgs(state, func, call, context) {
     }
     inliner_diagnostic(state, call.loc, null);
     if (context.type !== "ReturnStatement" && retStmtCount) {
-        const last = body.body[body.body.length - 1];
+        const [last, block] = lastStmt(body);
         if (last.type != "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
-        if (context.type === "AssignmentExpression") {
-            context.right = last.argument;
-            body.body[body.body.length - 1] = {
-                type: "ExpressionStatement",
-                expression: context,
-            };
-        }
-        else if (last.argument) {
-            const side_exprs = inliner_unused(last.argument);
-            body.body.splice(body.body.length - 1, 1, ...side_exprs);
+        if (last.argument) {
+            if (context.type === "AssignmentExpression") {
+                context.right = last.argument;
+                block.body[block.body.length - 1] = {
+                    type: "ExpressionStatement",
+                    expression: context,
+                };
+            }
+            else if (context.type === "VariableDeclarator") {
+                const { id, init: _init, kind: _kind, ...rest } = context;
+                block.body[block.body.length - 1] = {
+                    ...rest,
+                    type: "ExpressionStatement",
+                    expression: {
+                        ...rest,
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: id.type === "Identifier" ? id : id.left,
+                        right: last.argument,
+                    },
+                };
+            }
+            else {
+                const side_exprs = inliner_unused(last.argument);
+                block.body.splice(block.body.length - 1, 1, ...side_exprs);
+            }
         }
         else {
-            --body.body.length;
+            --block.body.length;
         }
     }
+    withLocDeep(body, context, context, true);
     return body;
 }
 function inliner_inlineFunction(state, func, call, context) {
     if (context) {
         return inlineWithArgs(state, func, call, context);
     }
-    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
+    const retArg = cloneDeep(func.node.body.body[0].argument);
     const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
     const map = fixupLocalsMap(state);
     const ret = processInlineBody(state, func, call, retArg, params);
     state.localsStack[state.localsStack.length - 1].map = map;
-    return ret;
+    return ret && withLocDeep(ret, call, call, true);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -799,11 +1339,1660 @@ function fixNodeScope(state, lookupNode, nodeStack) {
             loc: node.loc,
         }, node));
     }
-    return null;
+    return null;
+}
+
+;// CONCATENATED MODULE: ./src/pragma-checker.ts
+
+
+
+function pragma_checker_pragmaChecker(state, ast, diagnostics) {
+    const comments = ast.comments;
+    if (!comments)
+        return;
+    diagnostics = diagnostics
+        ?.slice()
+        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
+    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];
+            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.loc, `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+)/g, "(pre_)?$1(_\\d+)?"));
+        return re.test(haystack);
+    };
+    next();
+    traverseAst(ast, (node) => {
+        if (index >= comments.length)
+            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.loc, `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.loc, `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;
+    });
+}
+
+;// CONCATENATED MODULE: external "./util.cjs"
+const external_util_cjs_namespaceObject = require("./util.cjs");
+;// CONCATENATED MODULE: ./src/control-flow.ts
+
+
+const Terminals = {
+    BreakStatement: "break",
+    ContinueStatement: "continue",
+    ReturnStatement: null,
+    ThrowStatement: "throw",
+};
+class LocalState {
+    constructor(func) {
+        this.stack = [];
+        this.info = new Map();
+        this.curBlock = {};
+        this.unreachable = false;
+        this.push(func);
+    }
+    push(node) {
+        const top = { node };
+        this.stack.push(top);
+        return top;
+    }
+    pop() {
+        return this.stack.pop();
+    }
+    top(depth) {
+        return this.stack[this.stack.length - (depth || 1)];
+    }
+    addEdge(from, to) {
+        if (!from.succs) {
+            from.succs = [to];
+        }
+        else {
+            pushUnique(from.succs, to);
+        }
+        if (!to.preds) {
+            to.preds = [from];
+        }
+        else {
+            pushUnique(to.preds, from);
+        }
+    }
+    newBlock(block) {
+        if (!block)
+            block = {};
+        if (!this.unreachable) {
+            this.addEdge(this.curBlock, block);
+        }
+        this.unreachable = false;
+        for (let i = this.stack.length; i--;) {
+            const si = this.stack[i];
+            if (si.throw) {
+                block.exsucc = si.throw;
+                if (!si.throw.expreds) {
+                    si.throw.expreds = [block];
+                }
+                else {
+                    si.throw.expreds.push(block);
+                }
+                break;
+            }
+        }
+        return (this.curBlock = block);
+    }
+    terminal(type) {
+        const re = Terminals[type];
+        if (re) {
+            for (let i = this.stack.length; i--;) {
+                const target = this.stack[i][re];
+                if (target) {
+                    this.addEdge(this.curBlock, target);
+                    break;
+                }
+            }
+        }
+        this.unreachable = true;
+    }
+}
+function control_flow_buildReducedGraph(state, func, notice) {
+    const { stack, pre, post } = state;
+    try {
+        const localState = new LocalState(func.node);
+        const ret = localState.curBlock;
+        state.stack = func.stack;
+        const stmtStack = [func.node];
+        let tryActive = 0;
+        state.pre = (node) => {
+            if (state.inType || localState.unreachable) {
+                return [];
+            }
+            if (!localState.curBlock.node &&
+                (isStatement(node) || isExpression(node))) {
+                localState.curBlock.node = node;
+            }
+            if (isStatement(node)) {
+                stmtStack.push(node);
+            }
+            switch (node.type) {
+                case "AttributeList":
+                    return [];
+                case "SwitchStatement": {
+                    const top = localState.push(node);
+                    top.break = {};
+                    state.traverse(node.discriminant);
+                    const testBlocks = [];
+                    let defaultSeen = false;
+                    node.cases.forEach((sc, i) => {
+                        if (sc.test) {
+                            state.traverse(sc.test);
+                            testBlocks[i] = localState.curBlock;
+                            localState.newBlock();
+                        }
+                        else {
+                            defaultSeen = true;
+                        }
+                    });
+                    const endOfTests = localState.curBlock;
+                    if (!defaultSeen) {
+                        localState.addEdge(endOfTests, top.break);
+                    }
+                    localState.unreachable = true;
+                    node.cases.forEach((sc, i) => {
+                        localState.newBlock();
+                        localState.addEdge(testBlocks[i] || endOfTests, localState.curBlock);
+                        sc.consequent.every((s) => {
+                            state.traverse(s);
+                            return !localState.unreachable;
+                        });
+                    });
+                    localState.newBlock(top.break);
+                    localState.unreachable = !top.break.preds;
+                    return [];
+                }
+                case "DoWhileStatement":
+                case "WhileStatement": {
+                    localState.push(node);
+                    const top = localState.top();
+                    top.break = {};
+                    top.continue = {};
+                    let head;
+                    if (node.type === "WhileStatement") {
+                        head = localState.newBlock(top.continue);
+                        state.traverse(node.test);
+                        localState.addEdge(localState.curBlock, top.break);
+                        localState.newBlock();
+                    }
+                    else {
+                        head = localState.newBlock();
+                    }
+                    state.traverse(node.body);
+                    if (node.type === "DoWhileStatement") {
+                        localState.newBlock(top.continue);
+                        state.traverse(node.test);
+                        localState.addEdge(localState.curBlock, top.break);
+                    }
+                    localState.addEdge(localState.curBlock, head);
+                    localState.curBlock = top.break;
+                    return [];
+                }
+                case "TryStatement": {
+                    const top = localState.push(node);
+                    const catches = (top.throw = {});
+                    // This edge shouldn't exist, but we can trigger
+                    // (incorrect) "variable may not be initialized" errors
+                    // in the monkey c compiler without it.
+                    // https://forums.garmin.com/developer/connect-iq/i/bug-reports/incorrect-maybe-uninitialized-error
+                    localState.addEdge(localState.curBlock, top.throw);
+                    localState.newBlock();
+                    tryActive++;
+                    state.traverse(node.block);
+                    tryActive--;
+                    delete top.throw;
+                    top.posttry = {};
+                    const tryFallsThrough = !localState.unreachable;
+                    if (node.finalizer) {
+                        tryActive++;
+                        top.throw = top.finally = {};
+                        // curBlock branches to finally, no matter how it exits.
+                        localState.addEdge(localState.curBlock, top.finally);
+                    }
+                    else {
+                        if (!localState.unreachable) {
+                            localState.addEdge(localState.curBlock, top.posttry);
+                        }
+                    }
+                    localState.unreachable = true;
+                    localState.newBlock(catches);
+                    if (node.handler) {
+                        state.traverse(node.handler);
+                        if (top.throw) {
+                            tryActive--;
+                            delete top.throw;
+                        }
+                        // Each "catch (ex instanceof Foo)" chains to the next,
+                        // but "catch (ex)" terminates the list. If the end
+                        // of the chain has a predecessor, its possible that
+                        // none of the conditions matched, so the exception
+                        // will propagate from there.
+                        if (localState.curBlock.preds) {
+                            localState.terminal("ThrowStatement");
+                        }
+                    }
+                    if (top.throw) {
+                        tryActive--;
+                        delete top.throw;
+                    }
+                    if (node.finalizer) {
+                        localState.unreachable = true;
+                        localState.newBlock(top.finally);
+                        delete top.finally;
+                        state.traverse(node.finalizer);
+                        if (tryFallsThrough && !localState.unreachable) {
+                            localState.addEdge(localState.curBlock, top.posttry);
+                        }
+                        localState.terminal("ThrowStatement");
+                    }
+                    localState.unreachable = true;
+                    localState.newBlock(top.posttry);
+                    return [];
+                }
+                case "CatchClause": {
+                    const top = localState.top();
+                    if (!localState.curBlock.preds && !localState.curBlock.expreds) {
+                        return [];
+                    }
+                    const next = {};
+                    if (node.param && node.param.type === "BinaryExpression") {
+                        state.traverse(node.param);
+                        localState.addEdge(localState.curBlock, next);
+                        localState.newBlock();
+                    }
+                    state.traverse(node.body);
+                    if (top.finally) {
+                        // this edge exists even if this point is unreachable
+                        localState.addEdge(localState.curBlock, top.finally);
+                    }
+                    if (!localState.unreachable) {
+                        if (!top.posttry)
+                            top.posttry = {};
+                        localState.addEdge(localState.curBlock, top.posttry);
+                    }
+                    localState.unreachable = true;
+                    localState.newBlock(next);
+                    return [];
+                }
+                case "ForStatement": {
+                    const top = localState.push(node);
+                    if (node.init)
+                        state.traverse(node.init);
+                    const head = localState.newBlock();
+                    top.break = {};
+                    top.continue = {};
+                    if (node.test) {
+                        state.traverse(node.test);
+                        localState.addEdge(localState.curBlock, top.break);
+                        localState.newBlock();
+                    }
+                    state.traverse(node.body);
+                    localState.newBlock(top.continue);
+                    if (node.update) {
+                        state.traverse(node.update);
+                    }
+                    if (!localState.unreachable) {
+                        localState.addEdge(localState.curBlock, head);
+                    }
+                    // there is no fall through from the end of the loop
+                    // to the next block. The only way there is via break
+                    // or the test failing.
+                    localState.unreachable = true;
+                    localState.newBlock(top.break);
+                    if (!top.break.preds) {
+                        localState.unreachable = true;
+                    }
+                    return [];
+                }
+                case "IfStatement":
+                case "ConditionalExpression": {
+                    state.traverse(node.test);
+                    const alternate = {};
+                    localState.addEdge(localState.curBlock, alternate);
+                    localState.newBlock();
+                    state.traverse(node.consequent);
+                    const consequent = localState.unreachable
+                        ? null
+                        : localState.curBlock;
+                    localState.unreachable = true;
+                    localState.newBlock(alternate);
+                    if (node.alternate) {
+                        state.traverse(node.alternate);
+                        if (!localState.unreachable) {
+                            localState.newBlock();
+                        }
+                    }
+                    if (consequent) {
+                        if (localState.unreachable) {
+                            localState.newBlock();
+                        }
+                        localState.addEdge(consequent, localState.curBlock);
+                    }
+                    return [];
+                }
+                case "LogicalExpression": {
+                    state.traverse(node.left);
+                    if (localState.unreachable)
+                        break;
+                    const mid = localState.curBlock;
+                    localState.newBlock();
+                    state.traverse(node.right);
+                    localState.newBlock();
+                    localState.addEdge(mid, localState.curBlock);
+                    return [];
+                }
+                case "VariableDeclarator":
+                    return ["init"];
+                case "MemberExpression":
+                    if (!node.computed) {
+                        return ["object"];
+                    }
+                    break;
+                case "UnaryExpression":
+                    if (node.operator === ":") {
+                        return [];
+                    }
+                    break;
+                case "UpdateExpression":
+                    // We don't want to traverse the argument, since then it would
+                    // look like a ref, rather than a def. But if its a
+                    // MemberExpression, we *do* want to traverse the subexpressions
+                    // as potential refs.
+                    if (node.argument.type === "MemberExpression") {
+                        state.traverse(node.argument.object);
+                        if (node.argument.computed) {
+                            state.traverse(node.argument.property);
+                        }
+                    }
+                    return [];
+                case "AssignmentExpression":
+                    if (node.left.type === "MemberExpression") {
+                        state.traverse(node.left.object);
+                        if (node.left.computed) {
+                            state.traverse(node.left.property);
+                        }
+                    }
+                    return ["right"];
+                case "ThrowStatement":
+                case "ReturnStatement":
+                    if (node.argument) {
+                        state.traverse(node.argument);
+                    }
+                // fall through
+                case "BreakStatement":
+                case "ContinueStatement":
+                    localState.terminal(node.type);
+                    return [];
+            }
+            return null;
+        };
+        const addEvent = (block, event) => {
+            if (!block.events) {
+                block.events = [event];
+            }
+            else {
+                block.events.push(event);
+            }
+        };
+        state.post = (node) => {
+            const curStmt = stmtStack[stmtStack.length - 1];
+            if (!state.inType) {
+                const throws = tryActive > 0 && mayThrow(node);
+                const event = notice(node, curStmt, throws);
+                if (throws) {
+                    if (!event) {
+                        throw new Error("mayThrow expression in try/catch must generate an event");
+                    }
+                }
+                else if (event) {
+                    event.mayThrow = false;
+                }
+                if (event) {
+                    if (event.mayThrow) {
+                        for (let i = localState.stack.length; i--;) {
+                            const target = localState.stack[i].throw;
+                            if (target) {
+                                if (localState.curBlock.exsucc) {
+                                    if (localState.curBlock.exsucc !== target) {
+                                        throw new Error(`Block has multiple throw targets`);
+                                    }
+                                }
+                                else {
+                                    localState.curBlock.exsucc = target;
+                                    if (!target.expreds) {
+                                        target.expreds = [localState.curBlock];
+                                    }
+                                    else {
+                                        target.expreds.push(localState.curBlock);
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    addEvent(localState.curBlock, event);
+                }
+            }
+            if (curStmt === node) {
+                stmtStack.pop();
+            }
+            if (localState.top().node === node) {
+                localState.pop();
+            }
+            return null;
+        };
+        state.traverse(func.node);
+        return cleanCfg(ret);
+    }
+    finally {
+        state.pre = pre;
+        state.post = post;
+        state.stack = stack;
+    }
+}
+function cleanCfg(head) {
+    preOrderTraverse(head, (cur) => {
+        if (cur.succs && cur.succs.length === 1) {
+            const succ = cur.succs[0];
+            if (succ !== head &&
+                succ.preds.length === 1 &&
+                (!cur.exsucc || cur.exsucc === succ.exsucc) &&
+                (!succ.succs ||
+                    succ.succs.length === 1 ||
+                    (cur.preds && cur.preds.length === 1))) {
+                if (cur.events) {
+                    if (succ.events) {
+                        cur.events.push(...succ.events);
+                    }
+                }
+                else if (succ.events) {
+                    cur.events = succ.events;
+                }
+                if (succ.exsucc) {
+                    const preds = succ.exsucc.expreds;
+                    for (let i = preds.length; i--;) {
+                        if (preds[i] === succ) {
+                            // If cur has an exsucc, we already
+                            // checked that its the same as succ's,
+                            // so we can just delete the edge.
+                            // Otherwise, we need to point it at cur.
+                            if (cur.exsucc) {
+                                preds.splice(i, 1);
+                            }
+                            else {
+                                preds[i] = cur;
+                            }
+                        }
+                    }
+                }
+                cur.exsucc = succ.exsucc;
+                cur.succs = succ.succs;
+                if (cur.succs) {
+                    cur.succs.forEach((s) => s.preds.forEach((p, i, arr) => {
+                        if (p === succ) {
+                            arr[i] = cur;
+                        }
+                    }));
+                }
+                if (!cur.node)
+                    cur.node = succ.node;
+            }
+        }
+    });
+    return head;
+}
+function postOrderTraverse(head, visitor) {
+    const visited = new Set();
+    const helper = (cur) => {
+        if (visited.has(cur))
+            return;
+        visited.add(cur);
+        if (cur.succs) {
+            cur.succs.forEach((block) => helper(block));
+        }
+        if (cur.exsucc)
+            helper(cur.exsucc);
+        visitor(cur);
+    };
+    helper(head);
+}
+function preOrderTraverse(head, visitor) {
+    const visited = new Set();
+    const helper = (cur) => {
+        if (visited.has(cur))
+            return;
+        visited.add(cur);
+        visitor(cur);
+        if (cur.succs) {
+            cur.succs.forEach((block) => helper(block));
+        }
+        if (cur.exsucc)
+            helper(cur.exsucc);
+    };
+    helper(head);
+}
+function control_flow_getPostOrder(head) {
+    const blocks = [];
+    postOrderTraverse(head, (block) => blocks.push(block));
+    return blocks;
+}
+function getPreOrder(head) {
+    const blocks = [];
+    postOrderTraverse(head, (block) => blocks.push(block));
+    return blocks;
+}
+
+// EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
+var priorityqueuejs = __webpack_require__(2789);
+;// CONCATENATED MODULE: ./src/pre.ts
+
+
+
+
+
+/**
+ * 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 declFullName(decl) {
+    switch (decl.type) {
+        case "Literal":
+            return decl.raw || decl.value?.toString() || "null";
+        case "VariableDeclarator":
+            return decl.fullName;
+        default:
+            throw new Error(`Unexpected EventDecl type: ${decl.type}`);
+    }
+}
+function declName(decl) {
+    switch (decl.type) {
+        case "Literal":
+            return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
+        case "VariableDeclarator":
+            return decl.name;
+        default:
+            throw new Error(`Unexpected EventDecl type: ${decl.type}`);
+    }
+}
+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 pre_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;
+        candidates.forEach((s, 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);
+            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 unhandledExpression(node) {
+    throw new Error(`Unhandled expression type: ${node.type}`);
+}
+function buildPREGraph(state, func) {
+    const findDecl = (node) => {
+        if (node.type === "Identifier" ||
+            (node.type === "MemberExpression" && !node.computed)) {
+            const [, results] = state.lookup(node);
+            if (results &&
+                results.length === 1 &&
+                results[0].parent?.type != "BlockStatement" &&
+                results[0].results.length === 1 &&
+                results[0].results[0].type === "VariableDeclarator") {
+                return results[0].results[0];
+            }
+        }
+        return null;
+    };
+    const literals = new Map();
+    const identifiers = new Set();
+    const liveDefs = new Map();
+    const liveStmts = new Map();
+    const liveDef = (def, stmt) => {
+        let curNodes = liveDefs.get(def);
+        if (!curNodes) {
+            liveDefs.set(def, (curNodes = new Set()));
+        }
+        curNodes.add(stmt);
+        let defs = liveStmts.get(stmt);
+        if (!defs) {
+            liveStmts.set(stmt, (defs = new Map()));
+        }
+        defs.set(def, (defs.get(def) || 0) + 1);
+    };
+    return {
+        identifiers,
+        graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
+            const defs = liveStmts.get(node);
+            if (defs) {
+                liveStmts.delete(node);
+                defs.forEach((count, def) => {
+                    if (count > 1) {
+                        defs.set(def, count--);
+                        return;
+                    }
+                    const v = liveDefs.get(def);
+                    if (!v || !v.has(node)) {
+                        throw new Error(`No stmt in liveDef for ${def ? declFullName(def) : "null"}`);
+                    }
+                    v.delete(node);
+                    if (!v.size) {
+                        liveDefs.delete(def);
+                    }
+                });
+            }
+            switch (node.type) {
+                case "BinaryExpression":
+                case "UnaryExpression":
+                case "SizedArrayExpression":
+                case "ArrayExpression":
+                case "ObjectExpression":
+                case "ThisExpression":
+                case "LogicalExpression":
+                case "ConditionalExpression":
+                case "SequenceExpression":
+                case "ParenthesizedExpression":
+                    break;
+                case "Literal":
+                    if (refCost(node) > LocalRefCost) {
+                        let decl = literals.get(node.value);
+                        if (!decl) {
+                            decl = node;
+                            literals.set(node.value, decl);
+                        }
+                        return {
+                            type: "ref",
+                            node,
+                            decl: decl,
+                            mayThrow,
+                        };
+                    }
+                    break;
+                case "Identifier":
+                    identifiers.add(node.name);
+                // fall through
+                case "MemberExpression":
+                    {
+                        const decl = findDecl(node);
+                        if (decl && decl.type === "VariableDeclarator") {
+                            const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
+                                liveDefs.get(decl);
+                            if (defStmts) {
+                                break;
+                                /*
+                                // hold off on this for now. we need to communicate
+                                // which defs need to be fixed, which involves yet-another
+                                // table.
+              
+                                if (defStmts.size !== 1) break;
+                                const fixable = isFixableStmt([...defStmts][0]);
+                                if (fixable === false) break;
+                                cost += fixable;
+                              */
+                            }
+                            return {
+                                type: "ref",
+                                node,
+                                decl,
+                                mayThrow,
+                            };
+                        }
+                    }
+                    break;
+                case "VariableDeclarator": {
+                    const decl = findDecl(node.id.type === "BinaryExpression" ? node.id.left : node.id);
+                    if (decl) {
+                        liveDef(decl, stmt);
+                        return {
+                            type: "def",
+                            node,
+                            decl,
+                            mayThrow,
+                        };
+                    }
+                    break;
+                }
+                case "AssignmentExpression": {
+                    const decl = findDecl(node.left);
+                    if (decl) {
+                        liveDef(decl, stmt);
+                        return {
+                            type: "def",
+                            node,
+                            decl,
+                            mayThrow,
+                        };
+                    }
+                    break;
+                }
+                case "UpdateExpression": {
+                    const decl = findDecl(node.argument);
+                    if (decl) {
+                        liveDef(decl, stmt);
+                        return {
+                            type: "def",
+                            node,
+                            decl,
+                            mayThrow,
+                        };
+                    }
+                    break;
+                }
+                case "NewExpression": {
+                    const [, results] = state.lookup(node.callee);
+                    const callees = results ? findCalleesForNew(results) : null;
+                    liveDef(null, stmt);
+                    return { type: "mod", node, mayThrow, callees };
+                }
+                case "CallExpression": {
+                    liveDef(null, stmt);
+                    const [, results] = state.lookup(node.callee);
+                    const callees = results ? findCallees(results) : null;
+                    return { type: "mod", node, mayThrow, callees };
+                }
+                default:
+                    if (!isExpression(node))
+                        break;
+                    unhandledExpression(node);
+            }
+            if (mayThrow) {
+                return { type: "exn", node, mayThrow };
+            }
+            return null;
+        }),
+    };
+}
+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) : "??"}`));
+            }
+            console.log(`Succs: ${(block.succs || [])
+                .map((block) => block.order)
+                .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
+        });
+    }
+    const enqueued = new Set();
+    const queue = new PriorityQueue((b, a) => (a.order || 0) - (b.order || 0));
+    const enqueue = (block) => {
+        if (!enqueued.has(block)) {
+            enqueued.add(block);
+            queue.enq(block);
+        }
+    };
+    const dequeue = () => {
+        const block = queue.deq();
+        enqueued.delete(block);
+        return block;
+    };
+    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) => enqueue(block));
+    while (queue.size()) {
+        const top = 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, decl) => {
+                            if (decl.type === "VariableDeclarator" &&
+                                decl.node.kind === "var" &&
+                                candidates.live &&
+                                (!event.callees ||
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl)))) {
+                                candidates.ant.add(getMod(event, decl, 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) => 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;
+    });
+}
+
+;// CONCATENATED MODULE: ./src/unused-exprs.ts
+
+
+
+function unused_exprs_cleanupUnusedVars(state, node) {
+    const [parent] = state.stack.slice(-1);
+    if (parent.node !== node) {
+        return;
+    }
+    if (parent.type != "BlockStatement") {
+        throw new Error(`Unexpected parent type '${parent.type}' for local declaration`);
+    }
+    if (parent.decls) {
+        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) {
+            const varDeclarations = new Map();
+            traverseAst(node, null, (node) => {
+                switch (node.type) {
+                    case "VariableDeclaration": {
+                        node.declarations.forEach((decl, i) => {
+                            const name = variableDeclarationName(decl.id);
+                            if (hasProperty(toRemove, name)) {
+                                const indices = varDeclarations.get(node);
+                                if (indices) {
+                                    indices.push(i);
+                                }
+                                else {
+                                    varDeclarations.set(node, [i]);
+                                }
+                            }
+                        });
+                        break;
+                    }
+                    case "ExpressionStatement":
+                        if (node.expression.type === "AssignmentExpression") {
+                            if (node.expression.left.type === "Identifier" &&
+                                hasProperty(toRemove, node.expression.left.name)) {
+                                return unused(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(expr.right);
+                                    if (!rep.length) {
+                                        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)) {
+                                node.expressions.splice(i, 1);
+                            }
+                        }
+                        break;
+                    }
+                }
+                return null;
+            });
+            varDeclarations.forEach((indices, decl) => {
+                let index = -1;
+                for (let ii = indices.length, j = decl.declarations.length; ii--;) {
+                    const i = indices[ii];
+                    const vdecl = decl.declarations[i];
+                    const name = variableDeclarationName(vdecl.id);
+                    if (hasProperty(toRemove, name)) {
+                        const rep = vdecl.init ? unused(vdecl.init) : [];
+                        if (rep.length) {
+                            if (parent.node.type === "ForStatement") {
+                                // declarations whose inits have side effects
+                                // can't be deleted from for statements.
+                                continue;
+                            }
+                            if (index < 0) {
+                                index = parent.node.body.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);
+                            parent.node.body.splice(index + 1, 0, ...rep);
+                            j = i;
+                            continue;
+                        }
+                        if (toRemove[name]) {
+                            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;
+                        }
+                    }
+                }
+            });
+        }
+    }
 }
 
-;// CONCATENATED MODULE: external "./util.cjs"
-const external_util_cjs_namespaceObject = require("./util.cjs");
 ;// CONCATENATED MODULE: ./src/visitor.ts
 
 function visitor_visitReferences(state, ast, name, defn, callback) {
@@ -868,14 +3057,16 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
                     return checkResults(state.lookup(node), node);
                 }
                 break;
-            case "MemberExpression":
-                if (!node.computed && node.property.type === "Identifier") {
-                    if (!name || node.property.name === name) {
+            case "MemberExpression": {
+                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
+                if (property) {
+                    if (!name || property.name === name) {
                         return checkResults(state.lookup(node), node) || ["object"];
                     }
                     return ["object"];
                 }
                 break;
+            }
             case "MethodDefinition": {
                 if (!state.inType) {
                     throw new Error("Method definition outside of type!");
@@ -884,7 +3075,6 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
                     node.params.forEach((param) => {
                         if (param.type == "BinaryExpression") {
                             state.traverse(param.right);
-                            state.inType = true;
                         }
                     });
                 }
@@ -906,6 +3096,10 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
 
 
 
+
+
+
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -965,8 +3159,7 @@ function collectClassInfo(state) {
             c.decls &&
                 Object.values(c.decls).forEach((funcs) => {
                     funcs.forEach((f) => {
-                        if (isStateNode(f) &&
-                            f.type === "FunctionDeclaration" &&
+                        if (f.type === "FunctionDeclaration" &&
                             hasProperty(cls.decls, f.name)) {
                             f.node.hasOverride = true;
                         }
@@ -979,6 +3172,15 @@ function collectClassInfo(state) {
     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.isStatic) {
+                        markInvokeClassMethod(f);
+                    }
+                });
+            });
+        }
     });
 }
 function getFileSources(fnMap) {
@@ -1018,7 +3220,7 @@ async function analyze(fnMap, barrelList, config) {
     const preState = {
         fnMap,
         config,
-        allFunctions: [],
+        allFunctions: {},
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
@@ -1048,11 +3250,6 @@ async function analyze(fnMap, barrelList, config) {
         pre(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
-                    if (markApi) {
-                        node.body = null;
-                        break;
-                    }
-                // falls through
                 case "ModuleDeclaration":
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
@@ -1063,7 +3260,18 @@ async function analyze(fnMap, barrelList, config) {
                                 (scope.node.attrs &&
                                     scope.node.attrs.access &&
                                     scope.node.attrs.access.includes("static"));
-                        state.allFunctions.push(scope);
+                        if (markApi) {
+                            node.body = null;
+                            scope.info = getApiFunctionInfo(scope);
+                            delete scope.stack;
+                        }
+                        const allFuncs = state.allFunctions;
+                        if (!hasProperty(allFuncs, scope.name)) {
+                            allFuncs[scope.name] = [scope];
+                        }
+                        else {
+                            allFuncs[scope.name].push(scope);
+                        }
                     }
                     else if (scope.type === "ClassDeclaration") {
                         state.allClasses.push(scope);
@@ -1088,7 +3296,7 @@ async function analyze(fnMap, barrelList, config) {
         value.hasTests = hasTests;
     });
     delete state.shouldExclude;
-    delete state.post;
+    delete state.pre;
     collectClassInfo(state);
     const diagnosticType = config?.checkInvalidSymbols !== "OFF"
         ? config?.checkInvalidSymbols || "WARNING"
@@ -1111,6 +3319,8 @@ async function analyze(fnMap, barrelList, config) {
             });
         });
     }
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
     return state;
 }
 function compareLiteralLike(a, b) {
@@ -1156,15 +3366,12 @@ function getLiteralNode(node) {
         if (node.argument.type != "Literal")
             return null;
         switch (node.operator) {
-            case "-":
-                if (typeof node.argument.value == "number") {
-                    return {
-                        ...node.argument,
-                        value: -node.argument.value,
-                        raw: "-" + node.argument.value,
-                        enumType: node.enumType,
-                    };
+            case "-": {
+                const [arg, type] = getNodeValue(node.argument);
+                if (type === "Number" || type === "Long") {
+                    return replacementLiteral(arg, -arg.value, type);
                 }
+            }
         }
     }
     return null;
@@ -1183,31 +3390,114 @@ function getNodeValue(node) {
     if (node.type != "Literal") {
         return [null, null];
     }
-    let type = node.value === null ? "Null" : typeof node.value;
+    if (node.value === null) {
+        return [node, "Null"];
+    }
+    const type = typeof node.value;
     if (type === "number") {
-        const match = node.raw && LiteralIntegerRe.exec(node.raw);
+        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
         if (match) {
-            type = match[2] == "l" ? "Long" : "Number";
-        }
-        else if (node.raw && node.raw.endsWith("d")) {
-            type = "Double";
+            return match[2] === "l" || match[2] === "L"
+                ? [node, "Long"]
+                : [node, "Number"];
         }
-        else {
-            type = "Float";
+        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
+    }
+    if (type === "bigint") {
+        return [node, "Long"];
+    }
+    if (type === "string") {
+        return [node, "String"];
+    }
+    if (type === "boolean") {
+        return [node, "Boolean"];
+    }
+    throw new Error(`Literal has unknown type '${type}'`);
+}
+function fullTypeName(state, tsp) {
+    if (typeof tsp.name === "string") {
+        return tsp.name;
+    }
+    const [, results] = state.lookupType(tsp.name);
+    if (results && results.length === 1 && results[0].results.length === 1) {
+        const result = results[0].results[0];
+        if (isStateNode(result)) {
+            return result.fullName;
         }
     }
-    else if (type === "string") {
-        type = "String";
+    return null;
+}
+function isBooleanExpression(state, node) {
+    switch (node.type) {
+        case "Literal":
+            return typeof node.value === "boolean";
+        case "BinaryExpression":
+            switch (node.operator) {
+                case "==":
+                case "!=":
+                case "<=":
+                case ">=":
+                case "<":
+                case ">":
+                    return true;
+                case "as":
+                    return node.right.ts.length === 1 &&
+                        node.right.ts[0].type === "TypeSpecPart" &&
+                        node.right.ts[0].name &&
+                        fullTypeName(state, node.right.ts[0]) === "$.Toybox.Lang.Boolean"
+                        ? true
+                        : false;
+            }
+            return false;
+        case "LogicalExpression":
+            return (isBooleanExpression(state, node.left) &&
+                isBooleanExpression(state, node.right));
+        case "UnaryExpression":
+            return node.operator === "!" && isBooleanExpression(state, node.argument);
     }
-    else if (type === "boolean") {
+    return false;
+}
+function replacementLiteral(arg, value, type) {
+    if (typeof value === "boolean") {
         type = "Boolean";
     }
-    else {
-        type = "Unknown";
+    else if (type === "Number") {
+        value = Number(BigInt.asIntN(32, BigInt(value)));
+    }
+    else if (type === "Long") {
+        value = BigInt.asIntN(64, BigInt(value));
     }
-    return [node, type];
+    return {
+        ...arg,
+        value,
+        raw: value.toString() + (type === "Long" ? "l" : ""),
+    };
 }
-function optimizeNode(node) {
+const operators = {
+    "+": (left, right) => left + right,
+    "-": (left, right) => left - right,
+    "*": (left, right) => left * right,
+    "/": (left, right) => left / right,
+    "%": (left, right) => left % right,
+    "&": (left, right) => left & right,
+    "|": (left, right) => left | right,
+    "^": (left, right) => left ^ right,
+    "<<": (left, right) => left << (right & 127n),
+    ">>": (left, right) => left >> (right & 127n),
+    "==": (left, right) => 
+    // two string literals will compare unequal, becuase string
+    // equality is object equality.
+    typeof left === "string" ? false : left === right,
+    "!=": (left, right) => typeof left === "string" ? true : left !== right,
+    "<=": (left, right) => left <= right,
+    ">=": (left, right) => left >= right,
+    "<": (left, right) => left < right,
+    ">": (left, right) => left > right,
+    as: null,
+    instanceof: null,
+    has: null,
+};
+function optimizeNode(state, node) {
     switch (node.type) {
         case "UnaryExpression": {
             const [arg, type] = getNodeValue(node.argument);
@@ -1221,29 +3511,17 @@ function optimizeNode(node) {
                     break;
                 case "-":
                     if (type === "Number" || type === "Long") {
-                        return {
-                            ...arg,
-                            value: -arg.value,
-                            raw: (-arg.value).toString() + (type === "Long" ? "l" : ""),
-                        };
+                        return replacementLiteral(arg, -arg.value, type);
                     }
                     break;
                 case "!":
                 case "~":
                     {
-                        let value;
                         if (type === "Number" || type === "Long") {
-                            value = -arg.value - 1;
+                            return replacementLiteral(arg, ~BigInt(arg.value), type);
                         }
-                        else if (type === "Boolean" && node.operator == "!") {
-                            value = !arg.value;
-                        }
-                        if (value !== undefined) {
-                            return {
-                                ...arg,
-                                value,
-                                raw: value.toString() + (type === "Long" ? "l" : ""),
-                            };
+                        if (type === "Boolean" && node.operator == "!") {
+                            return replacementLiteral(arg, !arg.value, type);
                         }
                     }
                     break;
@@ -1251,56 +3529,81 @@ function optimizeNode(node) {
             break;
         }
         case "BinaryExpression": {
-            const operators = {
-                "+": (left, right) => left + right,
-                "-": (left, right) => left - right,
-                "*": (left, right) => left * right,
-                "/": (left, right) => Math.trunc(left / right),
-                "%": (left, right) => left % right,
-                "&": (left, right, type) => type === "Number" ? left & right : null,
-                "|": (left, right, type) => type === "Number" ? left | right : null,
-                "<<": (left, right, type) => type === "Number" ? left << right : null,
-                ">>": (left, right, type) => type === "Number" ? left >> right : null,
-            };
             const op = operators[node.operator];
             if (op) {
                 const [left, left_type] = getNodeValue(node.left);
                 const [right, right_type] = getNodeValue(node.right);
                 if (!left || !right)
                     break;
-                if (left_type != right_type ||
-                    (left_type != "Number" && left_type != "Long")) {
-                    break;
+                let value = null;
+                let type;
+                if ((left_type != "Number" && left_type != "Long") ||
+                    left_type != right_type) {
+                    if (node.operator !== "==" && node.operator !== "!=") {
+                        break;
+                    }
+                    value = operators[node.operator](left.value, right.value);
+                    type = "Boolean";
+                }
+                else {
+                    type = left_type;
+                    value = op(BigInt(left.value), BigInt(right.value));
                 }
-                const value = op(left.value, right.value, left_type);
                 if (value === null)
                     break;
-                return {
-                    ...left,
-                    value,
-                    raw: value.toString() + (left_type === "Long" ? "l" : ""),
-                };
+                return replacementLiteral(left, value, type);
+            }
+            break;
+        }
+        case "LogicalExpression": {
+            const [left, left_type] = getNodeValue(node.left);
+            if (!left)
+                break;
+            const falsy = left.value === false ||
+                left.value === null ||
+                ((left_type === "Number" || left_type === "Long") &&
+                    (left.value === 0 || left.value === 0n));
+            if (falsy === (node.operator === "&&")) {
+                return left;
+            }
+            if (left_type !== "Boolean" &&
+                left_type !== "Number" &&
+                left_type !== "Long") {
+                break;
+            }
+            const [right, right_type] = getNodeValue(node.right);
+            if (right && right_type === left_type) {
+                if (left_type === "Boolean" || node.operator === "||") {
+                    return right;
+                }
+                if (node.operator !== "&&") {
+                    throw new Error(`Unexpected operator "${node.operator}"`);
+                }
+                return { ...node, type: "BinaryExpression", operator: "&" };
+            }
+            if (left_type === "Boolean") {
+                if (isBooleanExpression(state, node.right)) {
+                    return node.right;
+                }
             }
             break;
         }
         case "FunctionDeclaration":
-            if (node.body && evaluateFunction(node, null) !== false) {
+            if (node.body && evaluateFunction(state, node, null) !== false) {
                 node.optimizable = true;
             }
             break;
     }
     return null;
 }
-function evaluateFunction(func, args) {
+function evaluateFunction(state, func, args) {
     if (!func.body || (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
-        ? JSON.parse(JSON.stringify(func.body))
-        : func.body;
+    const body = args ? cloneDeep(func.body) : func.body;
     try {
         traverseAst(body, (node) => {
             switch (node.type) {
@@ -1330,7 +3633,7 @@ function evaluateFunction(func, args) {
                         }
                     // fall through;
                     default: {
-                        const repl = optimizeNode(node);
+                        const repl = optimizeNode(state, node);
                         if (repl && repl.type === "Literal")
                             return repl;
                         throw new Error("Didn't optimize");
@@ -1351,12 +3654,10 @@ function markFunctionCalled(state, func) {
     pushUnique(state.calledFunctions[func.id.name], func);
 }
 async function optimizeMonkeyC(fnMap, barrelList, config) {
-    const state = {
-        ...(await analyze(fnMap, barrelList, config)),
-        localsStack: [{}],
-        exposed: {},
-        calledFunctions: {},
-    };
+    const state = (await analyze(fnMap, barrelList, config));
+    state.localsStack = [{}];
+    state.calledFunctions = {};
+    state.usedByName = {};
     const replace = (node, old) => {
         if (node === false || node === null)
             return node;
@@ -1390,10 +3691,19 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         if (!objects) {
             return false;
         }
-        const obj = getLiteralFromDecls(objects);
+        let obj = getLiteralFromDecls(objects);
         if (!obj) {
             return false;
         }
+        while (obj.type === "BinaryExpression") {
+            if (obj.left.type === "BinaryExpression" && obj.left.operator === "as") {
+                obj = { ...obj, left: obj.left.left };
+            }
+            else {
+                obj = { ...obj, left: { ...obj.left } };
+                break;
+            }
+        }
         inPlaceReplacement(node, obj);
         return true;
     };
@@ -1436,6 +3746,58 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     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;
+            }
+        }
+    };
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -1456,7 +3818,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         result = !!value.value;
                     }
                     if (result !== null) {
-                        node.test = { type: "Literal", value: result };
+                        node.test = {
+                            type: "Literal",
+                            value: result,
+                            raw: result.toString(),
+                        };
                         if (node.type === "IfStatement" ||
                             node.type === "ConditionalExpression") {
                             return [result ? "consequent" : "alternate"];
@@ -1475,7 +3841,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 return null;
             }
             case "EnumDeclaration":
-                return false;
+                return [];
             case "ForStatement": {
                 const map = topLocals().map;
                 if (map) {
@@ -1484,43 +3850,13 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             }
             case "VariableDeclarator": {
-                const locals = topLocals();
-                const { map } = locals;
-                if (map) {
-                    const declName = variableDeclarationName(node.id);
-                    const name = renameVariable(state, locals, declName);
-                    if (name) {
-                        if (node.id.type === "Identifier") {
-                            node.id.name = name;
-                        }
-                        else {
-                            node.id.left.name = name;
-                        }
-                    }
-                    else {
-                        map[declName] = true;
-                    }
-                }
+                renamer(node.id);
                 return ["init"];
             }
             case "CatchClause":
                 if (node.param) {
                     state.localsStack.push({ node, map: { ...(topLocals().map || {}) } });
-                    const locals = topLocals();
-                    const map = locals.map;
-                    const declName = variableDeclarationName(node.param);
-                    const name = renameVariable(state, locals, declName);
-                    if (name) {
-                        if (node.param.type === "Identifier") {
-                            node.param.name = name;
-                        }
-                        else {
-                            node.param.left.name = name;
-                        }
-                    }
-                    else {
-                        map[declName] = true;
-                    }
+                    renamer(node.param);
                     return ["body"];
                 }
                 break;
@@ -1536,14 +3872,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             case "UnaryExpression":
                 if (node.operator == ":") {
-                    // If we produce a Symbol, for a given name,
-                    // its possible that someone uses that symbol
-                    // indirectly, so we can't remove any enums or
-                    // constants with that name (we can still replace
-                    // uses of those constants though).
-                    state.exposed[node.argument.name] = true;
-                    // In any case, we can't replace *this* use of the
-                    // symbol with its value...
+                    // node.argument is not a normal identifier.
+                    // don't visit it.
                     return [];
                 }
                 break;
@@ -1555,29 +3885,73 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         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;
+                        }
                     }
                 }
                 if (hasProperty(state.index, node.name)) {
                     if (!lookupAndReplace(node)) {
-                        state.exposed[node.name] = true;
+                        state.usedByName[node.name] = true;
                     }
                 }
                 return [];
             }
-            case "MemberExpression":
-                if (node.property.type === "Identifier" && !node.computed) {
-                    if (hasProperty(state.index, node.property.name)) {
+            case "MemberExpression": {
+                const property = isLookupCandidate(node);
+                if (property) {
+                    if (hasProperty(state.index, property.name)) {
                         if (lookupAndReplace(node)) {
                             return false;
                         }
                         else {
-                            state.exposed[node.property.name] = true;
+                            state.usedByName[property.name] = true;
                         }
                     }
                     // Don't optimize the property.
                     return ["object"];
                 }
                 break;
+            }
+            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") {
+                    state.traverse(lhs.object);
+                    if (lhs.computed) {
+                        state.traverse(lhs.property);
+                    }
+                }
+                return node.type === "AssignmentExpression" ? ["right"] : [];
+            }
             case "BlockStatement": {
                 const map = topLocals().map;
                 if (map) {
@@ -1593,7 +3967,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 node.params &&
                     node.params.forEach((p) => (map[variableDeclarationName(p)] = true));
                 state.localsStack.push({ node, map });
-                const [parent] = state.stack.slice(-2);
+                const [parent, 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;
                 if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
                     let used = false;
                     if (node.id.name == "initialize") {
@@ -1611,14 +3989,33 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         return null;
     };
     state.post = (node) => {
-        if (topLocals().node === node) {
+        const locals = topLocals();
+        if (locals.node === node) {
             state.localsStack.pop();
         }
-        const opt = optimizeNode(node);
+        const opt = optimizeNode(state, node);
         if (opt) {
             return replace(opt, node);
         }
         switch (node.type) {
+            case "FunctionDeclaration":
+                if (!state.currentFunction) {
+                    throw new Error(`Finished function ${state.stack.slice(-1)[0].fullName}, but it was not marked current`);
+                }
+                state.currentFunction.info = state.currentFunction.next_info;
+                delete state.currentFunction.next_info;
+                delete state.currentFunction;
+                break;
+            case "BlockStatement":
+                if (node.body.length === 1 && node.body[0].type === "BlockStatement") {
+                    node.body.splice(0, 1, ...node.body[0].body);
+                }
+            // fall through
+            case "ForStatement":
+                if (locals.map) {
+                    cleanupUnusedVars(state, node);
+                }
+                break;
             case "ConditionalExpression":
             case "IfStatement":
                 if (node.test.type === "Literal" &&
@@ -1628,6 +4025,12 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         return false;
                     return replace(rep, rep);
                 }
+                else if (node.type === "IfStatement" &&
+                    node.alternate &&
+                    node.alternate.type === "BlockStatement" &&
+                    !node.alternate.body.length) {
+                    delete node.alternate;
+                }
                 break;
             case "WhileStatement":
                 if (node.test.type === "Literal" && node.test.value === false) {
@@ -1644,17 +4047,62 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.argument, node), node.argument);
                 }
                 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 replace(optimizeCall(state, node, null), node);
             }
-            case "AssignmentExpression":
-                if (node.operator === "=" &&
-                    node.left.type === "Identifier" &&
-                    node.right.type === "Identifier" &&
-                    node.left.name === node.right.name) {
-                    return { type: "Literal", value: null, raw: "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 && decl.init.type === "CallExpression") {
+                            const inlined = replace(optimizeCall(state, decl.init, decl), decl.init);
+                            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 replace(optimizeCall(state, node.expression, node), node.expression);
@@ -1686,6 +4134,32 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     }
                 }
                 break;
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+            // fall through;
+            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;
     };
@@ -1693,12 +4167,16 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         collectNamespaces(f.ast, state);
     });
     state.calledFunctions = {};
-    state.exposed = {};
+    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":
@@ -1708,7 +4186,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 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.exposed, name) &&
+                        !hasProperty(state.usedByName, name));
                 })) {
                     node.enumType = [
                         ...new Set(node.members.map((m) => {
@@ -1751,7 +4230,9 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             case "VariableDeclaration": {
                 node.declarations = node.declarations.filter((d) => {
                     const name = variableDeclarationName(d.id);
-                    return (!hasProperty(state.index, name) || hasProperty(state.exposed, name));
+                    return (!hasProperty(state.index, name) ||
+                        hasProperty(state.exposed, name) ||
+                        hasProperty(state.usedByName, name));
                 });
                 if (!node.declarations.length) {
                     return false;
@@ -1784,7 +4265,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         }
         return null;
     };
-    Object.values(fnMap).forEach((f) => {
+    Object.entries(fnMap).forEach(([name, f]) => {
         traverseAst(f.ast, undefined, (node) => {
             const ret = cleanup(node);
             if (ret === false) {
@@ -1792,16 +4273,15 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             }
             return ret;
         });
+        if (state.config && state.config.checkBuildPragmas) {
+            pragmaChecker(state, f.ast, state.diagnostics?.[name]);
+        }
     });
     return state.diagnostics;
 }
 function optimizeCall(state, node, context) {
     const [name, results] = state.lookupNonlocal(node.callee);
-    const callees = results &&
-        results
-            .map((r) => r.results)
-            .flat()
-            .filter((c) => c.type === "FunctionDeclaration");
+    const callees = results ? findCallees(results) : null;
     if (!callees || !callees.length) {
         const n = name ||
             ("name" in node.callee && node.callee.name) ||
@@ -1810,21 +4290,31 @@ function optimizeCall(state, node, context) {
                 "name" in node.callee.property &&
                 node.callee.property.name);
         if (n) {
-            state.exposed[n] = true;
+            if (hasProperty(state.allFunctions, n)) {
+                if (state.currentFunction) {
+                    recordCalledFuncs(state.currentFunction, state.allFunctions[n]);
+                }
+                state.allFunctions[n].forEach((fn) => markFunctionCalled(state, fn.node));
+            }
         }
-        else {
-            // There are unnamed CallExpressions, such as new [size]
-            // So there's nothing to do here.
+        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(callee, node.arguments);
+            const ret = evaluateFunction(state, callee, node.arguments);
             if (ret) {
                 return ret;
             }
@@ -1984,11 +4474,8 @@ async function api_getApiMapping(state, barrelList) {
         return null;
     }
 }
-function api_hasProperty(obj, prop) {
-    return obj ? Object.prototype.hasOwnProperty.call(obj, prop) : false;
-}
 function api_isStateNode(node) {
-    return api_hasProperty(node, "node");
+    return ast_hasProperty(node, "node");
 }
 function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
@@ -2008,7 +4495,7 @@ function checkOne(state, ns, decls, node, isStatic) {
         }
         return cls.superClass.reduce((result, sup) => {
             const sdecls = sup[decls];
-            const next = api_hasProperty(sdecls, node.name)
+            const next = ast_hasProperty(sdecls, node.name)
                 ? sdecls[node.name]
                 : superChain(sup);
             return next ? (result ? result.concat(next) : next) : result;
@@ -2031,20 +4518,18 @@ function checkOne(state, ns, decls, node, isStatic) {
             return next ? (result ? result.concat(next) : next) : result;
         }, null);
     };
-    if (api_isStateNode(ns)) {
-        const ndecls = ns[decls];
-        if (api_hasProperty(ndecls, node.name)) {
-            return ndecls[node.name];
-        }
-        switch (ns.type) {
-            case "ClassDeclaration":
-                if (!isStatic) {
-                    return superChain(ns) || superChainScopes(ns) || false;
-                }
-            // fall through
-            case "ModuleDeclaration":
-                return lookupInContext(ns) || false;
-        }
+    const ndecls = ns[decls];
+    if (ast_hasProperty(ndecls, node.name)) {
+        return ndecls[node.name];
+    }
+    switch (ns.type) {
+        case "ClassDeclaration":
+            if (!isStatic) {
+                return superChain(ns) || superChainScopes(ns) || false;
+            }
+        // fall through
+        case "ModuleDeclaration":
+            return lookupInContext(ns) || false;
     }
     return null;
 }
@@ -2067,6 +4552,13 @@ function sameLookupDefinition(a, b) {
 function api_sameLookupResult(a, b) {
     return (0,external_util_cjs_namespaceObject.sameArrays)(a, b, sameLookupDefinition);
 }
+function api_isLookupCandidate(node) {
+    return node.computed
+        ? node.property.type === "UnaryExpression" &&
+            node.property.operator === ":" &&
+            node.property.argument
+        : node.property.type === "Identifier" && node.property;
+}
 /**
  *
  * @param state    - The ProgramState
@@ -2087,9 +4579,9 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
     const stack = maybeStack || state.stack;
     switch (node.type) {
         case "MemberExpression": {
-            if (node.property.type != "Identifier" || node.computed)
+            const property = api_isLookupCandidate(node);
+            if (!property)
                 break;
-            const property = node.property;
             let result;
             if (node.object.type === "ThisExpression") {
                 [, result] = lookup(state, decls, node.property, name, stack, true);
@@ -2103,6 +4595,9 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                 result = results.reduce((current, lookupDef) => {
                     const items = lookupDef.results
                         .map((module) => {
+                        if (!api_isStateNode(module)) {
+                            return null;
+                        }
                         const res = checkOne(state, module, decls, property, false);
                         return res ? { parent: module, results: res } : null;
                     })
@@ -2187,6 +4682,8 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
 }
 function api_collectNamespaces(ast, stateIn) {
     const state = (stateIn || {});
+    if (!state.nextExposed)
+        state.nextExposed = {};
     if (!state.index)
         state.index = {};
     if (!state.stack) {
@@ -2222,7 +4719,7 @@ function api_collectNamespaces(ast, stateIn) {
     state.stackClone = () => state.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
         ? { ...elm }
         : elm);
-    state.inType = false;
+    state.inType = 0;
     state.traverse = (root) => ast_traverseAst(root, (node) => {
         try {
             if (state.shouldExclude && state.shouldExclude(node)) {
@@ -2230,6 +4727,13 @@ function api_collectNamespaces(ast, stateIn) {
                 return [];
             }
             switch (node.type) {
+                case "UnaryExpression":
+                    if (node.operator === ":" && !state.inType) {
+                        state.nextExposed[node.argument.name] = true;
+                    }
+                    break;
+                case "AttributeList":
+                    return [];
                 case "Program":
                     if (state.stack.length != 1) {
                         throw new Error("Unexpected stack length for Program node");
@@ -2238,7 +4742,7 @@ function api_collectNamespaces(ast, stateIn) {
                     break;
                 case "TypeSpecList":
                 case "TypeSpecPart":
-                    state.inType = true;
+                    state.inType++;
                     break;
                 case "ImportModule":
                 case "Using": {
@@ -2284,6 +4788,16 @@ function api_collectNamespaces(ast, stateIn) {
                         });
                     }
                     break;
+                case "ForStatement":
+                    if (node.init && node.init.type === "VariableDeclaration") {
+                        state.stack.push({
+                            type: "BlockStatement",
+                            fullName: undefined,
+                            name: undefined,
+                            node: node,
+                        });
+                    }
+                    break;
                 case "BlockStatement": {
                     const [parent] = state.stack.slice(-1);
                     if (parent.node === node ||
@@ -2313,7 +4827,7 @@ function api_collectNamespaces(ast, stateIn) {
                     if (name) {
                         if (!parent.decls)
                             parent.decls = {};
-                        if (api_hasProperty(parent.decls, name)) {
+                        if (ast_hasProperty(parent.decls, name)) {
                             const what = node.type == "ModuleDeclaration" ? "type" : "node";
                             const e = parent.decls[name].find((d) => api_isStateNode(d) && d[what] == elm[what]);
                             if (e != null) {
@@ -2339,7 +4853,7 @@ function api_collectNamespaces(ast, stateIn) {
                             elm.decls = { [name]: [elm] };
                             if (!parent.type_decls)
                                 parent.type_decls = {};
-                            if (!api_hasProperty(parent.type_decls, name)) {
+                            if (!ast_hasProperty(parent.type_decls, name)) {
                                 parent.type_decls[name] = [];
                             }
                             parent.type_decls[name].push(elm);
@@ -2350,20 +4864,22 @@ function api_collectNamespaces(ast, stateIn) {
                 // an EnumDeclaration doesn't create a scope, but
                 // it does create a type (if it has a name)
                 case "EnumDeclaration": {
-                    if (!node.id)
+                    if (!node.id) {
+                        state.inType++;
                         break;
+                    }
                     const [parent] = state.stack.slice(-1);
                     const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
                     node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
                 }
                 // fall through
                 case "TypedefDeclaration": {
-                    state.inType = true;
+                    state.inType++;
                     const name = node.id.name;
                     const [parent] = state.stack.slice(-1);
                     if (!parent.type_decls)
                         parent.type_decls = {};
-                    if (!api_hasProperty(parent.type_decls, name)) {
+                    if (!ast_hasProperty(parent.type_decls, name)) {
                         parent.type_decls[name] = [];
                     }
                     else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == node)) {
@@ -2387,7 +4903,7 @@ function api_collectNamespaces(ast, stateIn) {
                     const stack = state.stackClone();
                     node.declarations.forEach((decl) => {
                         const name = api_variableDeclarationName(decl.id);
-                        if (!api_hasProperty(decls, name)) {
+                        if (!ast_hasProperty(decls, name)) {
                             decls[name] = [];
                         }
                         else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
@@ -2402,7 +4918,7 @@ function api_collectNamespaces(ast, stateIn) {
                             stack,
                         });
                         if (node.kind == "const") {
-                            if (!api_hasProperty(state.index, name)) {
+                            if (!ast_hasProperty(state.index, name)) {
                                 state.index[name] = [];
                             }
                             (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
@@ -2411,13 +4927,21 @@ function api_collectNamespaces(ast, stateIn) {
                     break;
                 }
                 case "EnumStringBody": {
-                    state.inType = false;
+                    if (state.inType !== 1) {
+                        throw new Error(`Expected inType to be 1 at EnumStringBody. Got ${state.inType}.`);
+                    }
+                    state.inType--;
                     const [parent] = state.stack.slice(-1);
                     const values = parent.decls || (parent.decls = {});
                     let prev = -1;
                     node.members.forEach((m, i) => {
                         if (m.type == "Identifier") {
-                            prev += 1;
+                            if (typeof prev === "bigint") {
+                                prev += 1n;
+                            }
+                            else {
+                                prev += 1;
+                            }
                             m = node.members[i] = {
                                 type: "EnumStringMember",
                                 loc: m.loc,
@@ -2427,7 +4951,7 @@ function api_collectNamespaces(ast, stateIn) {
                                 init: {
                                     type: "Literal",
                                     value: prev,
-                                    raw: prev.toString(),
+                                    raw: prev.toString() + (typeof prev === "bigint" ? "l" : ""),
                                     enumType: m.enumType,
                                     loc: m.loc,
                                     start: m.start,
@@ -2448,11 +4972,11 @@ function api_collectNamespaces(ast, stateIn) {
                             prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
                             prev = init.value;
                         }
-                        if (!api_hasProperty(values, name)) {
+                        if (!ast_hasProperty(values, name)) {
                             values[name] = [];
                         }
                         (0,external_util_cjs_namespaceObject.pushUnique)(values[name], m);
-                        if (!api_hasProperty(state.index, name)) {
+                        if (!ast_hasProperty(state.index, name)) {
                             state.index[name] = [];
                         }
                         (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
@@ -2479,22 +5003,22 @@ function api_collectNamespaces(ast, stateIn) {
                 if (state.post)
                     ret = state.post(node, state);
                 switch (type) {
-                    // Don't clear inType for TypeSpecPart, since they
-                    // generally occur in TypeSpecLists. But do clear it for
-                    // SizedArrayExpression, since thats the only place they
-                    // happen on their own.
-                    case "SizedArrayExpression":
+                    case "TypeSpecPart":
                     case "TypeSpecList":
                     case "TypedefDeclaration":
                     case "EnumDeclaration":
-                        state.inType = false;
+                        state.inType--;
                         break;
                     case "EnumStringBody":
-                        state.inType = true;
+                        state.inType++;
                         break;
                 }
                 const [parent] = state.stack.slice(-1);
                 if (parent.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;
@@ -2513,6 +5037,9 @@ function api_collectNamespaces(ast, stateIn) {
         }
     });
     state.traverse(ast);
+    if (state.inType) {
+        throw new Error(`inType was non-zero on exit: ${state.inType}`);
+    }
     if (state.stack.length != 1) {
         throw new Error("Invalid AST!");
     }
@@ -2547,7 +5074,7 @@ function api_formatAst(node, monkeyCSource = null) {
     // json. The parser knows to just treat the last line of the input
     // as the ast itself, and the printers will find what they're
     // looking for in the source.
-    const source = (monkeyCSource || "") + "\n" + JSON.stringify(node);
+    const source = (monkeyCSource || "") + "\n" + (0,prettier_plugin_monkeyc_namespaceObject.serializeMonkeyC)(node);
     return external_prettier_namespaceObject.format(source, {
         parser: "monkeyc-json",
         plugins: [(prettier_plugin_monkeyc_default())],
@@ -2592,7 +5119,7 @@ function findUsing(state, stack, using) {
             find(node.object);
             name = node.property.name;
         }
-        if (api_hasProperty(module.decls, name)) {
+        if (ast_hasProperty(module.decls, name)) {
             const decls = module.decls[name];
             if (decls &&
                 decls.length === 1 &&
@@ -2615,7 +5142,7 @@ function findUsing(state, stack, using) {
 function findUsingForNode(state, stack, i, node, isType) {
     while (i >= 0) {
         const si = stack[i--];
-        if (api_hasProperty(si.usings, node.name)) {
+        if (ast_hasProperty(si.usings, node.name)) {
             const using = si.usings[node.name];
             const module = findUsing(state, stack, using);
             return module && [module];
@@ -2625,7 +5152,7 @@ function findUsingForNode(state, stack, i, node, isType) {
                 const using = si.imports[j];
                 const module = findUsing(state, stack, using);
                 if (module) {
-                    if (api_hasProperty(module.type_decls, node.name)) {
+                    if (ast_hasProperty(module.type_decls, node.name)) {
                         return module.type_decls[node.name];
                     }
                 }
@@ -2634,6 +5161,38 @@ function findUsingForNode(state, stack, i, node, isType) {
     }
     return null;
 }
+const invokeInfo = {};
+const toyboxFnInfo = {};
+function api_getApiFunctionInfo(func) {
+    if (func.fullName === "$.Toybox.Lang.Method.invoke" ||
+        (func.node.params &&
+            func.node.params.some((param) => param.type === "BinaryExpression" &&
+                param.right.ts.some((tsp) => tsp.type === "TypeSpecPart" && tsp.callspec)))) {
+        if (!invokeInfo.calledFuncs) {
+            invokeInfo.modifiedDecls = new Set();
+            invokeInfo.calledFuncs = new Set();
+            invokeInfo.callsExposed = true;
+        }
+        if (func.name === "initialize") {
+            const top = func.stack[func.stack.length - 1];
+            if (top.type === "ClassDeclaration") {
+                top.hasInvoke = true;
+            }
+        }
+        return invokeInfo;
+    }
+    if (!toyboxFnInfo.calledFuncs) {
+        toyboxFnInfo.modifiedDecls = new Set();
+        toyboxFnInfo.calledFuncs = new Set();
+        toyboxFnInfo.resolvedDecls = new Set();
+    }
+    return toyboxFnInfo;
+}
+function api_markInvokeClassMethod(func) {
+    func.info = invokeInfo;
+}
+
+})();
 
 var __webpack_export_target__ = exports;
 for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];