@markw65/monkeyc-optimizer 1.1.3 → 1.1.5

package/build/optimizer.cjs

@@ -3626,7 +3626,7 @@ async function checkManifest(manifest, products) {
                 `${t}app` === type ||
                 (type === "widget" && t === "watchapp"));
         }));
-    if (JSON.stringify(allowedProducts) !=
+    if (JSON.stringify(allowedProducts) !==
         JSON.stringify(manifestProducts(manifest))) {
         ok = false;
         const products = app.children("iq:products");
@@ -3730,15 +3730,15 @@ function process_assignments(assignments, current) {
         const process_list = (values) => {
             for (let i = values.length; i--;) {
                 const v = values[i];
-                if (v.type == "QualifiedName" &&
+                if (v.type === "QualifiedName" &&
                     v.names.every((n, i) => n === a.names[i])) {
                     values.splice(i, 1, ...(dot
-                        ? dot.map((v) => v.type == "QualifiedName"
+                        ? dot.map((v) => v.type === "QualifiedName"
                             ? { ...v, names: v.names.concat(dotnames) }
                             : v)
                         : []));
                 }
-                else if (v.type == "SubList") {
+                else if (v.type === "SubList") {
                     process_list(v.values);
                 }
             }
@@ -3771,7 +3771,8 @@ function evaluate_locals(assignments) {
     const locals = {};
     while (true) {
         assignments = assignments.filter((a) => {
-            if (a.names.length == 1 && a.values.every((v) => typeof v === "string")) {
+            if (a.names.length === 1 &&
+                a.values.every((v) => typeof v === "string")) {
                 locals[a.names[0]] = a.values;
                 return false;
             }
@@ -3782,12 +3783,12 @@ function evaluate_locals(assignments) {
         const process_list = (values) => {
             for (let i = values.length; i--;) {
                 const v = values[i];
-                if (v.type == "QualifiedName" &&
-                    v.names.length == 1 &&
+                if (v.type === "QualifiedName" &&
+                    v.names.length === 1 &&
                     (0,external_api_cjs_namespaceObject.hasProperty)(locals, v.names[0])) {
                     values.splice(i, 1, ...locals[v.names[0]]);
                 }
-                else if (v.type == "SubList") {
+                else if (v.type === "SubList") {
                     process_list(v.values);
                 }
             }
@@ -3866,7 +3867,7 @@ function resolve_node_by_path(state, path) {
             if (!resolved.length)
                 return undefined;
             const r = resolved[0][n];
-            if (!r && sdot.every((e) => e.type == "Literal")) {
+            if (!r && sdot.every((e) => e.type === "Literal")) {
                 /*
                  * We had something like:
                  *
@@ -3944,10 +3945,10 @@ async function resolve_literals(qualifier, default_source, deviceInfo, cache) {
             if (!isJNode(v)) {
                 return v;
             }
-            if (v.type == "QualifiedName") {
+            if (v.type === "QualifiedName") {
                 throw new Error("Unexpected QualifiedName found!");
             }
-            if (v.type == "SubList") {
+            if (v.type === "SubList") {
                 return resolve_file_list(v.values);
             }
             // Jungle files can contain "./**.mc" which is supposed to match
@@ -4741,6 +4742,9 @@ function withLoc(node, start, end) {
         if (!node.end)
             node.end = start.end;
         node.loc = { ...(node.loc || start.loc), start: start.loc.start };
+        if (end === start && start.origins) {
+            node.origins = start.origins;
+        }
     }
     if (end === false) {
         if (node.loc) {
@@ -4773,17 +4777,17 @@ function cloneDeep(node) {
     return withLocDeep(node, null);
 }
 function getNodeValue(node) {
-    if (node.type == "BinaryExpression" &&
-        node.operator == "as" &&
-        node.right.type == "TypeSpecList" &&
-        node.right.ts.length == 1 &&
-        typeof node.right.ts[0] == "string") {
+    if (node.type === "BinaryExpression" &&
+        node.operator === "as" &&
+        node.right.type === "TypeSpecList" &&
+        node.right.ts.length === 1 &&
+        typeof node.right.ts[0] === "string") {
         // this is a cast we inserted to retain the type of an enum
         // any arithmetic on it will revert to "Number", or "Long",
         // so just ignore it.
         return getNodeValue(node.left);
     }
-    if (node.type != "Literal") {
+    if (node.type !== "Literal") {
         return [null, null];
     }
     if (node.value === null) {
@@ -4873,13 +4877,13 @@ function makeScopedName(dotted, l) {
 function ast_getLiteralNode(node) {
     if (node == null)
         return null;
-    if (node.type == "Literal")
+    if (node.type === "Literal")
         return node;
-    if (node.type == "BinaryExpression" && node.operator == "as") {
+    if (node.type === "BinaryExpression" && node.operator === "as") {
         return ast_getLiteralNode(node.left) && node;
     }
-    if (node.type == "UnaryExpression") {
-        if (node.argument.type != "Literal")
+    if (node.type === "UnaryExpression") {
+        if (node.argument.type !== "Literal")
             return null;
         switch (node.operator) {
             case "-": {
@@ -4910,7 +4914,7 @@ function recordModifiedDecl(func, decl) {
 }
 function recordModifiedDecls(func, lookupDefs) {
     lookupDefs.forEach((lookupDef) => lookupDef.results.forEach((result) => {
-        if (result.type == "VariableDeclarator" && result.node.kind === "var") {
+        if (result.type === "VariableDeclarator" && result.node.kind === "var") {
             recordModifiedDecl(func, result);
         }
     }));
@@ -5262,7 +5266,7 @@ function getArgSafety(state, func, args, requireAll) {
             switch (node.type) {
                 case "AssignmentExpression":
                 case "UpdateExpression": {
-                    const v = node.type == "UpdateExpression" ? node.argument : node.left;
+                    const v = node.type === "UpdateExpression" ? node.argument : node.left;
                     if (v.type === "Identifier" && (0,external_api_cjs_namespaceObject.hasProperty)(params, v.name)) {
                         // If a parameter is modified, we can't just substitute the
                         // argument wherever the parameter is used.
@@ -5482,6 +5486,12 @@ function processInlineBody(state, func, call, root, params) {
                 const ix = params[node.name];
                 if (ix >= 0) {
                     const replacement = { ...call.arguments[ix] };
+                    if (node.loc) {
+                        if (!replacement.origins) {
+                            replacement.origins = [];
+                        }
+                        replacement.origins.unshift({ loc: node.loc, func: func.fullName });
+                    }
                     replacements.add(replacement);
                     return replacement;
                 }
@@ -5568,7 +5578,7 @@ function unused(state, expression, top) {
                 body: [estmt(expression.right)],
             }, expression.right);
             let alternate;
-            if (expression.operator == "||" || expression.operator == "or") {
+            if (expression.operator === "||" || expression.operator === "or") {
                 alternate = { ...consequent };
                 consequent.body = [];
             }
@@ -5629,7 +5639,10 @@ function unused(state, expression, top) {
 }
 function inlineDiagnostic(state, func, call, message) {
     if (inlineRequested(state, func)) {
-        (0,external_api_cjs_namespaceObject.diagnostic)(state, call, message && `While inlining ${func.node.id.name}: ${message}`);
+        if (!state.inlineDiagnostics) {
+            state.inlineDiagnostics = {};
+        }
+        (0,external_api_cjs_namespaceObject.diagnosticHelper)(state.inlineDiagnostics, call, message && `While inlining ${func.node.id.name}: ${message}`, "INFO", undefined, true);
     }
 }
 function inlineWithArgs(state, func, call, context) {
@@ -5688,10 +5701,10 @@ function inlineWithArgs(state, func, call, context) {
     if (!processInlineBody(state, func, call, body, params)) {
         return null;
     }
-    (0,external_api_cjs_namespaceObject.diagnostic)(state, call, null);
+    inlineDiagnostic(state, func, call, null);
     if (context.type !== "ReturnStatement" && retStmtCount) {
         const [last, block] = lastStmt(body);
-        if (last.type != "ReturnStatement") {
+        if (last.type !== "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
         if (last.argument) {
@@ -5988,7 +6001,7 @@ function pragmaChecker(state, ast, diagnostics) {
         }
     };
     const matcher = (quote, needle, haystack) => {
-        if (quote == '"') {
+        if (quote === '"') {
             return haystack.includes(needle);
         }
         const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
@@ -6785,7 +6798,7 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
             uniqueDeclMap.set(decls[0], decls);
             return decls;
         }
-        if (canon.length != decls.length ||
+        if (canon.length !== decls.length ||
             !canon.every((v, i) => v === decls[i])) {
             throw new Error(`Canonical representation of ${declFullName(canon)} did not match`);
         }
@@ -7376,7 +7389,7 @@ function anticipatedDecls() {
     return new Map();
 }
 function equalSet(a, b) {
-    if (a.size != b.size)
+    if (a.size !== b.size)
         return false;
     for (const item of a) {
         if (!b.has(item))
@@ -7385,7 +7398,7 @@ function equalSet(a, b) {
     return true;
 }
 function equalMap(a, b) {
-    if (a.size != b.size)
+    if (a.size !== b.size)
         return false;
     for (const [item, value] of a) {
         if (b.get(item) !== value)
@@ -7438,8 +7451,8 @@ function equalStates(a, b) {
     for (const [k, ae] of a) {
         const be = b.get(k);
         if (!be ||
-            be.live != ae.live ||
-            be.isIsolated != ae.isIsolated ||
+            be.live !== ae.live ||
+            be.isIsolated !== ae.isIsolated ||
             !equalSet(ae.ant, be.ant) ||
             !equalMap(ae.members, be.members)) {
             return false;
@@ -7471,8 +7484,8 @@ function refCost(node) {
         return cost;
     while (true) {
         const next = node.object;
-        if (next.type != "MemberExpression") {
-            if (next.type != "ThisExpression") {
+        if (next.type !== "MemberExpression") {
+            if (next.type !== "ThisExpression") {
                 cost += next.type === "Identifier" && next.name === "$" ? 4 : 6;
             }
             return cost;
@@ -7728,7 +7741,7 @@ function computeAttributes(state, head) {
                         delete existing.isIsolated;
                         mergeAnticipatedState(events, existing);
                     }
-                    else if (candidateCost(events) != cost) {
+                    else if (candidateCost(events) !== cost) {
                         throw new Error(`cost of block ${i} changed`);
                     }
                     candidateDecls.set(decl, events);
@@ -8014,7 +8027,7 @@ function describeEvent(event) {
 }
 function printBlockEvents(block, extra) {
     console.log("Events:");
-    (0,external_util_cjs_namespaceObject.forEach)(block.events, (event) => console.log(`    ${describeEvent(event)} ${extra?.(event)}`));
+    (0,external_util_cjs_namespaceObject.forEach)(block.events, (event) => console.log(`    ${describeEvent(event)} ${extra ? extra(event) : ""}`));
 }
 function printBlockTrailer(block) {
     console.log(`Succs: ${(block.succs || [])
@@ -8090,19 +8103,20 @@ function findDeadStores(graph, logThisRun) {
                         }
                         break;
                     case "def":
-                        if (isTypeStateKey(event.decl) &&
-                            ((event.node.type === "AssignmentExpression" &&
-                                event.node.operator === "=") ||
-                                (event.node.type === "VariableDeclarator" && event.node.init))) {
+                        if (isTypeStateKey(event.decl)) {
                             if (curState.has(event.decl)) {
                                 deadStores.add(event.node);
                             }
                             else {
                                 deadStores.delete(event.node);
                             }
-                            curState.add(event.decl);
-                            if (logThisRun) {
-                                console.log(`  anticipated => ${tsKey(event.decl)}`);
+                            if ((event.node.type === "AssignmentExpression" &&
+                                event.node.operator === "=") ||
+                                (event.node.type === "VariableDeclarator" && event.node.init)) {
+                                curState.add(event.decl);
+                                if (logThisRun) {
+                                    console.log(`  anticipated => ${tsKey(event.decl)}`);
+                                }
                             }
                         }
                         break;
@@ -8156,12 +8170,23 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
             node.expression.type === "AssignmentExpression" &&
             deadStores.has(node.expression)) {
             const body = unused(state, node.expression.left).concat(unused(state, node.expression.right));
+            changes = true;
             if (body.length) {
                 return withLoc({ type: "BlockStatement", body }, node, node);
             }
-            changes = true;
             return false;
         }
+        if (node.type === "UpdateExpression" && deadStores.has(node)) {
+            changes = true;
+            return { type: "Literal", value: null, raw: "null" };
+        }
+        if (node.type === "AssignmentExpression" &&
+            deadStores.has(node) &&
+            unused(state, node.right, true)?.length === 0 &&
+            unused(state, node.left, true)?.length === 0) {
+            changes = true;
+            return { type: "Literal", value: null, raw: "null" };
+        }
         if (node.type === "VariableDeclaration") {
             const result = [];
             for (let i = 0; i < node.declarations.length; i++) {
@@ -8305,28 +8330,32 @@ function intersection(a, b) {
     }
     let mask = 0;
     const result = {};
-    forEachUnionComponent(a, common, (bit, avalue) => {
-        const bvalue = getUnionComponent(b, bit);
-        if (avalue == null) {
+    forEachUnionComponent(a, common, (ac) => {
+        const bvalue = getUnionComponent(b, ac.type);
+        if (ac.value == null) {
             if (!bvalue)
                 return;
-            result[bit] = bvalue;
-            mask |= bit;
+            result[ac.type] = bvalue;
+            mask |= ac.type;
             return;
         }
-        if (bvalue === null || avalue === bvalue) {
-            result[bit] = avalue;
-            mask |= bit;
+        if (bvalue === null || ac.value === bvalue) {
+            result[ac.type] = ac.value;
+            mask |= ac.type;
             return;
         }
-        const ivalue = intersectionValue(bit, avalue, bvalue);
+        const ivalue = intersectionValue({
+            type: ac.type,
+            avalue: ac.value,
+            bvalue,
+        });
         if (ivalue != null) {
-            result[bit] = ivalue;
-            mask |= bit;
+            result[ac.type] = ivalue;
+            mask |= ac.type;
             return;
         }
         else {
-            common -= bit;
+            common -= ac.type;
         }
     });
     if (!mask)
@@ -8339,13 +8368,13 @@ function intersection(a, b) {
     }
     return { type: common, value: result[mask] };
 }
-function intersectionValue(bit, avalue, bvalue) {
-    switch (bit) {
+function intersectionValue(pair) {
+    switch (pair.type) {
         case 1 /* TypeTag.Null */:
         case 2 /* TypeTag.False */:
         case 4 /* TypeTag.True */:
         case 262144 /* TypeTag.Typedef */:
-            throw new Error(`Unexpected TypeTag '${typeTagName(bit)}'`);
+            throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
         case 8 /* TypeTag.Number */:
         case 16 /* TypeTag.Long */:
         case 32 /* TypeTag.Float */:
@@ -8353,31 +8382,27 @@ function intersectionValue(bit, avalue, bvalue) {
         case 256 /* TypeTag.String */:
         case 128 /* TypeTag.Char */:
         case 131072 /* TypeTag.Symbol */:
-            return avalue === bvalue ? avalue : null;
+            return pair.avalue === pair.bvalue ? pair.avalue : null;
         case 512 /* TypeTag.Array */: {
-            const atype = intersection(avalue, bvalue);
+            const atype = intersection(pair.avalue, pair.bvalue);
             return atype.type === 0 /* TypeTag.Never */ ? null : atype;
         }
         case 1024 /* TypeTag.Dictionary */: {
-            const adict = avalue;
-            const bdict = bvalue;
-            const dkey = intersection(adict.key, bdict.key);
-            const dvalue = intersection(adict.value, bdict.value);
+            const dkey = intersection(pair.avalue.key, pair.bvalue.key);
+            const dvalue = intersection(pair.avalue.value, pair.bvalue.value);
             return dkey.type !== 0 /* TypeTag.Never */ && dvalue.type !== 0 /* TypeTag.Never */
                 ? { key: dkey, value: dvalue }
                 : null;
         }
         case 2048 /* TypeTag.Method */: {
-            const ameth = avalue;
-            const bmeth = bvalue;
-            if (ameth.args.length != bmeth.args.length)
+            if (pair.avalue.args.length !== pair.bvalue.args.length)
                 return null;
-            const mresult = intersection(ameth.result, bmeth.result);
+            const mresult = intersection(pair.avalue.result, pair.bvalue.result);
             if (mresult.type === 0 /* TypeTag.Never */)
                 return null;
-            const margs = ameth.args.map((aarg, i) => {
+            const margs = pair.avalue.args.map((aarg, i) => {
                 aarg = cloneType(aarg);
-                unionInto(aarg, bmeth.args[i]);
+                unionInto(aarg, pair.bvalue.args[i]);
                 return aarg;
             });
             if (margs.some((arg) => arg.type === 0 /* TypeTag.Never */))
@@ -8386,23 +8411,19 @@ function intersectionValue(bit, avalue, bvalue) {
         }
         case 4096 /* TypeTag.Module */:
         case 8192 /* TypeTag.Function */: {
-            const asd = avalue;
-            const bsd = bvalue;
             // quadratic :-(
             const common = [];
-            (0,external_util_cjs_namespaceObject.forEach)(asd, (sna) => (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => sna === snb) &&
+            (0,external_util_cjs_namespaceObject.forEach)(pair.avalue, (sna) => (0,external_util_cjs_namespaceObject.some)(pair.bvalue, (snb) => sna === snb) &&
                 common.push(sna));
             if (!common.length)
                 return null;
             return (common.length === 1 ? common[0] : common);
         }
         case 16384 /* TypeTag.Class */: {
-            const asd = avalue;
-            const bsd = bvalue;
             const common = [];
-            (0,external_util_cjs_namespaceObject.forEach)(asd, (sna) => {
+            (0,external_util_cjs_namespaceObject.forEach)(pair.avalue, (sna) => {
                 const superA = (0,external_api_cjs_namespaceObject.getSuperClasses)(sna);
-                (0,external_util_cjs_namespaceObject.forEach)(bsd, (snb) => {
+                (0,external_util_cjs_namespaceObject.forEach)(pair.bvalue, (snb) => {
                     if (sna === snb || (superA && superA.has(snb))) {
                         common.push(sna);
                     }
@@ -8417,10 +8438,8 @@ function intersectionValue(bit, avalue, bvalue) {
             return common.length === 1 ? common[0] : common;
         }
         case 32768 /* TypeTag.Object */: {
-            const aobj = avalue;
-            const bobj = bvalue;
-            const klass = intersection(aobj.klass, bobj.klass);
-            const obj = intersectObj(aobj.obj, bobj.obj);
+            const klass = intersection(pair.avalue.klass, pair.bvalue.klass);
+            const obj = intersectObj(pair.avalue.obj, pair.bvalue.obj);
             return klass.type !== 16384 /* TypeTag.Class */ || klass.value == null
                 ? null
                 : obj
@@ -8428,24 +8447,24 @@ function intersectionValue(bit, avalue, bvalue) {
                     : { klass: klass };
         }
         case 65536 /* TypeTag.Enum */: {
-            const aenum = avalue;
-            const benum = bvalue;
-            if (aenum.enum !== benum.enum && aenum.enum && benum.enum) {
+            if (pair.avalue.enum !== pair.bvalue.enum &&
+                pair.avalue.enum &&
+                pair.bvalue.enum) {
                 return null;
             }
-            const enumDecl = aenum.enum || benum.enum;
-            if (aenum.value != null) {
-                if (benum.value != null) {
-                    const value = intersection(aenum.value, benum.value);
+            const enumDecl = pair.avalue.enum || pair.bvalue.enum;
+            if (pair.avalue.value != null) {
+                if (pair.bvalue.value != null) {
+                    const value = intersection(pair.avalue.value, pair.bvalue.value);
                     const e = { enum: enumDecl, value };
                     return e;
                 }
-                return aenum.value;
+                return pair.avalue.value;
             }
-            return benum;
+            return pair.bvalue;
         }
         default:
-            unhandledType(bit);
+            unhandledType(pair);
     }
 }
 function intersectObj(to, from) {
@@ -8509,9 +8528,11 @@ function restrictExactTypesByEquality(a, b) {
                 extra_bits |= 4 /* TypeTag.True */;
             }
             let value_bits = b.type & (120 /* TypeTag.Numeric */ | 128 /* TypeTag.Char */);
+            // Some Numbers don't fit exactly in a Float
+            // We can eliminate Float from b's type in those cases.
             if (a.value != null &&
                 value_bits & 32 /* TypeTag.Float */ &&
-                roundToFloat(Number(a.value)) != a.value) {
+                roundToFloat(Number(a.value)) !== a.value) {
                 value_bits -= 32 /* TypeTag.Float */;
             }
             let v = {
@@ -8540,14 +8561,15 @@ function restrictExactTypesByEquality(a, b) {
             let value_bits = b.type & 120 /* TypeTag.Numeric */;
             if (a.value != null) {
                 if (value_bits & 8 /* TypeTag.Number */ &&
-                    BigInt.asIntN(32, a.value) != a.value) {
+                    BigInt.asIntN(32, a.value) !== a.value) {
                     value_bits -= 8 /* TypeTag.Number */;
                 }
                 if (value_bits & 32 /* TypeTag.Float */ &&
-                    BigInt(roundToFloat(Number(a.value))) != a.value) {
+                    BigInt(roundToFloat(Number(a.value))) !== a.value) {
                     value_bits -= 32 /* TypeTag.Float */;
                 }
-                if (value_bits & 64 /* TypeTag.Double */ && BigInt(Number(a.value)) != a.value) {
+                if (value_bits & 64 /* TypeTag.Double */ &&
+                    BigInt(Number(a.value)) !== a.value) {
                     value_bits -= 64 /* TypeTag.Double */;
                 }
             }
@@ -8648,7 +8670,7 @@ function restrictExactTypesByEquality(a, b) {
 }
 function restrictByEqualityByComponent(a, b) {
     let bits = a.type;
-    if (a.value == null && (b.type & bits) == b.type) {
+    if (a.value == null && (b.type & bits) === b.type) {
         // shortcut:
         // if b.type is contained in a.type, and a has no
         // specialization, the result is just b.
@@ -8690,7 +8712,7 @@ function restrictByEqualityByComponent(a, b) {
  * 5.0 == 5, and 5.toChar() == 5.
  */
 function restrictByEquality(a, b) {
-    if (a.type == 0 /* TypeTag.Never */)
+    if (a.type === 0 /* TypeTag.Never */)
         return a;
     if (isExact(a)) {
         return restrictExactTypesByEquality(a, b);
@@ -8741,11 +8763,12 @@ function subtypeOf(a, b) {
     if (b.value == null)
         return true;
     let result = true;
-    forEachUnionComponent(b, common, (bit, bvalue) => {
-        const avalue = getUnionComponent(a, bit);
-        if (bvalue == null || avalue === bvalue)
+    forEachUnionComponent(b, common, (bc) => {
+        const avalue = getUnionComponent(a, bc.type);
+        if (bc.value == null || avalue === bc.value)
             return true;
-        if (avalue == null || !subtypeOfValue(bit, avalue, bvalue)) {
+        if (avalue == null ||
+            !subtypeOfValue({ type: bc.type, avalue, bvalue: bc.value })) {
             result = false;
             return false;
         }
@@ -8753,13 +8776,13 @@ function subtypeOf(a, b) {
     });
     return result;
 }
-function subtypeOfValue(bit, avalue, bvalue) {
-    switch (bit) {
+function subtypeOfValue(pair) {
+    switch (pair.type) {
         case 1 /* TypeTag.Null */:
         case 2 /* TypeTag.False */:
         case 4 /* TypeTag.True */:
         case 262144 /* TypeTag.Typedef */:
-            throw new Error(`Unexpected TypeTag '${typeTagName(bit)}'`);
+            throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
         case 8 /* TypeTag.Number */:
         case 16 /* TypeTag.Long */:
         case 32 /* TypeTag.Float */:
@@ -8767,31 +8790,29 @@ function subtypeOfValue(bit, avalue, bvalue) {
         case 256 /* TypeTag.String */:
         case 128 /* TypeTag.Char */:
         case 131072 /* TypeTag.Symbol */:
-            return avalue === bvalue;
+            return pair.avalue === pair.bvalue;
         case 512 /* TypeTag.Array */:
-            return subtypeOf(avalue, bvalue);
+            return subtypeOf(pair.avalue, pair.bvalue);
         case 1024 /* TypeTag.Dictionary */: {
-            const adict = avalue;
-            const bdict = bvalue;
+            const adict = pair.avalue;
+            const bdict = pair.bvalue;
             return (subtypeOf(adict.key, bdict.key) && subtypeOf(adict.value, bdict.value));
         }
         case 2048 /* TypeTag.Method */: {
-            const ameth = avalue;
-            const bmeth = bvalue;
-            return (ameth.args.length === bmeth.args.length &&
-                subtypeOf(ameth.result, bmeth.result) &&
-                ameth.args.every((arg, i) => subtypeOf(bmeth.args[i], arg)));
+            return (pair.avalue.args.length === pair.bvalue.args.length &&
+                subtypeOf(pair.avalue.result, pair.bvalue.result) &&
+                pair.avalue.args.every((arg, i) => subtypeOf(pair.bvalue.args[i], arg)));
         }
         case 4096 /* TypeTag.Module */:
         case 8192 /* TypeTag.Function */: {
-            const asd = avalue;
-            const bsd = bvalue;
+            const asd = pair.avalue;
+            const bsd = pair.bvalue;
             // quadratic :-(
             return (0,external_util_cjs_namespaceObject.some)(asd, (sna) => (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => sna === snb));
         }
         case 16384 /* TypeTag.Class */: {
-            const asd = avalue;
-            const bsd = bvalue;
+            const asd = pair.avalue;
+            const bsd = pair.bvalue;
             return (0,external_util_cjs_namespaceObject.every)(asd, (sna) => {
                 const superA = (0,external_api_cjs_namespaceObject.getSuperClasses)(sna);
                 return (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => {
@@ -8803,18 +8824,18 @@ function subtypeOfValue(bit, avalue, bvalue) {
             });
         }
         case 32768 /* TypeTag.Object */: {
-            const aobj = avalue;
-            const bobj = bvalue;
+            const aobj = pair.avalue;
+            const bobj = pair.bvalue;
             return (subtypeOf(aobj.klass, bobj.klass) && subtypeOfObj(aobj.obj, bobj.obj));
         }
         case 65536 /* TypeTag.Enum */: {
-            const aenum = avalue;
-            const benum = bvalue;
+            const aenum = pair.avalue;
+            const benum = pair.bvalue;
             return (aenum.enum === benum.enum &&
                 (!aenum.value || !benum.value || subtypeOf(aenum.value, benum.value)));
         }
         default:
-            unhandledType(bit);
+            unhandledType(pair);
     }
 }
 function subtypeOfObj(a, b) {
@@ -8835,6 +8856,9 @@ function subtypeOfObj(a, b) {
 
 
 function unionInto(to, from) {
+    if (to == null || from == null) {
+        throw new Error("Null");
+    }
     if (from.type === 0 || to === from)
         return false;
     if (to.type === 0) {
@@ -8884,23 +8908,27 @@ function mergeMultiple(to, from) {
     let anyChanged = newTags !== to.type;
     let mask = 0;
     const result = {};
-    forEachUnionComponent(to, newTags, (tag, tov) => {
-        const fromv = getUnionComponent(from, tag);
-        if (tov != null) {
+    forEachUnionComponent(to, newTags, (ac) => {
+        const fromv = getUnionComponent(from, ac.type);
+        if (ac.value != null) {
             if (fromv != null) {
-                const [value, changed] = mergeSingle(tag, tov, fromv);
+                const [value, changed] = mergeSingle({
+                    type: ac.type,
+                    avalue: ac.value,
+                    bvalue: fromv,
+                });
                 if (changed)
                     anyChanged = true;
                 if (value) {
-                    mask |= tag;
-                    result[tag] = value;
+                    mask |= ac.type;
+                    result[ac.type] = value;
                 }
             }
-            else if (!(from.type & tag)) {
+            else if (!(from.type & ac.type)) {
                 // from doesn't contribute to this tag,
                 // so just keep it. No change.
-                mask |= tag;
-                result[tag] = tov;
+                mask |= ac.type;
+                result[ac.type] = ac.value;
             }
             else {
                 // We dropped the data for this tag, so
@@ -8908,13 +8936,13 @@ function mergeMultiple(to, from) {
                 anyChanged = true;
             }
         }
-        else if (fromv && !(to.type & tag)) {
+        else if (fromv && !(to.type & ac.type)) {
             // to doesn't contribute to this tag,
             // so just keep from's component.
             // this is new, so it changed.
             anyChanged = true;
-            mask |= tag;
-            result[tag] = fromv;
+            mask |= ac.type;
+            result[ac.type] = fromv;
         }
     });
     if (!anyChanged)
@@ -8941,8 +8969,8 @@ function tryUnion(to, from) {
         return to;
     return null;
 }
-function mergeSingle(type, to, from) {
-    switch (type) {
+function mergeSingle(pair) {
+    switch (pair.type) {
         case 1 /* TypeTag.Null */:
         case 2 /* TypeTag.False */:
         case 4 /* TypeTag.True */:
@@ -8954,48 +8982,49 @@ function mergeSingle(type, to, from) {
         case 128 /* TypeTag.Char */:
         case 256 /* TypeTag.String */:
         case 131072 /* TypeTag.Symbol */:
-            if (to === from) {
-                return [to, false];
+            if (pair.avalue === pair.bvalue) {
+                return [pair.avalue, false];
             }
             return [null, true];
         case 512 /* TypeTag.Array */: {
-            const merged = tryUnion(to, from);
-            return [merged || to, merged != null];
+            const merged = tryUnion(pair.avalue, pair.bvalue);
+            return [merged || pair.avalue, merged != null];
         }
         case 1024 /* TypeTag.Dictionary */: {
-            const { key, value } = to;
-            const keyChange = tryUnion(key, from.key);
-            const valueChange = tryUnion(value, from.value);
+            const { key, value } = pair.avalue;
+            const keyChange = tryUnion(key, pair.bvalue.key);
+            const valueChange = tryUnion(value, pair.bvalue.value);
             if (keyChange || valueChange) {
                 return [{ key: keyChange || key, value: valueChange || value }, true];
             }
-            return [to, false];
+            return [pair.avalue, false];
         }
         case 2048 /* TypeTag.Method */: {
-            const ameth = to;
-            const bmeth = from;
-            if (ameth.args.length != bmeth.args.length)
+            if (pair.avalue.args.length !== pair.bvalue.args.length)
                 return [null, true];
-            const resultChange = tryUnion(ameth.result, bmeth.result);
-            const args = ameth.args.map((arg, i) => intersection(arg, bmeth.args[i]));
+            const resultChange = tryUnion(pair.avalue.result, pair.bvalue.result);
+            const args = pair.avalue.args.map((arg, i) => intersection(arg, pair.bvalue.args[i]));
             if (args.some((arg) => arg.type === 0 /* TypeTag.Never */)) {
                 return [null, true];
             }
-            const argsChanged = args.some((arg, i) => !subtypeOf(ameth.args[i], arg));
+            const argsChanged = args.some((arg, i) => !subtypeOf(pair.avalue.args[i], arg));
             if (resultChange || argsChanged) {
-                return [{ result: resultChange || ameth.result, args }, true];
+                return [{ result: resultChange || pair.avalue.result, args }, true];
             }
-            return [to, false];
+            return [pair.avalue, false];
         }
         case 4096 /* TypeTag.Module */:
+            return mergeStateDecls(pair.avalue, pair.bvalue);
         case 8192 /* TypeTag.Function */:
+            return mergeStateDecls(pair.avalue, pair.bvalue);
         case 16384 /* TypeTag.Class */:
+            return mergeStateDecls(pair.avalue, pair.bvalue);
         case 262144 /* TypeTag.Typedef */:
-            return mergeStateDecls(to, from);
+            return mergeStateDecls(pair.avalue, pair.bvalue);
         case 32768 /* TypeTag.Object */: {
-            let klass = to.klass;
-            const [obj, objChanged] = mergeObjectValues(to.obj, from.obj);
-            const klassChanged = tryUnion(klass, from.klass);
+            let klass = pair.avalue.klass;
+            const [obj, objChanged] = mergeObjectValues(pair.avalue.obj, pair.bvalue.obj);
+            const klassChanged = tryUnion(klass, pair.bvalue.klass);
             if (klassChanged || objChanged) {
                 klass = (klassChanged || klass);
                 if (obj) {
@@ -9003,11 +9032,11 @@ function mergeSingle(type, to, from) {
                 }
                 return [{ klass }, true];
             }
-            return [to, false];
+            return [pair.avalue, false];
         }
         case 65536 /* TypeTag.Enum */: {
-            const toE = to;
-            const fromE = from;
+            const toE = pair.avalue;
+            const fromE = pair.bvalue;
             if (toE.enum !== fromE.enum) {
                 return [null, true];
             }
@@ -9026,9 +9055,8 @@ function mergeSingle(type, to, from) {
             return [toE, false];
         }
         default:
-            unhandledType(type);
+            unhandledType(pair);
     }
-    throw new Error(`Unexpected type ${type}`);
 }
 function mergeObjectValues(to, from) {
     if (!to) {
@@ -9172,22 +9200,22 @@ function clearValuesUnder(v, tag, clearTag = false) {
 }
 function widenTypeHelper(t, depth) {
     let result = null;
-    forEachUnionComponent(t, t.type & (512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */), (tag, value) => {
-        if (!value)
+    forEachUnionComponent(t, t.type & (512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */), (ac) => {
+        if (ac.value == null)
             return;
-        switch (tag) {
+        switch (ac.type) {
             case 512 /* TypeTag.Array */:
                 if (depth > 4) {
                     if (!result)
                         result = cloneType(t);
-                    clearValuesUnder(result, tag);
+                    clearValuesUnder(result, ac.type);
                 }
                 else {
-                    const v = widenTypeHelper(value, depth + 1);
+                    const v = widenTypeHelper(ac.value, depth + 1);
                     if (v) {
                         if (!result)
                             result = cloneType(t);
-                        setUnionComponent(result, tag, v);
+                        setUnionComponent(result, ac.type, v);
                     }
                 }
                 return;
@@ -9195,10 +9223,10 @@ function widenTypeHelper(t, depth) {
                 if (depth > 4) {
                     if (!result)
                         result = cloneType(t);
-                    clearValuesUnder(result, tag);
+                    clearValuesUnder(result, ac.type);
                 }
                 else {
-                    const ddata = value;
+                    const ddata = ac.value;
                     const key = widenTypeHelper(ddata.key, depth + 1);
                     const data = widenTypeHelper(ddata.value, depth + 1);
                     if (key || data) {
@@ -9209,7 +9237,7 @@ function widenTypeHelper(t, depth) {
                             newDData.key = key;
                         if (data)
                             newDData.value = data;
-                        setUnionComponent(result, tag, newDData);
+                        setUnionComponent(result, ac.type, newDData);
                     }
                 }
                 return;
@@ -9229,6 +9257,7 @@ function widenType(t) {
 
 
 
+
 function typeTagName(tag) {
     switch (tag) {
         case 0 /* TypeTag.Never */:
@@ -9327,7 +9356,7 @@ function hasNoData(v, t) {
         return true;
     return ((hasUnionData(v.type)
         ? v.value.mask & t
-        : v.type & t & ~SingleTonTypeTagsConst) == 0);
+        : v.type & t & ~SingleTonTypeTagsConst) === 0);
 }
 function lookupByFullName(state, fullName) {
     return fullName.split(".").reduce((results, part) => {
@@ -9445,24 +9474,47 @@ function typeFromTypeStateNode(state, sn, classVsObj) {
             sn.resolvedType = result;
             return result;
         }
-        case "VariableDeclarator":
+        case "VariableDeclarator": {
+            if (sn.resolvedType)
+                return sn.resolvedType;
+            let declared = null;
+            if (sn.node.id.type === "BinaryExpression") {
+                declared = typeFromTypespec(state, sn.node.id.right, sn.stack);
+            }
             if (sn.node.kind === "const" && sn.node.init) {
-                let node = sn.node.init;
-                if (node.type === "Literal") {
-                    return typeFromLiteral(node);
+                if (hasProperty(sn, "resolvedType")) {
+                    // The constant is defined recursively
+                    return declared ?? { type: 524287 /* TypeTag.Any */ };
+                }
+                // set the marker in case the constant appears in its
+                // own initializer.
+                sn.resolvedType = undefined;
+                const stack = state.stack;
+                let resolved;
+                try {
+                    state.stack = sn.stack;
+                    resolved = evaluateExpr(state, sn.node.init).value;
                 }
-                while (node.type === "BinaryExpression" && node.operator === "as") {
-                    node = node.left;
+                finally {
+                    state.stack = stack;
                 }
-                if (node.type === "Literal" ||
-                    (node.type === "UnaryExpression" && node.operator === ":")) {
-                    return evaluateExpr(state, sn.node.init).value;
+                if (resolved.type === 0 /* TypeTag.Never */) {
+                    resolved = declared ?? { type: 524287 /* TypeTag.Any */ };
                 }
+                else if (declared) {
+                    resolved = intersection(resolved, declared);
+                    if (resolved.type === 0 /* TypeTag.Never */) {
+                        resolved = declared;
+                    }
+                }
+                sn.resolvedType = resolved;
+                return resolved;
             }
             if (sn.node.id.type === "BinaryExpression") {
                 return typeFromTypespec(state, sn.node.id.right, sn.stack);
             }
             return { type: 524287 /* TypeTag.Any */ };
+        }
     }
     throw new Error(`Internal error: Unexpected StateNodeDecl.type: ${sn.type}`);
 }
@@ -9742,7 +9794,7 @@ function castType(type, target) {
             // Number or Long operands to '&', '|', and '^' are coerced
             // to boolean if the other argument is boolean.
             if (type.type & (8 /* TypeTag.Number */ | 16 /* TypeTag.Long */)) {
-                result.type = type.value == 0 ? 2 /* TypeTag.False */ : 4 /* TypeTag.True */;
+                result.type = Number(type.value) === 0 ? 2 /* TypeTag.False */ : 4 /* TypeTag.True */;
                 return result;
             }
         }
@@ -9760,15 +9812,15 @@ const TruthyTypes = 4 /* TypeTag.True */ |
 function mustBeTrue(arg) {
     return (((arg.type === 8 /* TypeTag.Number */ || arg.type === 16 /* TypeTag.Long */) &&
         arg.value != null &&
-        arg.value != 0) ||
-        ((arg.type & TruthyTypes) != 0 && (arg.type & ~TruthyTypes) == 0));
+        Number(arg.value) !== 0) ||
+        ((arg.type & TruthyTypes) !== 0 && (arg.type & ~TruthyTypes) === 0));
 }
 function mustBeFalse(arg) {
     return (arg.type === 1 /* TypeTag.Null */ ||
         arg.type === 2 /* TypeTag.False */ ||
         ((arg.type === 8 /* TypeTag.Number */ || arg.type === 16 /* TypeTag.Long */) &&
             arg.value != null &&
-            arg.value == 0));
+            Number(arg.value) === 0));
 }
 function display(type) {
     const names = (v, fn) => (0,external_util_cjs_namespaceObject.map)(v, fn)
@@ -9869,7 +9921,7 @@ function display(type) {
 }
 function hasUnionData(tag) {
     tag &= UnionDataTypeTagsConst;
-    return (tag & (tag - 1)) != 0;
+    return (tag & (tag - 1)) !== 0;
 }
 function getObjectValue(t) {
     if (!(t.type & 32768 /* TypeTag.Object */) || t.value == null)
@@ -9903,7 +9955,7 @@ function forEachUnionComponent(v, bits, fn) {
             : bit & v.type
                 ? v.value
                 : null;
-        if (fn(bit, data) === false)
+        if (fn({ type: bit, value: data }) === false)
             break;
         bits = next;
     } while (bits);
@@ -9945,27 +9997,30 @@ function getStateNodeDeclsFromType(state, object) {
     const decls = [];
     if (object.value != null &&
         object.type & (4096 /* TypeTag.Module */ | 16384 /* TypeTag.Class */ | 32768 /* TypeTag.Object */)) {
-        forEachUnionComponent(object, object.type & (4096 /* TypeTag.Module */ | 16384 /* TypeTag.Class */ | 32768 /* TypeTag.Object */), (tag, value) => {
-            if (!value)
+        forEachUnionComponent(object, object.type & (4096 /* TypeTag.Module */ | 16384 /* TypeTag.Class */ | 32768 /* TypeTag.Object */), (type) => {
+            if (type.value == null)
                 return;
-            if (tag === 32768 /* TypeTag.Object */) {
-                const ovalue = value;
-                if (ovalue.klass.type === 16384 /* TypeTag.Class */ && ovalue.klass.value) {
-                    if (Array.isArray(ovalue.klass.value)) {
-                        decls.push(...ovalue.klass.value);
+            switch (type.type) {
+                case 32768 /* TypeTag.Object */:
+                    if (type.value.klass.type === 16384 /* TypeTag.Class */ &&
+                        type.value.klass.value) {
+                        if (Array.isArray(type.value.klass.value)) {
+                            decls.push(...type.value.klass.value);
+                        }
+                        else {
+                            decls.push(type.value.klass.value);
+                        }
+                    }
+                    break;
+                case 4096 /* TypeTag.Module */:
+                case 16384 /* TypeTag.Class */:
+                    if (Array.isArray(type.value)) {
+                        decls.push(...type.value);
                     }
                     else {
-                        decls.push(ovalue.klass.value);
+                        decls.push(type.value);
                     }
-                }
-            }
-            else {
-                if (Array.isArray(value)) {
-                    decls.push(...value);
-                }
-                else {
-                    decls.push(value);
-                }
+                    break;
             }
         });
     }
@@ -10014,15 +10069,15 @@ function couldBe(a, b) {
             return true;
         }
         let result = false;
-        forEachUnionComponent(a, common, (bit, avalue) => {
-            if (avalue == null) {
+        forEachUnionComponent(a, common, (ac) => {
+            if (ac.value == null) {
                 result = true;
                 return false;
             }
-            const bvalue = getUnionComponent(b, bit);
+            const bvalue = getUnionComponent(b, ac.type);
             if (bvalue == null ||
-                avalue === bvalue ||
-                couldBeValue(bit, avalue, bvalue)) {
+                ac.value === bvalue ||
+                couldBeValue({ type: ac.type, avalue: ac.value, bvalue })) {
                 result = true;
                 return false;
             }
@@ -10077,13 +10132,13 @@ function couldBeWeak(a, b) {
         return true;
     return couldBe(a, b);
 }
-function couldBeValue(bit, avalue, bvalue) {
-    switch (bit) {
+function couldBeValue(pair) {
+    switch (pair.type) {
         case 1 /* TypeTag.Null */:
         case 2 /* TypeTag.False */:
         case 4 /* TypeTag.True */:
         case 262144 /* TypeTag.Typedef */:
-            throw new Error(`Unexpected TypeTag '${typeTagName(bit)}'`);
+            throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
         case 8 /* TypeTag.Number */:
         case 16 /* TypeTag.Long */:
         case 32 /* TypeTag.Float */:
@@ -10091,34 +10146,27 @@ function couldBeValue(bit, avalue, bvalue) {
         case 256 /* TypeTag.String */:
         case 128 /* TypeTag.Char */:
         case 131072 /* TypeTag.Symbol */:
-            return avalue === bvalue;
+            return pair.avalue === pair.bvalue;
         case 512 /* TypeTag.Array */:
-            return couldBe(avalue, bvalue);
+            return couldBe(pair.avalue, pair.bvalue);
         case 1024 /* TypeTag.Dictionary */: {
-            const adict = avalue;
-            const bdict = bvalue;
-            return couldBe(adict.key, bdict.key) && couldBe(adict.value, bdict.value);
+            return (couldBe(pair.avalue.key, pair.bvalue.key) &&
+                couldBe(pair.avalue.value, pair.bvalue.value));
         }
         case 2048 /* TypeTag.Method */: {
-            const ameth = avalue;
-            const bmeth = bvalue;
-            return (ameth.args.length === bmeth.args.length &&
-                couldBe(ameth.result, bmeth.result) &&
-                ameth.args.every((arg, i) => couldBe(arg, bmeth.args[i])));
+            return (pair.avalue.args.length === pair.bvalue.args.length &&
+                couldBe(pair.avalue.result, pair.bvalue.result) &&
+                pair.avalue.args.every((arg, i) => couldBe(arg, pair.bvalue.args[i])));
         }
         case 4096 /* TypeTag.Module */:
         case 8192 /* TypeTag.Function */: {
-            const asd = avalue;
-            const bsd = bvalue;
             // quadratic :-(
-            return (0,external_util_cjs_namespaceObject.some)(asd, (sna) => (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => sna === snb));
+            return (0,external_util_cjs_namespaceObject.some)(pair.avalue, (sna) => (0,external_util_cjs_namespaceObject.some)(pair.bvalue, (snb) => sna === snb));
         }
         case 16384 /* TypeTag.Class */: {
-            const asd = avalue;
-            const bsd = bvalue;
-            return (0,external_util_cjs_namespaceObject.some)(asd, (sna) => {
+            return (0,external_util_cjs_namespaceObject.some)(pair.avalue, (sna) => {
                 const superA = (0,external_api_cjs_namespaceObject.getSuperClasses)(sna);
-                return (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => {
+                return (0,external_util_cjs_namespaceObject.some)(pair.bvalue, (snb) => {
                     if (sna === snb || (superA && superA.has(snb))) {
                         return true;
                     }
@@ -10128,18 +10176,17 @@ function couldBeValue(bit, avalue, bvalue) {
             });
         }
         case 32768 /* TypeTag.Object */: {
-            const aobj = avalue;
-            const bobj = bvalue;
-            return couldBe(aobj.klass, bobj.klass) && couldBeObj(aobj.obj, bobj.obj);
+            return (couldBe(pair.avalue.klass, pair.bvalue.klass) &&
+                couldBeObj(pair.avalue.obj, pair.bvalue.obj));
         }
         case 65536 /* TypeTag.Enum */: {
-            const aenum = avalue;
-            const benum = bvalue;
-            return (aenum.enum === benum.enum &&
-                (!aenum.value || !benum.value || couldBe(aenum.value, benum.value)));
+            return (pair.avalue.enum === pair.bvalue.enum &&
+                (!pair.avalue.value ||
+                    !pair.bvalue.value ||
+                    couldBe(pair.avalue.value, pair.bvalue.value)));
         }
         default:
-            unhandledType(bit);
+            unhandledType(pair);
     }
 }
 function couldBeObj(a, b) {
@@ -10255,16 +10302,17 @@ function equalsCheck(left, right) {
     // Note that each type can only have a single bit set. This is important!
     const lrBits = left.type | right.type;
     return left.type & 120 /* TypeTag.Numeric */ && right.type & 120 /* TypeTag.Numeric */
-        ? left.value == right.value
-        : lrBits == (8 /* TypeTag.Number */ | 128 /* TypeTag.Char */)
+        ? // eslint-disable-next-line eqeqeq
+            left.value == right.value
+        : lrBits === (8 /* TypeTag.Number */ | 128 /* TypeTag.Char */)
             ? // Char vs Number is true iff the number is the char-code of the char
                 left.type === 128 /* TypeTag.Char */
                     ? left.value.charCodeAt(0) === right.value
                     : left.value === right.value.charCodeAt(0)
-            : left.type == 8 /* TypeTag.Number */ && right.type & 6 /* TypeTag.Boolean */
-                ? left.value == (right.value ? 1 : 0)
-                : right.type == 8 /* TypeTag.Number */ && left.type & 6 /* TypeTag.Boolean */
-                    ? right.value == (left.value ? 1 : 0)
+            : left.type === 8 /* TypeTag.Number */ && right.type & 6 /* TypeTag.Boolean */
+                ? left.value === (right.value ? 1 : 0)
+                : right.type === 8 /* TypeTag.Number */ && left.type & 6 /* TypeTag.Boolean */
+                    ? right.value === (left.value ? 1 : 0)
                     : left.type !== right.type
                         ? lrBits & 1 /* TypeTag.Null */
                             ? lrBits & (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */)
@@ -10330,7 +10378,7 @@ function evaluateBinaryTypes(op, left, right) {
             "/": {
                 allowed: 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */ | 32 /* TypeTag.Float */ | 64 /* TypeTag.Double */,
                 typeFn: common_types,
-                valueFn: (left, right) => right.value == 0 // "==" because it could be a bigint
+                valueFn: (left, right) => Number(right.value) === 0
                     ? { type: left.type }
                     : left.type === 8 /* TypeTag.Number */
                         ? {
@@ -10345,7 +10393,7 @@ function evaluateBinaryTypes(op, left, right) {
             "%": {
                 allowed: 8 /* TypeTag.Number */ | 16 /* TypeTag.Long */,
                 typeFn: common_types,
-                valueFn: (left, right) => right.value == 0 // "==" because it could be a bigint
+                valueFn: (left, right) => Number(right.value) === 0
                     ? { type: left.type }
                     : {
                         type: left.type,
@@ -11179,9 +11227,9 @@ function getLhsConstraint(istate, node) {
         }
         const object = istate.typeMap.get(node.object);
         if (object && !node.computed) {
-            const objDecls = findObjectDeclsByProperty(istate, object, node);
-            if (objDecls) {
-                lookupDefs = (0,external_api_cjs_namespaceObject.lookupNext)(istate.state, [{ parent: null, results: objDecls }], "decls", node.property);
+            const [, trueDecls] = findObjectDeclsByProperty(istate.state, object, node);
+            if (trueDecls) {
+                lookupDefs = (0,external_api_cjs_namespaceObject.lookupNext)(istate.state, [{ parent: null, results: trueDecls }], "decls", node.property);
             }
         }
     }
@@ -11242,6 +11290,17 @@ function pushScopedNameType(istate, node, object) {
         node,
     });
 }
+function byteArrayType(state) {
+    return {
+        type: 32768 /* TypeTag.Object */,
+        value: {
+            klass: {
+                type: 16384 /* TypeTag.Class */,
+                value: lookupByFullName(state, "Toybox.Lang.ByteArray"),
+            },
+        },
+    };
+}
 function evaluateNode(istate, node) {
     const { state, stack } = istate;
     const push = (item) => {
@@ -11268,7 +11327,9 @@ function evaluateNode(istate, node) {
                 // garmin's type checker.
                 if (subtypeOf(left.value, right.value) &&
                     !subtypeOf({ type: 1 /* TypeTag.Null */ | 32768 /* TypeTag.Object */ }, right.value) &&
-                    (!(left.value.type & 65536 /* TypeTag.Enum */) || right.value.type & 65536 /* TypeTag.Enum */)) {
+                    (!(left.value.type & 65536 /* TypeTag.Enum */) ||
+                        right.value.type & 65536 /* TypeTag.Enum */) &&
+                    !couldBe({ type: 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */ }, left.value)) {
                     push({
                         value: left.value,
                         embeddedEffects: left.embeddedEffects,
@@ -11280,7 +11341,7 @@ function evaluateNode(istate, node) {
                     (0,external_api_cjs_namespaceObject.diagnostic)(istate.state, node, `The type ${display(left.value)} cannot be converted to ${display(right.value)} because they have nothing in common`, istate.checkTypes);
                 }
                 if (hasValue(right.value) && right.value.type === 65536 /* TypeTag.Enum */) {
-                    if ((left.value.type & EnumTagsConst) == left.value.type) {
+                    if ((left.value.type & EnumTagsConst) === left.value.type) {
                         const result = cloneType(right.value);
                         result.value = { ...result.value, value: left.value };
                         stack.push({
@@ -11299,7 +11360,7 @@ function evaluateNode(istate, node) {
             }
             else {
                 if (istate.checkTypes &&
-                    (node.operator === "==" || node.operator == "!=") &&
+                    (node.operator === "==" || node.operator === "!=") &&
                     ((left.value.type === 1 /* TypeTag.Null */ &&
                         !(right.value.type & 1 /* TypeTag.Null */)) ||
                         (right.value.type === 1 /* TypeTag.Null */ &&
@@ -11339,7 +11400,10 @@ function evaluateNode(istate, node) {
         case "SizedArrayExpression": {
             const arg = popIstate(istate, node.size);
             let type = { type: 512 /* TypeTag.Array */ };
-            if (node.ts) {
+            if (node.byte) {
+                type = byteArrayType(state);
+            }
+            else if (node.ts) {
                 type = typeFromSingleTypeSpec(istate.state, node.ts);
                 if (type.type !== 512 /* TypeTag.Array */) {
                     type = { type: 512 /* TypeTag.Array */, value: type };
@@ -11359,15 +11423,7 @@ function evaluateNode(istate, node) {
             const embeddedEffects = args.some((arg) => arg.embeddedEffects);
             if (node.byte) {
                 push({
-                    value: {
-                        type: 32768 /* TypeTag.Object */,
-                        value: {
-                            klass: {
-                                type: 16384 /* TypeTag.Class */,
-                                value: lookupByFullName(state, "Toybox.Lang.ByteArray"),
-                            },
-                        },
-                    },
+                    value: byteArrayType(state),
                     embeddedEffects,
                     node,
                 });
@@ -11551,6 +11607,13 @@ function evaluateNode(istate, node) {
                     node,
                 });
             }
+            else {
+                push({
+                    value: { type: 1 /* TypeTag.Null */ },
+                    embeddedEffects: false,
+                    node,
+                });
+            }
             break;
         }
         case "AssignmentExpression": {
@@ -11869,7 +11932,7 @@ function getEquivSet(ts, k) {
         }
         keys.add(s);
         s = next.equivSet.next;
-    } while (s != k);
+    } while (s !== k);
     return keys;
 }
 function intersectEquiv(ts1, ts2, k) {
@@ -11894,7 +11957,7 @@ function intersectEquiv(ts1, ts2, k) {
             removeEquiv(ts1, s);
         }
         s = next.equivSet.next;
-    } while (s != k);
+    } while (s !== k);
     return ret;
 }
 function mergeTypeState(blockStates, blockVisits, index, from) {
@@ -11954,7 +12017,7 @@ function tsEquivs(state, key) {
             throw new Error(`Inconsistent equivSet for ${tsKey(key)}: missing value for ${tsKey(s)}`);
         }
         s = next.equivSet.next;
-    } while (s != key);
+    } while (s !== key);
     return `[(${result.join(", ")})]`;
 }
 function typeStateEntry(value, key) {
@@ -11970,45 +12033,115 @@ function printBlockState(block, state, indent = "") {
         console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state, key) : ""}`);
     });
 }
-function filterDecls(decls, possible) {
+/*
+ * We have an object, and a MemberExpression object.<name>
+ *  - decls are the StateNodes associated with the known type
+ *    of object.
+ *  - possible are all the StateNodes that declare <name>
+ *
+ * We want to find all the elements of possible which are
+ * "compatible" with decls, which tells us the set of things
+ * that object.<name> could correspond to, and also what that
+ * tells us about object.
+ *
+ * The return value is two arrays of StateNode. The first
+ * gives the refined type of object, and the second is the
+ * array of StateNodes that could declare <name>
+ */
+function filterDecls(decls, possible, name) {
     if (!possible)
-        return null;
-    return decls.reduce((cur, decl) => {
+        return [null, null];
+    const result = decls.reduce((cur, decl) => {
         const found = possible.reduce((flag, poss) => {
             if (decl === poss ||
-                (poss.type === "ClassDeclaration" &&
-                    (0,external_api_cjs_namespaceObject.getSuperClasses)(poss)?.has(decl)) ||
-                (decl.type === "ClassDeclaration" && (0,external_api_cjs_namespaceObject.getSuperClasses)(decl)?.has(poss))) {
-                if (!cur)
-                    cur = [poss];
-                else
-                    cur.push(poss);
+                (poss.type === "ClassDeclaration" && (0,external_api_cjs_namespaceObject.getSuperClasses)(poss)?.has(decl))) {
+                // poss extends decl, so decl must actually be a poss
+                // eg we know obj is an Object, and we call obj.toNumber
+                // so possible includes all the classes that declare toNumber
+                // so we can refine obj's type to the union of those types
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(poss);
+                cur[1].add(poss);
+                return true;
+            }
+            else if (decl.type === "ClassDeclaration" &&
+                (0,external_api_cjs_namespaceObject.getSuperClasses)(decl)?.has(poss)) {
+                // decl extends poss, so decl remains unchanged
+                // eg we know obj is Menu2, we call obj.toString
+                // Menu2 doesn't define toString, but Object does
+                // so poss is Object. But we still know that
+                // obj is Menu2
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(decl);
+                cur[1].add(poss);
                 return true;
             }
             return flag;
         }, false);
         if (!found) {
-            possible.some((poss) => {
-                if (decl.stack?.some((sn) => sn.decls === poss.decls)) {
-                    if (!cur)
-                        cur = [poss];
-                    else
-                        cur.push(poss);
-                    return true;
-                }
-                return false;
-            });
+            // If we didn't find the property in any of the
+            // standard places, the runtime might still find
+            // it by searching up the Module stack (and up
+            // the module stack from any super classes)
+            //
+            // eg
+            //
+            //  obj = Application.getApp();
+            //  obj.Properties.whatever
+            //
+            // Properties doesn't exist on AppBase, but AppBase
+            // is declared in Application, and Application
+            // does declare Properties. So Application.Properties
+            // is (one of) the declarations we should find; but we
+            // must not refine obj's type to include Application.
+            let d = [decl];
+            do {
+                d.forEach((d) => {
+                    const stack = d.stack;
+                    possible.forEach((poss) => {
+                        for (let i = stack.length; i--;) {
+                            const sn = stack[i];
+                            if (sn.decls === poss.decls) {
+                                if (!cur[0]) {
+                                    cur = [new Set(), new Set()];
+                                }
+                                cur[0].add(decl);
+                                cur[1].add(poss);
+                                break;
+                            }
+                            if ((0,external_api_cjs_namespaceObject.hasProperty)(sn.decls, name)) {
+                                break;
+                            }
+                        }
+                    });
+                });
+                d = d.flatMap((d) => {
+                    if (d.type !== "ClassDeclaration" ||
+                        !d.superClass ||
+                        d.superClass === true) {
+                        return [];
+                    }
+                    return d.superClass;
+                });
+            } while (d.length);
         }
         return cur;
-    }, null);
+    }, [null, null]);
+    if (!result[0])
+        return [null, null];
+    return [Array.from(result[0]), Array.from(result[1])];
 }
-function findObjectDeclsByProperty(istate, object, next) {
-    const decls = getStateNodeDeclsFromType(istate.state, object);
+function findObjectDeclsByProperty(state, object, next) {
+    const decls = getStateNodeDeclsFromType(state, object);
     if (!decls)
-        return null;
-    const possibleDecls = (0,external_api_cjs_namespaceObject.hasProperty)(istate.state.allDeclarations, next.property.name) &&
-        istate.state.allDeclarations[next.property.name];
-    return filterDecls(decls, possibleDecls);
+        return [null, null];
+    const possibleDecls = (0,external_api_cjs_namespaceObject.hasProperty)(state.allDeclarations, next.property.name) &&
+        state.allDeclarations[next.property.name];
+    return filterDecls(decls, possibleDecls, next.property.name);
 }
 function refineObjectTypeByDecls(istate, object, trueDecls) {
     const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
@@ -12024,13 +12157,13 @@ function findNextObjectType(istate, trueDecls, next) {
     }, { type: 0 /* TypeTag.Never */ });
 }
 function resolveDottedMember(istate, object, next) {
-    const decls = findObjectDeclsByProperty(istate, object, next);
-    if (!decls)
+    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, object, next);
+    if (!objDecls)
         return null;
-    const property = findNextObjectType(istate, decls, next);
+    const property = findNextObjectType(istate, trueDecls, next);
     if (!property)
         return null;
-    const type = refineObjectTypeByDecls(istate, object, decls);
+    const type = refineObjectTypeByDecls(istate, object, objDecls);
     const mayThrow = !subtypeOf(object, type);
     return { mayThrow, object: type, property };
 }
@@ -12067,12 +12200,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     next = value.obj[me.property.name];
                 }
                 else {
-                    const trueDecls = findObjectDeclsByProperty(istate, cur, me);
-                    if (!trueDecls ||
-                        (0,external_util_cjs_namespaceObject.some)(trueDecls, (decl) => decl.type !== "ClassDeclaration")) {
+                    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, cur, me);
+                    if (!objDecls) {
                         return null;
                     }
-                    cur = refineObjectTypeByDecls(istate, cur, trueDecls);
+                    cur = refineObjectTypeByDecls(istate, cur, objDecls);
                     next = findNextObjectType(istate, trueDecls, me);
                 }
             }
@@ -12389,10 +12521,10 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                                         type: 32768 /* TypeTag.Object */,
                                         value: leftValue,
                                     });
-                                    const leftReduced = leftDecls.filter((ldec) => !rightDecls.every((rdec) => ldec == rdec ||
+                                    const leftReduced = leftDecls.filter((ldec) => !rightDecls.every((rdec) => ldec === rdec ||
                                         (ldec.type === "ClassDeclaration" &&
                                             (0,external_api_cjs_namespaceObject.getSuperClasses)(ldec)?.has(rdec))));
-                                    if (leftReduced.length != leftDecls.length) {
+                                    if (leftReduced.length !== leftDecls.length) {
                                         result = cloneType(left);
                                         clearValuesUnder(result, 32768 /* TypeTag.Object */, true);
                                         if (leftReduced.length) {
@@ -13033,7 +13165,15 @@ function beforeEvaluate(istate, node) {
             break;
         }
         case "ForStatement": {
-            if (node.init?.type === "Literal") {
+            if (node.update?.type === "Literal" ||
+                (node.update?.type === "SequenceExpression" &&
+                    node.update.expressions.length === 0)) {
+                popIstate(istate, node.update);
+                delete node.update;
+            }
+            if (node.init?.type === "Literal" ||
+                (node.init?.type === "SequenceExpression" &&
+                    node.init.expressions.length === 0)) {
                 delete node.init;
                 const depth = -1 - (node.update ? 1 : 0) - (node.test ? 1 : 0);
                 istate.stack.splice(depth, 1);
@@ -13057,7 +13197,7 @@ function beforeEvaluate(istate, node) {
             for (let i = node.expressions.length; i--;) {
                 const expr = node.expressions[i];
                 if (expr.type === "Literal") {
-                    istate.stack.splice(i - node.expressions.length);
+                    istate.stack.splice(i - node.expressions.length, 1);
                     node.expressions.splice(i, 1);
                 }
             }
@@ -13411,7 +13551,7 @@ function cleanupUnusedVars(state, node) {
     if (parent.node !== node) {
         return false;
     }
-    if (parent.type != "BlockStatement") {
+    if (parent.type !== "BlockStatement") {
         throw new Error(`Unexpected parent type '${parent.type}' for local declaration`);
     }
     if (!parent.decls)
@@ -13767,14 +13907,14 @@ async function analyze(fnMap, resourcesMap, manifestXML, config) {
                 const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
                 if (excludeAnnotations) {
                     return node.attrs.attributes.elements.reduce((drop, attr) => {
-                        if (attr.type != "UnaryExpression")
+                        if (attr.type !== "UnaryExpression")
                             return drop;
-                        if (attr.argument.type != "Identifier")
+                        if (attr.argument.type !== "Identifier")
                             return drop;
                         if ((0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name)) {
                             return true;
                         }
-                        if (attr.argument.name == "test") {
+                        if (attr.argument.name === "test") {
                             hasTests = true;
                         }
                         return drop;
@@ -13790,7 +13930,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config) {
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
                     scope.stack = state.stackClone().slice(0, -1);
-                    if (scope.type == "FunctionDeclaration") {
+                    if (scope.type === "FunctionDeclaration") {
                         if (markApi) {
                             node.body = null;
                             scope.info = (0,external_api_cjs_namespaceObject.getApiFunctionInfo)(state, scope);
@@ -13956,7 +14096,7 @@ function optimizeNode(istate, node) {
 function evaluateFunction(istate, func, args) {
     if (!func.body ||
         istate.state.inlining ||
-        (args && args.length != func.params.length)) {
+        (args && args.length !== func.params.length)) {
         return false;
     }
     const paramValues = args &&
@@ -14051,11 +14191,11 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         if (func.attrs &&
             func.attrs.attributes &&
             func.attrs.attributes.elements.some((attr) => {
-                if (attr.type != "UnaryExpression")
+                if (attr.type !== "UnaryExpression")
                     return false;
-                if (attr.argument.type != "Identifier")
+                if (attr.argument.type !== "Identifier")
                     return false;
-                return attr.argument.name == "test";
+                return attr.argument.name === "test";
             })) {
             return true;
         }
@@ -14072,7 +14212,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         (elm.superClass != null &&
             elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
                 sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
-                    f.type == "FunctionDeclaration" &&
+                    f.type === "FunctionDeclaration" &&
                     maybeCalled(f.node))) ||
                 (sc.superClass && checkInherited(sc, name))));
     const renamer = (idnode) => {
@@ -14255,7 +14395,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 }
                 state.currentFunction = self;
                 const is = !state.config?.propagateTypes ||
-                    node.attrs?.attributes?.elements.find((attr) => attr.type == "UnaryExpression" &&
+                    node.attrs?.attributes?.elements.find((attr) => attr.type === "UnaryExpression" &&
                         attr.argument.name === "noConstProp")
                     ? null
                     : type_flow_buildTypeInfo(state, state.currentFunction, true);
@@ -14276,9 +14416,9 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     }
                     istate = is;
                 }
-                if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
+                if (parent.type === "ClassDeclaration" && !maybeCalled(node)) {
                     let used = false;
-                    if (node.id.name == "initialize") {
+                    if (node.id.name === "initialize") {
                         used = true;
                     }
                     else if (parent.superClass) {
@@ -14395,7 +14535,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                             const inlined = optimizeCallHelper(istate, call, decl);
                             if (!inlined)
                                 continue;
-                            if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
+                            if (Array.isArray(inlined) || inlined.type !== "BlockStatement") {
                                 throw new Error("Unexpected inlined result");
                             }
                             if (!results) {
@@ -14435,7 +14575,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                                 ok = true;
                             }
                         }
-                        if (!ok && node.expression.operator == "=") {
+                        if (!ok && node.expression.operator === "=") {
                             const [, result] = state.lookup(node.expression.left);
                             ok = !!result;
                         }
@@ -14588,6 +14728,22 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         });
     });
     reportMissingSymbols(state, config);
+    if (state.inlineDiagnostics) {
+        if (!state.diagnostics) {
+            state.diagnostics = state.inlineDiagnostics;
+        }
+        else {
+            Object.entries(state.inlineDiagnostics).forEach(([key, diags]) => {
+                if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, key)) {
+                    state.diagnostics[key] = diags;
+                }
+                else {
+                    state.diagnostics[key].push(...diags);
+                }
+            });
+        }
+        delete state.inlineDiagnostics;
+    }
     Object.entries(fnMap).forEach(([name, f]) => {
         if (state.config && state.config.checkBuildPragmas) {
             pragmaChecker(state, f.ast, state.diagnostics?.[name]);
@@ -14625,7 +14781,7 @@ function optimizeCall(istate, node, context) {
     if (state.currentFunction) {
         recordCalledFuncs(state.currentFunction, callees);
     }
-    if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
+    if (callees.length === 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
         if (!context &&
             callee.optimizable &&
@@ -14826,7 +14982,7 @@ async function createLocalBarrels(targets, options) {
             }
             if (optBarrels[barrel].manifest !== manifest ||
                 optBarrels[barrel].optBarrelDir !== optBarrelDir ||
-                optBarrels[barrel].rawBarrelDir != rawBarrelDir) {
+                optBarrels[barrel].rawBarrelDir !== rawBarrelDir) {
                 throw new Error(`For device ${target.product}, barrel ${barrel} was mapped to both ${external_path_.relative(optBarrels[barrel].rawBarrelDir, optBarrels[barrel].manifest)} in ${optBarrels[barrel].rawBarrelDir} and ${external_path_.relative(rawBarrelDir, manifest)} in ${rawBarrelDir}.`);
             }
             optBarrels[barrel].jungleFiles.push(...rawJungles);
@@ -15160,16 +15316,16 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
     if (hasTests != null &&
         !config.checkBuildPragmas &&
         configOptionsToCheck.every((option) => prevOptions[option] === config[option]) &&
-        actualOptimizedFiles.length == Object.values(fnMap).length &&
+        actualOptimizedFiles.length === Object.values(fnMap).length &&
         Object.values(fnMap)
             .map((v) => v.output)
             .sort()
-            .every((f, i) => f == actualOptimizedFiles[i])) {
+            .every((f, i) => f === actualOptimizedFiles[i])) {
         // now if the newest source file is older than
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1674436813829 < opt_time) {
+        if (source_time < opt_time && 1674683508654 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -15196,7 +15352,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.1.3",
+                optimizerVersion: "1.1.5",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));
@@ -15249,6 +15405,7 @@ async function getProjectAnalysis(targets, analysis, manifestXML, options) {
     });
     const state = await analyze(fnMap, resourcesMap, manifestXML, options);
     reportMissingSymbols(state, options);
+    let typeMap = null;
     if (state.config?.propagateTypes &&
         state.config.trustDeclaredTypes &&
         state.config.checkTypes !== "OFF" &&
@@ -15271,6 +15428,14 @@ async function getProjectAnalysis(targets, analysis, manifestXML, options) {
                         istate.typeChecker = gistate.typeChecker;
                         istate.checkTypes = gistate.checkTypes;
                         interp_evaluate(istate, node.body);
+                        if (istate.typeMap) {
+                            if (typeMap == null) {
+                                typeMap = istate.typeMap;
+                            }
+                            else {
+                                istate.typeMap.forEach((value, key) => typeMap.set(key, value));
+                            }
+                        }
                     }
                     return [];
                 }
@@ -15280,8 +15445,9 @@ async function getProjectAnalysis(targets, analysis, manifestXML, options) {
         Object.values(state.fnMap).forEach((f) => {
             (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
         });
+        delete state.pre;
     }
-    return { fnMap: fnMap, paths, state };
+    return { fnMap: fnMap, paths, state, typeMap };
 }
 /**
  *
@@ -15300,7 +15466,7 @@ async function generateApiMirTests(options) {
             Object.entries(node.decls).forEach(([key, decl]) => {
                 if (decl.length > 1)
                     throw `Bad decl length:${node.fullName}.${key}`;
-                if (decl.length != 1)
+                if (decl.length !== 1)
                     return;
                 const d = decl[0];
                 if (d.type === "EnumStringMember" ||