@markw65/monkeyc-optimizer 1.0.43 → 1.0.45

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLocal,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -265,6 +265,7 @@ __webpack_require__.d(__webpack_exports__, {
   "getApiFunctionInfo": () => (/* binding */ api_getApiFunctionInfo),
   "getApiMapping": () => (/* binding */ api_getApiMapping),
   "hasProperty": () => (/* reexport */ ast_hasProperty),
+  "isLocal": () => (/* binding */ api_isLocal),
   "isLookupCandidate": () => (/* binding */ api_isLookupCandidate),
   "isStateNode": () => (/* binding */ api_isStateNode),
   "markInvokeClassMethod": () => (/* binding */ api_markInvokeClassMethod),
@@ -524,13 +525,73 @@ function ast_getNodeValue(node) {
         return [node, "Long"];
     }
     if (type === "string") {
-        return [node, "String"];
+        return node.raw.startsWith("'")
+            ? [node, "Char"]
+            : [node, "String"];
     }
     if (type === "boolean") {
         return [node, "Boolean"];
     }
     throw new Error(`Literal has unknown type '${type}'`);
 }
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    const result = dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
+        }
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+    if (!result)
+        throw new Error("Failed to make a ScopedName");
+    return result;
+}
 
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
@@ -585,6 +646,8 @@ function function_info_recordCalledFuncs(func, callees) {
 }
 function function_info_functionMayModify(state, func, decl) {
     const info = func.info;
+    if (info === false)
+        return false;
     if (!info || info.modifiedUnknown)
         return true;
     if (info.resolvedDecls) {
@@ -597,7 +660,7 @@ function function_info_functionMayModify(state, func, decl) {
     const visited = new Set();
     const resolved = new Set();
     const resolveDecls = (f) => {
-        if (visited.has(f))
+        if (f.info === false || visited.has(f))
             return true;
         if (!f.info)
             return false;
@@ -659,6 +722,16 @@ function function_info_findCalleesForNew(lookupDefs) {
         .flatMap(initializer)
         .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
 }
+function function_info_findCalleesByNode(state, callee) {
+    const name = callee.type === "Identifier"
+        ? callee.name
+        : callee.type === "MemberExpression" && !callee.computed
+            ? callee.property.name
+            : null;
+    if (!name)
+        return null;
+    return ((hasProperty(state.allFunctions, name) && state.allFunctions[name]) || null);
+}
 
 ;// CONCATENATED MODULE: ./src/optimizer-types.ts
 var optimizer_types_StateNodeAttributes;
@@ -1622,13 +1695,17 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
         return re.test(haystack);
     };
     next();
     traverseAst(ast, (node) => {
-        if (index >= comments.length)
+        if (index >= comments.length ||
+            node.type === "Line" ||
+            node.type === "Block" ||
+            node.type === "MultiLine") {
             return false;
+        }
         if (node.start && node.start >= (comment.end || Infinity)) {
             const { kind, quote, needle } = matchers.shift();
             if (kind === "match") {
@@ -1776,7 +1853,7 @@ function control_flow_buildReducedGraph(state, func, notice) {
     try {
         const localState = new LocalState(func.node);
         const ret = localState.curBlock;
-        state.stack = func.stack;
+        state.stack = [...func.stack];
         const stmtStack = [func.node];
         let tryActive = 0;
         state.pre = (node) => {
@@ -1791,6 +1868,8 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 stmtStack.push(node);
             }
             switch (node.type) {
+                case "FunctionDeclaration":
+                    return ["body"];
                 case "AttributeList":
                     return [];
                 case "SwitchStatement": {
@@ -2007,11 +2086,6 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 }
                 case "VariableDeclarator":
                     return ["init"];
-                case "MemberExpression":
-                    if (!node.computed) {
-                        return ["object"];
-                    }
-                    break;
                 case "UnaryExpression":
                     if (node.operator === ":") {
                         return [];
@@ -2047,6 +2121,14 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 case "ContinueStatement":
                     localState.terminal(node.type);
                     return [];
+                case "CallExpression":
+                    if (node.callee.type === "Identifier") {
+                        const extra = state.stack.splice(func.stack.length);
+                        state.traverse(node.callee);
+                        state.stack.push(...extra);
+                        return ["arguments"];
+                    }
+                    break;
             }
             return null;
         };
@@ -2208,142 +2290,94 @@ function getPreOrder(head) {
 
 // EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
 var priorityqueuejs = __webpack_require__(2789);
-;// CONCATENATED MODULE: ./src/pre.ts
+;// CONCATENATED MODULE: ./src/data-flow.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) {
+
+function data_flow_declFullName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return decl.raw || decl.value?.toString() || "null";
+    }
+    if (isStateNode(decl))
+        return decl.fullName;
     switch (decl.type) {
-        case "Literal":
-            return decl.raw || decl.value?.toString() || "null";
-        case "VariableDeclarator":
-            return decl.fullName;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.init
+                ? `${decl.id.name}:${formatAst(decl.init)}`
+                : decl.id.name;
         default:
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
-function declName(decl) {
+function data_flow_declName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
+    }
+    if (isStateNode(decl))
+        return decl.name;
     switch (decl.type) {
-        case "Literal":
-            return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
-        case "VariableDeclarator":
-            return decl.name;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.id.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) {
+function data_flow_buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wantsAllRefs) {
+    const uniqueDeclMap = new Map();
     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];
-            }
+            const decls = (results &&
+                results.reduce((decls, result) => result.results.reduce((decls, result) => {
+                    if (!wantsAllRefs &&
+                        (result.type !== "VariableDeclarator" || isLocal(result))) {
+                        return decls;
+                    }
+                    if (!decls)
+                        return result;
+                    if (Array.isArray(decls)) {
+                        decls.push(result);
+                        return decls;
+                    }
+                    else {
+                        return [decls, result];
+                    }
+                }, decls), null)) ||
+                null;
+            if (!Array.isArray(decls))
+                return decls;
+            // We use EventDecl as a Map key, so we need to
+            // uniquify it. Note that from any given function,
+            // if state.lookup finds a set of non locals, it will
+            // always find the same set, so we can use the first
+            // such as the unique identifier.
+            const canon = uniqueDeclMap.get(decls[0]);
+            if (!canon) {
+                uniqueDeclMap.set(decls[0], decls);
+                return decls;
+            }
+            if (canon.length != decls.length ||
+                !canon.every((v, i) => v === decls[i])) {
+                throw new Error(`Canonical representation of ${data_flow_declFullName(canon)} did not match`);
+            }
+            return canon;
         }
         return null;
     };
@@ -2351,18 +2385,22 @@ function buildPREGraph(state, func) {
     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()));
+    const liveDef = trackInsertionPoints
+        ? (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);
         }
-        defs.set(def, (defs.get(def) || 0) + 1);
-    };
+        : () => {
+            /* do nothing */
+        };
     return {
         identifiers,
         graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
@@ -2376,7 +2414,7 @@ function buildPREGraph(state, func) {
                     }
                     const v = liveDefs.get(def);
                     if (!v || !v.has(node)) {
-                        throw new Error(`No stmt in liveDef for ${def ? declFullName(def) : "null"}`);
+                        throw new Error(`No stmt in liveDef for ${def ? data_flow_declFullName(def) : "null"}`);
                     }
                     v.delete(node);
                     if (!v.size) {
@@ -2397,7 +2435,7 @@ function buildPREGraph(state, func) {
                 case "ParenthesizedExpression":
                     break;
                 case "Literal":
-                    if (refCost(node) > LocalRefCost) {
+                    if (wantsLiteral(node)) {
                         const result = getNodeValue(node);
                         const key = result[1] +
                             (result[0].value === null
@@ -2419,34 +2457,40 @@ function buildPREGraph(state, func) {
                 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;
-                              */
+                case "MemberExpression": {
+                    const decls = findDecl(node);
+                    if (!decls)
+                        break;
+                    if (trackInsertionPoints &&
+                        some(decls, (decl) => {
+                            if (decl.type === "VariableDeclarator") {
+                                const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
+                                    liveDefs.get(decl);
+                                if (defStmts) {
+                                    return true;
+                                    /*
+                                      // 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,
-                            };
-                        }
+                            return false;
+                        })) {
+                        break;
                     }
-                    break;
+                    return {
+                        type: "ref",
+                        node,
+                        decl: decls,
+                        mayThrow,
+                    };
+                }
                 case "VariableDeclarator": {
                     const decl = findDecl(node.id.type === "BinaryExpression" ? node.id.left : node.id);
                     if (decl) {
@@ -2494,8 +2538,10 @@ function buildPREGraph(state, func) {
                 }
                 case "CallExpression": {
                     liveDef(null, stmt);
-                    const [, results] = state.lookup(node.callee);
-                    const callees = results ? findCallees(results) : null;
+                    const [, results] = state.lookupNonlocal(node.callee);
+                    const callees = results
+                        ? findCallees(results)
+                        : findCalleesByNode(state, node.callee);
                     return { type: "mod", node, mayThrow, callees };
                 }
                 default:
@@ -2510,67 +2556,193 @@ function buildPREGraph(state, func) {
         }),
     };
 }
-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;
+class data_flow_DataflowQueue {
+    constructor() {
+        this.enqueued = new Set();
+        this.queue = new PriorityQueue((b, a) => (a.order || 0) - (b.order || 0));
     }
-    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));
+    enqueue(block) {
+        if (!this.enqueued.has(block)) {
+            this.enqueued.add(block);
+            this.queue.enq(block);
         }
     }
-    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));
-        }
+    dequeue() {
+        const block = this.queue.deq();
+        this.enqueued.delete(block);
+        return block;
+    }
+    empty() {
+        return this.queue.isEmpty();
     }
 }
-function equalStates(a, b) {
+
+;// 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 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 buildPREGraph(state, func) {
+    return buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+}
+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) {
@@ -2665,26 +2837,18 @@ function computeAttributes(state, head) {
                 .join(", ")}`);
             if (block.events) {
                 block.events.forEach((event) => event.type !== "exn" &&
-                    console.log(`    ${event.type}: ${event.decl ? declFullName(event.decl) : "??"}`));
+                    console.log(`    ${event.type}: ${event.decl
+                        ? declFullName(event.decl)
+                        : event.node
+                            ? formatAst(event.node)
+                            : "??"}`));
             }
             console.log(`Succs: ${(block.succs || [])
                 .map((block) => block.order)
                 .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
         });
     }
-    const 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 queue = new DataflowQueue();
     const blockStates = [];
     /*
       Algorithm
@@ -2718,9 +2882,9 @@ function computeAttributes(state, head) {
         }
         return result;
     };
-    order.forEach((block) => enqueue(block));
-    while (queue.size()) {
-        const top = dequeue();
+    order.forEach((block) => queue.enqueue(block));
+    while (!queue.empty()) {
+        const top = queue.dequeue();
         if (top.order === undefined) {
             throw new Error(`Unreachable block was visited!`);
         }
@@ -2759,13 +2923,13 @@ function computeAttributes(state, head) {
                         break;
                     }
                     case "mod": {
-                        curState.forEach((candidates, decl) => {
-                            if (decl.type === "VariableDeclarator" &&
+                        curState.forEach((candidates, decls) => {
+                            if (some(decls, (decl) => decl.type === "VariableDeclarator" &&
                                 decl.node.kind === "var" &&
                                 candidates.live &&
                                 (!event.callees ||
-                                    event.callees.some((callee) => functionMayModify(state, callee, decl)))) {
-                                candidates.ant.add(getMod(event, decl, candidates.node));
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl))))) {
+                                candidates.ant.add(getMod(event, decls, candidates.node));
                                 candidates.live = false;
                             }
                         });
@@ -2817,7 +2981,7 @@ function computeAttributes(state, head) {
             logAntDecls(curState);
         }
         if (top.preds) {
-            top.preds.forEach((pred) => enqueue(pred));
+            top.preds.forEach((pred) => queue.enqueue(pred));
         }
     }
     const candidateDecls = anticipatedDecls();
@@ -3572,7 +3736,7 @@ function getLiteralNode(node) {
             case "-": {
                 const [arg, type] = ast_getNodeValue(node.argument);
                 if (type === "Number" || type === "Long") {
-                    return replacementLiteral(arg, -arg.value, type);
+                    return replacementLiteral(node, -arg.value, type);
                 }
             }
         }
@@ -3622,8 +3786,14 @@ function isBooleanExpression(state, node) {
     }
     return false;
 }
+function roundToFloat(value) {
+    return new Float32Array([value])[0];
+}
 function replacementLiteral(arg, value, type) {
-    if (typeof value === "boolean") {
+    if (value === null) {
+        type = "Null";
+    }
+    else if (typeof value === "boolean") {
         type = "Boolean";
     }
     else if (type === "Number") {
@@ -3632,32 +3802,213 @@ function replacementLiteral(arg, value, type) {
     else if (type === "Long") {
         value = BigInt.asIntN(64, BigInt(value));
     }
+    else if (type === "Float") {
+        value = roundToFloat(Number(value));
+    }
+    let raw = type === "String"
+        ? JSON.stringify(value)
+        : type === "Char"
+            ? value === "'"
+                ? "'\\''"
+                : "'" + JSON.stringify(value).slice(1, -1) + "'"
+            : value == null
+                ? "null"
+                : value.toString();
+    if (type === "Long") {
+        raw += "l";
+    }
+    else if (type === "Double") {
+        raw += "d";
+    }
+    else if (type === "Float") {
+        if (prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
+            raw += "f";
+        }
+        else {
+            const match = raw.match(/^(-)?(\d*)\.(\d+)(e\d+)?/);
+            if (match && match[2].length + match[3].length > 9) {
+                for (let l = 9 - match[2].length; l > 0; l--) {
+                    const s = `${match[1] || ""}${match[2]}.${match[3].substring(0, l)}${match[4] || ""}`;
+                    if (value !== roundToFloat(parseFloat(s)))
+                        break;
+                    raw = s;
+                }
+            }
+        }
+    }
+    const { start, end, loc } = arg;
     return {
-        ...arg,
+        type: "Literal",
         value,
-        raw: value.toString() + (type === "Long" ? "l" : ""),
+        raw,
+        start,
+        end,
+        loc,
     };
 }
+function classify(arg) {
+    switch (arg) {
+        case "Number":
+            return { big: false, int: true };
+        case "Long":
+            return { big: true, int: true };
+        case "Float":
+            return { big: false, int: false };
+        case "Double":
+            return { big: true, int: false };
+    }
+    return null;
+}
+function common_arith_types(left, right) {
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (l.big || r.big) {
+        return l.int && r.int
+            ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+            : ["Double", (v) => Number(v)];
+    }
+    else {
+        return l.int && r.int
+            ? ["Number", (v) => BigInt.asIntN(32, BigInt(v))]
+            : ["Float", (v) => roundToFloat(Number(v))];
+    }
+}
+function common_bitwise_types(left, right) {
+    if (left === "Boolean" && right === "Boolean") {
+        return ["Boolean", (v) => (v ? true : false)];
+    }
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (!l.int || !r.int)
+        return null;
+    return l.big || r.big
+        ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+        : ["Number", (v) => Number(BigInt.asIntN(32, BigInt(v)))];
+}
+function plus_types(left, right) {
+    if (left === "String" || right === "String") {
+        // Boolean + String is an error, and
+        // Float/Double + String is legal, but its hard to predict
+        // the way the float will be formatted (and it won't match
+        // what javascript would do by default)
+        if (/Float|Double|Boolean/.test(left + right)) {
+            return null;
+        }
+        return ["String", String];
+    }
+    if (left === "Char" || right === "Char") {
+        if (left === right) {
+            // adding two chars produces a string
+            return ["String", String];
+        }
+        if (/Number|Long/.test(left + right)) {
+            return ["Char", (v) => v];
+        }
+    }
+    return common_arith_types(left, right);
+}
+function shift_mod_types(left, right) {
+    const result = common_bitwise_types(left, right);
+    if (result && result[0] === "Boolean") {
+        return null;
+    }
+    return result;
+}
+function equalsFn(left, right) {
+    const lt = typeof left;
+    const rt = typeof right;
+    return lt === "string" || rt === "string"
+        ? // two string literals will compare unequal, becuase string
+            // equality is object equality.
+            false
+        : (lt === "number" || lt === "bigint") &&
+            (rt === "number" || rt === "bigint")
+            ? // numeric types are compared for value equality
+                left == right
+            : // otherwise types and values must match
+                left === right;
+}
 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,
+    "+": {
+        typeFn: plus_types,
+        valueFn: (left, right) => typeof left === "string" && typeof right !== "string"
+            ? String.fromCharCode(left.charCodeAt(0) + Number(right))
+            : typeof left !== "string" && typeof right === "string"
+                ? String.fromCharCode(right.charCodeAt(0) + Number(left))
+                : left + right,
+    },
+    "-": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left - right,
+    },
+    "*": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left * right,
+    },
+    "/": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left / right,
+    },
+    "%": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => left % right,
+    },
+    "&": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left & right,
+    },
+    "|": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left | right,
+    },
+    "^": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left ^ right,
+    },
+    "<<": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left << right
+            : left << right,
+    },
+    ">>": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left >> right
+            : left >> right,
+    },
+    "==": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: equalsFn,
+    },
+    "!=": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: (left, right) => !equalsFn(left, right),
+    },
+    "<=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left <= right,
+    },
+    ">=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left >= right,
+    },
+    "<": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left < right,
+    },
+    ">": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left > right,
+    },
     as: null,
     instanceof: null,
     has: null,
@@ -3670,23 +4021,31 @@ function optimizeNode(state, node) {
                 break;
             switch (node.operator) {
                 case "+":
-                    if (type === "Number" || type === "Long") {
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double" ||
+                        type === "Char" ||
+                        type === "String") {
                         return arg;
                     }
                     break;
                 case "-":
-                    if (type === "Number" || type === "Long") {
-                        return replacementLiteral(arg, -arg.value, type);
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double") {
+                        return replacementLiteral(node, -arg.value, type);
                     }
                     break;
                 case "!":
                 case "~":
                     {
                         if (type === "Number" || type === "Long") {
-                            return replacementLiteral(arg, ~BigInt(arg.value), type);
+                            return replacementLiteral(node, ~BigInt(arg.value), type);
                         }
                         if (type === "Boolean" && node.operator == "!") {
-                            return replacementLiteral(arg, !arg.value, type);
+                            return replacementLiteral(node, !arg.value, type);
                         }
                     }
                     break;
@@ -3700,23 +4059,13 @@ function optimizeNode(state, node) {
                 const [right, right_type] = getNodeValue(node.right);
                 if (!left || !right)
                     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 type = op.typeFn(left_type, right_type);
+                if (!type)
+                    break;
+                const value = op.valueFn(type[1](left.value), type[1](right.value));
                 if (value === null)
                     break;
-                return replacementLiteral(left, value, type);
+                return replacementLiteral(node, value, type[0]);
             }
             break;
         }
@@ -4169,7 +4518,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 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;
+                state.currentFunction.info = state.currentFunction.next_info || false;
                 delete state.currentFunction.next_info;
                 delete state.currentFunction;
                 break;
@@ -4607,6 +4956,8 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 ;// CONCATENATED MODULE: ./src/resources.ts
 
 
+
+
 /*
  * This is unavoidably ad-hoc. Garmin has arbitrary rules for how
  * resources can be nested, which we need to mimic here.
@@ -4759,7 +5110,7 @@ function visit_resources(elements, parent, v) {
             visitor.post(e);
     });
 }
-function add_resources_to_ast(ast, resources, manifestXML) {
+function add_resources_to_ast(state, ast, resources, manifestXML) {
     const modules = {
         Drawables: true,
         Fonts: true,
@@ -4801,7 +5152,7 @@ function add_resources_to_ast(ast, resources, manifestXML) {
             manifestXML.body instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Nodes) {
             manifestXML.body
                 .children("iq:application")
-                .elements.forEach((e) => add_one_resource(rez, e));
+                .elements.forEach((e) => add_one_resource(state, manifestXML, rez, e));
         }
         const rezModules = Object.fromEntries(Object.entries(modules).map(([moduleName, isPublic]) => {
             const module = makeModule(moduleName);
@@ -4817,110 +5168,152 @@ function add_resources_to_ast(ast, resources, manifestXML) {
                 if (!ast_hasProperty(rezModules, s))
                     return;
                 const module = rezModules[s];
-                add_one_resource(module, e);
+                add_one_resource(state, rez, module, e);
             });
         });
     });
 }
-function makeIdentifier(name, loc) {
-    return wrap({ type: "Identifier", name }, loc);
-}
-function makeMemberExpression(object, property) {
-    return wrap({
-        type: "MemberExpression",
-        object,
-        property,
-        computed: false,
-    }, object.loc && locRange(object.loc, property.loc));
+const drawableSkips = {
+    x: { center: true, left: true, right: true, start: true },
+    y: { center: true, top: true, bottom: true, start: true },
+    width: { fill: true },
+    height: { fill: true },
+    a: { fill: true },
+    b: { fill: true },
+    color: {},
+    corner_radius: {},
+    radius: {},
+    border_width: {},
+    border_color: {},
+    foreground: {},
+    background: {},
+    font: {},
+    justification: {},
+};
+function addPositions(base, pos) {
+    const result = { ...base };
+    if (pos.line > 1) {
+        result.line += pos.line - 1;
+        result.column = pos.column;
+    }
+    else {
+        result.column += pos.column - 1;
+    }
+    result.offset += pos.offset;
+    return result;
 }
-function makeScopedName(dotted, l) {
-    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
-    return dotted.split(".").reduce(({ cur, offset }, next) => {
-        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
-        if (!cur) {
-            cur = id;
+function visit_resource_refs(state, doc, e) {
+    const result = [];
+    const parseArg = (name, loc, skip) => {
+        if (name.startsWith("@")) {
+            name = name.substring(1);
+            loc = adjustLoc(loc, 1, 0);
         }
-        else {
-            cur = makeMemberExpression(cur, id);
+        if (ast_hasProperty(skip, name)) {
+            return;
         }
-        offset += next.length + 1;
-        return { cur, offset };
-    }, { cur: null, offset: 0 }).cur;
-}
-function visit_resource_refs(e) {
-    const result = [];
-    const stringToScopedName = (element, id, dotted, l) => {
-        const match = dotted.match(/^(@)?([\w_$]+\s*\.\s*)*[\w_$]+$/);
-        if (!match)
+        if (/^([-\w_$]+\s*\.\s*)*[-\w_$]+$/.test(name)) {
+            result.push(makeScopedName(name, loc));
             return;
-        let offset = 0;
-        if (match[1]) {
-            offset = 1;
         }
-        else if ((element === "drawable" && id === "class") ||
-            (element === "iq:application" && id === "entry")) {
-            // nothing to do
+        // We wrap the expression in parentheses, so adjust
+        // the start position by 1 character to compensate
+        // for the opening '('
+        const startPos = adjustLoc(loc, -1, 0).start;
+        try {
+            const expr = prettier_plugin_monkeyc_default().parsers.monkeyc.parse(`(${name})`, null, {
+                filepath: loc.source || undefined,
+                singleExpression: true,
+            });
+            ast_traverseAst(expr, (node) => {
+                if (node.loc) {
+                    node.loc = {
+                        source: node.loc.source,
+                        start: addPositions(startPos, node.loc.start),
+                        end: addPositions(startPos, node.loc.end),
+                    };
+                    node.start = (node.start || 0) + startPos.offset;
+                    node.end = (node.end || 0) + startPos.offset;
+                }
+            });
+            result.push(expr);
         }
-        else {
-            return;
+        catch (ex) {
+            if (state) {
+                const check = state.config?.checkInvalidSymbols;
+                if (check !== "OFF" && ex instanceof Error) {
+                    const error = ex;
+                    if (error.location) {
+                        const location = {
+                            source: error.location.source,
+                            start: addPositions(startPos, error.location.start),
+                            end: addPositions(startPos, error.location.end),
+                        };
+                        inliner_diagnostic(state, location, ex.message, check || "WARNING");
+                    }
+                }
+            }
         }
-        const dn = makeScopedName(dotted.substring(offset), adjustLoc(l, offset, 0));
-        if (dn)
-            result.push(dn);
     };
-    visit_resources([e], null, {
-        pre(node) {
-            if (node.type === "element") {
-                Object.values(node.attr).forEach((attr) => {
-                    if (!attr || !attr.value.loc)
-                        return;
-                    const loc = adjustLoc(attr.value.loc);
-                    attr &&
-                        stringToScopedName(node.name, attr.name.value, attr.value.value, loc);
-                });
-                if (node.children &&
-                    node.children.length === 1 &&
-                    node.children[0].type === "chardata") {
-                    stringToScopedName(node.name, null, node.children[0].value, node.children[0].loc);
+    const stringToScopedName = (element, id, dotted, l) => {
+        dotted = doc.processRefs(dotted);
+        if (dotted.startsWith("@")) {
+            return parseArg(dotted, l);
+        }
+        if (/^\s*(true|false|null|NaN|(0x|#)[0-9a-f]+|[-+]?\d+%?)\s*$/i.test(dotted)) {
+            return;
+        }
+        switch (element.name) {
+            case "param":
+                if (id === null) {
+                    parseArg(dotted, l);
+                }
+                return;
+            case "drawable":
+                if (id === "class") {
+                    parseArg(dotted, l);
+                }
+                return;
+            case "shape":
+            case "bitmap":
+            case "drawable-list":
+            case "text-area":
+            case "label":
+                if (id && ast_hasProperty(drawableSkips, id)) {
+                    parseArg(dotted, l, drawableSkips[id]);
+                }
+                return;
+            case "iq:application":
+                if (id === "entry") {
+                    parseArg(dotted, l);
                 }
                 return;
+            default:
+                return;
+        }
+    };
+    external_sdk_util_cjs_namespaceObject.xmlUtil.visit_xml([e], {
+        pre(node) {
+            if (node.type !== "element")
+                return false;
+            Object.values(node.attr).forEach((attr) => {
+                if (!attr || !attr.value.loc)
+                    return;
+                const loc = adjustLoc(attr.value.loc);
+                attr &&
+                    stringToScopedName(node, attr.name.value, attr.value.value, loc);
+            });
+            const content = doc.textContent(node);
+            if (content) {
+                stringToScopedName(node, null, content, locRange(node.children[0].loc, node.children[node.children.length - 1].loc));
+                return false;
             }
+            return;
         },
     });
     return result;
 }
-function wrap(node, loc) {
-    if (loc) {
-        node.loc = loc;
-        node.start = loc.start.offset;
-        node.end = loc.end.offset;
-    }
-    return node;
-}
-function locRange(start, end) {
-    return {
-        source: start.source || end.source,
-        start: start.start,
-        end: end.end,
-    };
-}
-function adjustLoc(loc, start = 1, end = -1) {
-    /* Attributes are quoted, so skip the quotes */
-    return {
-        source: loc.source,
-        start: {
-            offset: loc.start.offset + start,
-            line: loc.start.line,
-            column: loc.start.column + start,
-        },
-        end: {
-            offset: loc.end.offset + end,
-            line: loc.end.line,
-            column: loc.end.column + end,
-        },
-    };
-}
-function add_one_resource(module, e) {
+function add_one_resource(state, doc, module, e) {
     let id;
     let func;
     const varDecl = () => {
@@ -4931,26 +5324,92 @@ function add_one_resource(module, e) {
                 wrap({
                     type: "VariableDeclarator",
                     kind: "var",
-                    id: makeIdentifier(id ? id.value.value : "*invalid*", loc),
+                    id: {
+                        type: "BinaryExpression",
+                        operator: "as",
+                        left: makeIdentifier(id ? id.value.value : "*invalid*", loc),
+                        right: {
+                            type: "TypeSpecList",
+                            ts: [
+                                {
+                                    type: "TypeSpecPart",
+                                    name: makeIdentifier("Symbol"),
+                                },
+                            ],
+                        },
+                    },
                     init,
-                }, loc),
+                }, e.loc),
             ],
             kind: "var",
-        }, loc);
+        }, e.loc);
     };
     const classDecl = (parent) => {
         if (!id)
             return null;
         const loc = id.value.loc;
         const items = init
-            ? [{ type: "ClassElement", item: varDecl(), loc }]
+            ? [{ type: "ClassElement", item: varDecl(), loc: e.loc }]
             : [];
         return {
             type: "ClassDeclaration",
-            body: { type: "ClassBody", body: items, loc },
+            body: { type: "ClassBody", body: items, loc: e.loc },
             id: makeIdentifier(id.value.value, loc),
             superClass: makeScopedName(parent),
-            loc,
+            loc: e.loc,
+        };
+    };
+    const layoutDecl = () => {
+        if (!id)
+            return null;
+        const loc = id.value.loc;
+        const items = init ? [varDecl()] : [];
+        return {
+            type: "FunctionDeclaration",
+            body: { type: "BlockStatement", body: items, loc: e.loc },
+            id: makeIdentifier(id.value.value, loc),
+            params: [
+                {
+                    type: "BinaryExpression",
+                    operator: "as",
+                    left: makeIdentifier("dc"),
+                    right: {
+                        type: "TypeSpecList",
+                        ts: [
+                            {
+                                type: "TypeSpecPart",
+                                name: makeScopedName("Graphics.Dc"),
+                            },
+                        ],
+                    },
+                },
+            ],
+            returnType: {
+                type: "UnaryExpression",
+                operator: " as",
+                prefix: true,
+                argument: {
+                    type: "TypeSpecList",
+                    ts: [
+                        {
+                            type: "TypeSpecPart",
+                            name: makeScopedName("$.Toybox.Lang.Array"),
+                            generics: [
+                                {
+                                    type: "TypeSpecList",
+                                    ts: [
+                                        {
+                                            type: "TypeSpecPart",
+                                            name: makeScopedName("$.Toybox.WatchUi.Drawable"),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+            loc: e.loc,
         };
     };
     switch (e.name) {
@@ -4959,13 +5418,16 @@ function add_one_resource(module, e) {
         case "jsonData":
         case "animation":
         case "bitmap":
-        case "layout":
         case "drawable-list":
         case "property":
         case "fitField":
             id = e.attr.id;
             func = varDecl;
             break;
+        case "layout":
+            id = e.attr.id;
+            func = layoutDecl;
+            break;
         case "menu":
             id = e.attr.id;
             func = () => classDecl("Ui.Menu");
@@ -4992,7 +5454,7 @@ function add_one_resource(module, e) {
     }
     if (!func)
         return;
-    const elements = visit_resource_refs(e);
+    const elements = visit_resource_refs(state, doc, e);
     const init = elements.length
         ? { type: "ArrayExpression", elements }
         : undefined;
@@ -5228,7 +5690,7 @@ async function api_getApiMapping(state, resourcesMap, manifestXML) {
             const rezAst = state
                 ? state.rezAst || { type: "Program", body: [] }
                 : ast;
-            add_resources_to_ast(rezAst, resourcesMap, manifestXML);
+            add_resources_to_ast(state, rezAst, resourcesMap, manifestXML);
             if (state) {
                 state.rezAst = rezAst;
                 state.manifestXML = manifestXML;
@@ -5555,387 +6017,423 @@ function lookup(state, decls, node, name, maybeStack, nonlocal, ignoreImports) {
     }
     return [false, false];
 }
-function api_collectNamespaces(ast, stateIn) {
-    const state = (stateIn || {});
-    if (!state.nextExposed)
-        state.nextExposed = {};
-    if (!state.index)
-        state.index = {};
-    if (!state.stack) {
-        state.stack = [
-            {
-                type: "Program",
-                name: "$",
-                fullName: "$",
-                node: undefined,
-                attributes: 0,
-            },
-        ];
-    }
-    if (!state.lookupRules) {
-        const rules = state?.config?.compilerLookupRules || "DEFAULT";
-        if (rules !== "COMPILER1" && rules !== "COMPILER2") {
-            const match = state.sdk?.match(/-(\d+\.\d+\.\d+).(compiler2beta)?/i);
-            if (match && (match[2] || parseSdkVersion(match[1]) >= 4001006)) {
-                state.lookupRules = "COMPILER2";
-            }
-            else {
-                state.lookupRules = "COMPILER1";
-            }
-        }
-    }
-    state.removeNodeComments = (node, ast) => {
-        if (node.start && node.end && ast.comments && ast.comments.length) {
-            let low = 0, high = ast.comments.length;
-            while (high > low) {
-                const mid = (low + high) >> 1;
-                if ((ast.comments[mid].start || 0) < node.start) {
-                    low = mid + 1;
+function stateFuncs() {
+    let currentEnum = null;
+    return {
+        removeNodeComments(node, ast) {
+            if (node.start && node.end && ast.comments && ast.comments.length) {
+                let low = 0, high = ast.comments.length;
+                while (high > low) {
+                    const mid = (low + high) >> 1;
+                    if ((ast.comments[mid].start || 0) < node.start) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
                 }
-                else {
-                    high = mid;
+                while (high < ast.comments.length &&
+                    (ast.comments[high].end || 0) < node.end) {
+                    high++;
+                }
+                if (high > low) {
+                    ast.comments.splice(low, high - low);
                 }
             }
-            while (high < ast.comments.length &&
-                (ast.comments[high].end || 0) < node.end) {
-                high++;
-            }
-            if (high > low) {
-                ast.comments.splice(low, high - low);
-            }
-        }
-    };
-    state.lookup = (node, name, stack) => lookup(state, state.inType ? "type_decls" : "decls", node, name, stack);
-    state.lookupNonlocal = (node, name, stack) => lookup(state, "decls", node, name, stack, true);
-    state.lookupValue = (node, name, stack) => lookup(state, "decls", node, name, stack);
-    state.lookupType = (node, name, stack) => lookup(state, "type_decls", node, name, stack);
-    state.stackClone = () => state.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
-        ? { ...elm }
-        : elm);
-    state.inType = 0;
-    state.traverse = (root) => ast_traverseAst(root, (node) => {
-        try {
-            if (state.shouldExclude && state.shouldExclude(node)) {
-                // don't visit any children, but do call post
-                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");
+        },
+        lookup(node, name, stack) {
+            return lookup(this, this.inType ? "type_decls" : "decls", node, name, stack);
+        },
+        lookupNonlocal(node, name, stack) {
+            return lookup(this, "decls", node, name, stack, true);
+        },
+        lookupValue(node, name, stack) {
+            return lookup(this, "decls", node, name, stack);
+        },
+        lookupType(node, name, stack) {
+            return lookup(this, "type_decls", node, name, stack);
+        },
+        stackClone() {
+            return this.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
+                ? { ...elm }
+                : elm);
+        },
+        traverse(root) {
+            return ast_traverseAst(root, (node) => {
+                try {
+                    if (this.shouldExclude && this.shouldExclude(node)) {
+                        // don't visit any children, but do call post
+                        return [];
                     }
-                    state.stack[0].node = node;
-                    break;
-                case "TypeSpecList":
-                case "TypeSpecPart":
-                    state.inType++;
-                    break;
-                case "ImportModule":
-                case "Using": {
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.usings) {
-                        parent.usings = {};
-                    }
-                    const name = (node.type === "Using" && node.as && node.as.name) ||
-                        (node.id.type === "Identifier"
-                            ? node.id.name
-                            : node.id.property.name);
-                    const using = { node };
-                    parent.usings[name] = using;
-                    if (node.type == "ImportModule") {
-                        if (!parent.imports) {
-                            parent.imports = [using];
+                    switch (node.type) {
+                        case "MemberExpression": {
+                            if (api_isLookupCandidate(node)) {
+                                return (this.pre && this.pre(node, this)) || ["object"];
+                            }
+                            break;
                         }
-                        else {
-                            const index = parent.imports.findIndex((using) => (using.node.id.type === "Identifier"
-                                ? using.node.id.name
-                                : using.node.id.property.name) === name);
-                            if (index >= 0)
-                                parent.imports.splice(index, 1);
-                            parent.imports.push(using);
+                        case "UnaryExpression":
+                            if (node.operator === ":" && !this.inType) {
+                                this.nextExposed[node.argument.name] = true;
+                            }
+                            break;
+                        case "AttributeList":
+                            return [];
+                        case "Program":
+                            if (this.stack.length != 1) {
+                                throw new Error("Unexpected stack length for Program node");
+                            }
+                            this.stack[0].node = node;
+                            break;
+                        case "TypeSpecList":
+                        case "TypeSpecPart":
+                            this.inType++;
+                            break;
+                        case "ImportModule":
+                        case "Using": {
+                            const [parent] = this.stack.slice(-1);
+                            if (!parent.usings) {
+                                parent.usings = {};
+                            }
+                            const name = (node.type === "Using" && node.as && node.as.name) ||
+                                (node.id.type === "Identifier"
+                                    ? node.id.name
+                                    : node.id.property.name);
+                            const using = { node };
+                            parent.usings[name] = using;
+                            if (node.type == "ImportModule") {
+                                if (!parent.imports) {
+                                    parent.imports = [using];
+                                }
+                                else {
+                                    const index = parent.imports.findIndex((using) => (using.node.id.type === "Identifier"
+                                        ? using.node.id.name
+                                        : using.node.id.property.name) === name);
+                                    if (index >= 0)
+                                        parent.imports.splice(index, 1);
+                                    parent.imports.push(using);
+                                }
+                            }
+                            break;
                         }
-                    }
-                    break;
-                }
-                case "CatchClause":
-                    if (node.param) {
-                        const [parent] = state.stack.slice(-1);
-                        if (!parent.decls)
-                            parent.decls = {};
-                        const id = node.param.type === "Identifier"
-                            ? node.param
-                            : node.param.left;
-                        state.stack.push({
-                            type: "BlockStatement",
-                            fullName: undefined,
-                            name: undefined,
-                            node: node.body,
-                            decls: { [id.name]: [id] },
-                            attributes: 0,
-                        });
-                    }
-                    break;
-                case "ForStatement":
-                    if (node.init && node.init.type === "VariableDeclaration") {
-                        state.stack.push({
-                            type: "BlockStatement",
-                            fullName: undefined,
-                            name: undefined,
-                            node: node,
-                            attributes: 0,
-                        });
-                    }
-                    break;
-                case "BlockStatement": {
-                    const [parent] = state.stack.slice(-1);
-                    if (parent.node === node ||
-                        (parent.type != "FunctionDeclaration" &&
-                            parent.type != "BlockStatement")) {
-                        break;
-                    }
-                    // fall through
-                }
-                case "ClassDeclaration":
-                case "FunctionDeclaration":
-                case "ModuleDeclaration": {
-                    const [parent] = state.stack.slice(-1);
-                    const name = "id" in node ? node.id && node.id.name : undefined;
-                    const fullName = state.stack
-                        .map((e) => e.name)
-                        .concat(name)
-                        .filter((e) => e != null)
-                        .join(".");
-                    const elm = {
-                        type: node.type,
-                        name,
-                        fullName,
-                        node,
-                        attributes: node.type === "BlockStatement"
-                            ? 0
-                            : stateNodeAttrs(node.attrs),
-                    };
-                    state.stack.push(elm);
-                    if (name) {
-                        if (!parent.decls)
-                            parent.decls = {};
-                        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) {
-                                e.node = node;
-                                state.stack.splice(-1, 1, e);
+                        case "CatchClause":
+                            if (node.param) {
+                                const [parent] = this.stack.slice(-1);
+                                if (!parent.decls)
+                                    parent.decls = {};
+                                const id = node.param.type === "Identifier"
+                                    ? node.param
+                                    : node.param.left;
+                                this.stack.push({
+                                    type: "BlockStatement",
+                                    fullName: undefined,
+                                    name: undefined,
+                                    node: node.body,
+                                    decls: { [id.name]: [id] },
+                                    attributes: 0,
+                                });
+                            }
+                            break;
+                        case "ForStatement":
+                            if (node.init && node.init.type === "VariableDeclaration") {
+                                this.stack.push({
+                                    type: "BlockStatement",
+                                    fullName: undefined,
+                                    name: undefined,
+                                    node: node,
+                                    attributes: 0,
+                                });
+                            }
+                            break;
+                        case "BlockStatement": {
+                            const [parent] = this.stack.slice(-1);
+                            if (parent.node === node ||
+                                (parent.type != "FunctionDeclaration" &&
+                                    parent.type != "BlockStatement")) {
                                 break;
                             }
+                            // fall through
                         }
-                        else {
-                            parent.decls[name] = [];
+                        case "ClassDeclaration":
+                        case "FunctionDeclaration":
+                        case "ModuleDeclaration": {
+                            const [parent] = this.stack.slice(-1);
+                            const name = "id" in node ? node.id && node.id.name : undefined;
+                            const fullName = this.stack
+                                .map((e) => e.name)
+                                .concat(name)
+                                .filter((e) => e != null)
+                                .join(".");
+                            const elm = {
+                                type: node.type,
+                                name,
+                                fullName,
+                                node,
+                                attributes: node.type === "BlockStatement"
+                                    ? 0
+                                    : stateNodeAttrs(node.attrs),
+                            };
+                            this.stack.push(elm);
+                            if (name) {
+                                if (!parent.decls)
+                                    parent.decls = {};
+                                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) {
+                                        e.node = node;
+                                        this.stack.splice(-1, 1, e);
+                                        break;
+                                    }
+                                }
+                                else {
+                                    parent.decls[name] = [];
+                                }
+                                if (node.type === "FunctionDeclaration" &&
+                                    node.params &&
+                                    node.params.length) {
+                                    const decls = (elm.decls = {});
+                                    node.params.forEach((p) => (decls[api_variableDeclarationName(p)] = [p]));
+                                }
+                                parent.decls[name].push(elm);
+                                if (node.type == "ModuleDeclaration" ||
+                                    node.type == "ClassDeclaration") {
+                                    if (!parent.type_decls)
+                                        parent.type_decls = {};
+                                    if (!ast_hasProperty(parent.type_decls, name)) {
+                                        parent.type_decls[name] = [];
+                                    }
+                                    parent.type_decls[name].push(elm);
+                                }
+                                break;
+                            }
+                            break;
                         }
-                        if (node.type === "FunctionDeclaration" &&
-                            node.params &&
-                            node.params.length) {
-                            const decls = (elm.decls = {});
-                            node.params.forEach((p) => (decls[api_variableDeclarationName(p)] = [p]));
+                        // an EnumDeclaration doesn't create a scope, but
+                        // it does create a type (if it has a name)
+                        case "EnumDeclaration": {
+                            if (!node.id) {
+                                this.inType++;
+                                break;
+                            }
+                            const [parent] = this.stack.slice(-1);
+                            const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
+                            node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
                         }
-                        parent.decls[name].push(elm);
-                        if (node.type == "ModuleDeclaration" ||
-                            node.type == "ClassDeclaration") {
+                        // fall through
+                        case "TypedefDeclaration": {
+                            this.inType++;
+                            const name = node.id.name;
+                            const [parent] = this.stack.slice(-1);
                             if (!parent.type_decls)
                                 parent.type_decls = {};
                             if (!ast_hasProperty(parent.type_decls, name)) {
                                 parent.type_decls[name] = [];
                             }
-                            parent.type_decls[name].push(elm);
+                            else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) === node)) {
+                                break;
+                            }
+                            const decl = {
+                                type: node.type,
+                                node,
+                                name,
+                                fullName: parent.fullName + "." + name,
+                                attributes: stateNodeAttrs(node.attrs),
+                                stack: this.stack.slice(),
+                            };
+                            parent.type_decls[name].push(decl);
+                            if (decl.type === "EnumDeclaration") {
+                                currentEnum = decl;
+                            }
+                            break;
+                        }
+                        case "VariableDeclaration": {
+                            const [parent] = this.stack.slice(-1);
+                            if (!parent.decls)
+                                parent.decls = {};
+                            const decls = parent.decls;
+                            const stack = this.stackClone();
+                            node.declarations.forEach((decl) => {
+                                const name = api_variableDeclarationName(decl.id);
+                                if (!ast_hasProperty(decls, name)) {
+                                    decls[name] = [];
+                                }
+                                else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
+                                    return;
+                                }
+                                decl.kind = node.kind;
+                                decls[name].push({
+                                    type: "VariableDeclarator",
+                                    node: decl,
+                                    name,
+                                    fullName: parent.fullName + "." + name,
+                                    stack,
+                                    attributes: stateNodeAttrs(node.attrs),
+                                });
+                                if (node.kind == "const") {
+                                    if (!ast_hasProperty(this.index, name)) {
+                                        this.index[name] = [];
+                                    }
+                                    (0,external_util_cjs_namespaceObject.pushUnique)(this.index[name], parent);
+                                }
+                            });
+                            break;
+                        }
+                        case "EnumStringBody": {
+                            if (this.inType !== 1) {
+                                throw new Error(`Expected inType to be 1 at EnumStringBody. Got ${this.inType}.`);
+                            }
+                            this.inType--;
+                            const [parent] = this.stack.slice(-1);
+                            const values = parent.decls || (parent.decls = {});
+                            let prev = -1;
+                            node.members.forEach((m, i) => {
+                                if (m.type == "Identifier") {
+                                    if (typeof prev === "bigint") {
+                                        prev += 1n;
+                                    }
+                                    else {
+                                        prev += 1;
+                                    }
+                                    m = node.members[i] = {
+                                        type: "EnumStringMember",
+                                        loc: m.loc,
+                                        start: m.start,
+                                        end: m.end,
+                                        id: m,
+                                        init: {
+                                            type: "Literal",
+                                            value: prev,
+                                            raw: prev.toString() +
+                                                (typeof prev === "bigint" ? "l" : ""),
+                                            enumType: m.enumType,
+                                            loc: m.loc,
+                                            start: m.start,
+                                            end: m.end,
+                                        },
+                                    };
+                                }
+                                const name = m.id.name;
+                                const init = getLiteralNode(m.init);
+                                if (!init) {
+                                    throw new Error("Unexpected enum initializer");
+                                }
+                                if (init != m.init) {
+                                    if (m.init.enumType) {
+                                        init.enumType = m.init.enumType;
+                                    }
+                                    m.init = init;
+                                }
+                                if (init.type == "Literal" &&
+                                    init.raw &&
+                                    prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
+                                    prev = init.value;
+                                }
+                                if (!ast_hasProperty(values, name)) {
+                                    values[name] = [];
+                                }
+                                if ((0,external_util_cjs_namespaceObject.pushUnique)(values[name], m) && currentEnum) {
+                                    if (!this.enumMap)
+                                        this.enumMap = new Map();
+                                    this.enumMap.set(m, currentEnum);
+                                }
+                                if (!ast_hasProperty(this.index, name)) {
+                                    this.index[name] = [];
+                                }
+                                (0,external_util_cjs_namespaceObject.pushUnique)(this.index[name], parent);
+                            });
+                            break;
                         }
                     }
-                    break;
+                    if (this.pre)
+                        return this.pre(node, this);
                 }
-                // an EnumDeclaration doesn't create a scope, but
-                // it does create a type (if it has a name)
-                case "EnumDeclaration": {
-                    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));
+                catch (e) {
+                    handleException(this, node, e);
                 }
-                // fall through
-                case "TypedefDeclaration": {
-                    state.inType++;
-                    const name = node.id.name;
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.type_decls)
-                        parent.type_decls = {};
-                    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)) {
-                        break;
+                return null;
+            }, (node) => {
+                try {
+                    let ret;
+                    if (this.shouldExclude && this.shouldExclude(node)) {
+                        // delete the node.
+                        ret = false;
                     }
-                    parent.type_decls[name].push(node.type === "EnumDeclaration"
-                        ? node
-                        : {
-                            type: "TypedefDeclaration",
-                            node,
-                            name,
-                            fullName: parent.fullName + "." + name,
-                            attributes: stateNodeAttrs(node.attrs),
-                        });
-                    break;
-                }
-                case "VariableDeclaration": {
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.decls)
-                        parent.decls = {};
-                    const decls = parent.decls;
-                    const stack = state.stackClone();
-                    node.declarations.forEach((decl) => {
-                        const name = api_variableDeclarationName(decl.id);
-                        if (!ast_hasProperty(decls, name)) {
-                            decls[name] = [];
-                        }
-                        else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
-                            return;
+                    else {
+                        const type = node.type;
+                        if (this.post)
+                            ret = this.post(node, this);
+                        switch (type) {
+                            case "EnumDeclaration":
+                                currentEnum = null;
+                            // fall through
+                            case "TypeSpecPart":
+                            case "TypeSpecList":
+                            case "TypedefDeclaration":
+                                this.inType--;
+                                break;
+                            case "EnumStringBody":
+                                this.inType++;
+                                break;
                         }
-                        decl.kind = node.kind;
-                        decls[name].push({
-                            type: "VariableDeclarator",
-                            node: decl,
-                            name,
-                            fullName: parent.fullName + "." + name,
-                            stack,
-                            attributes: stateNodeAttrs(node.attrs),
-                        });
-                        if (node.kind == "const") {
-                            if (!ast_hasProperty(state.index, name)) {
-                                state.index[name] = [];
+                        const [parent] = this.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;
+                            if (node.type != "Program") {
+                                this.stack.pop();
                             }
-                            (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
                         }
-                    });
-                    break;
+                    }
+                    if (ret != null && node.loc && node.loc.source && this.fnMap) {
+                        const fnInfo = this.fnMap[node.loc.source];
+                        fnInfo && fnInfo.ast && this.removeNodeComments(node, fnInfo.ast);
+                    }
+                    return ret;
                 }
-                case "EnumStringBody": {
-                    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") {
-                            if (typeof prev === "bigint") {
-                                prev += 1n;
-                            }
-                            else {
-                                prev += 1;
-                            }
-                            m = node.members[i] = {
-                                type: "EnumStringMember",
-                                loc: m.loc,
-                                start: m.start,
-                                end: m.end,
-                                id: m,
-                                init: {
-                                    type: "Literal",
-                                    value: prev,
-                                    raw: prev.toString() + (typeof prev === "bigint" ? "l" : ""),
-                                    enumType: m.enumType,
-                                    loc: m.loc,
-                                    start: m.start,
-                                    end: m.end,
-                                },
-                            };
-                        }
-                        const name = m.id.name;
-                        const init = getLiteralNode(m.init);
-                        if (!init) {
-                            throw new Error("Unexpected enum initializer");
-                        }
-                        if (init != m.init) {
-                            if (m.init.enumType) {
-                                init.enumType = m.init.enumType;
-                            }
-                            m.init = init;
-                        }
-                        if (init.type == "Literal" &&
-                            init.raw &&
-                            prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
-                            prev = init.value;
-                        }
-                        if (!ast_hasProperty(values, name)) {
-                            values[name] = [];
-                        }
-                        (0,external_util_cjs_namespaceObject.pushUnique)(values[name], m);
-                        if (!ast_hasProperty(state.index, name)) {
-                            state.index[name] = [];
-                        }
-                        (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
-                    });
-                    break;
+                catch (e) {
+                    handleException(this, node, e);
                 }
-            }
-            if (state.pre)
-                return state.pre(node, state);
-        }
-        catch (e) {
-            handleException(state, node, e);
-        }
-        return null;
-    }, (node) => {
-        try {
-            let ret;
-            if (state.shouldExclude && state.shouldExclude(node)) {
-                // delete the node.
-                ret = false;
+            });
+        },
+    };
+}
+function api_collectNamespaces(ast, stateIn) {
+    const state = (stateIn || {});
+    if (!state.nextExposed)
+        state.nextExposed = {};
+    if (!state.index)
+        state.index = {};
+    if (!state.stack) {
+        state.stack = [
+            {
+                type: "Program",
+                name: "$",
+                fullName: "$",
+                node: undefined,
+                attributes: 0,
+            },
+        ];
+    }
+    if (!state.lookupRules) {
+        const rules = state?.config?.compilerLookupRules || "DEFAULT";
+        if (rules !== "COMPILER1" && rules !== "COMPILER2") {
+            const match = state.sdk?.match(/-(\d+\.\d+\.\d+).(compiler2beta)?/i);
+            if (match && (match[2] || parseSdkVersion(match[1]) >= 4001006)) {
+                state.lookupRules = "COMPILER2";
             }
             else {
-                const type = node.type;
-                if (state.post)
-                    ret = state.post(node, state);
-                switch (type) {
-                    case "TypeSpecPart":
-                    case "TypeSpecList":
-                    case "TypedefDeclaration":
-                    case "EnumDeclaration":
-                        state.inType--;
-                        break;
-                    case "EnumStringBody":
-                        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;
-                    if (node.type != "Program") {
-                        state.stack.pop();
-                    }
-                }
-            }
-            if (ret != null) {
-                state.removeNodeComments(node, ast);
+                state.lookupRules = "COMPILER1";
             }
-            return ret;
         }
-        catch (e) {
-            handleException(state, node, e);
-        }
-    });
+    }
+    Object.assign(state, stateFuncs());
+    state.inType = 0;
     state.traverse(ast);
     if (state.inType) {
         throw new Error(`inType was non-zero on exit: ${state.inType}`);
@@ -5958,8 +6456,11 @@ function api_formatAst(node, monkeyCSource = null, options = null) {
      * should be ignored.
      */
     switch (node.type) {
-        case "Program":
         case "BlockStatement":
+            if (node.body.length)
+                break;
+            return "{}";
+        case "Program":
         case "ExpressionStatement":
             break;
         default: {
@@ -6088,15 +6589,16 @@ function api_getApiFunctionInfo(func) {
         return invokeInfo;
     }
     if (!toyboxFnInfo.calledFuncs) {
-        toyboxFnInfo.modifiedDecls = new Set();
-        toyboxFnInfo.calledFuncs = new Set();
-        toyboxFnInfo.resolvedDecls = new Set();
+        return false;
     }
     return toyboxFnInfo;
 }
 function api_markInvokeClassMethod(func) {
     func.info = invokeInfo;
 }
+function api_isLocal(v) {
+    return v.stack[v.stack.length - 1]?.type === "BlockStatement";
+}
 
 })();