@markw65/monkeyc-optimizer 1.1.11 → 1.1.13

package/build/api.cjs

@@ -1507,9 +1507,10 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                             decl,
                             mayThrow,
                         };
-                        if (wantsAllRefs && node.operator === "=") {
-                            if (node.right.type === "Identifier" ||
-                                node.right.type === "MemberExpression") {
+                        if (wantsAllRefs) {
+                            if ((node.right.type === "Identifier" ||
+                                node.right.type === "MemberExpression") &&
+                                node.operator === "=") {
                                 const rhs = findDecl(node.right);
                                 if (rhs)
                                     def.rhs = rhs;
@@ -2757,13 +2758,15 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 /* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4859);
 /* harmony import */ var _type_flow_could_be__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(4055);
 /* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7161);
-/* harmony import */ var _type_flow_optimize__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(3687);
-/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(9234);
-/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(7255);
-/* harmony import */ var _unused_exprs__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(424);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_16__);
-/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(4405);
+/* harmony import */ var _type_flow_minimize_modules__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(4416);
+/* harmony import */ var _type_flow_optimize__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(3687);
+/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(9234);
+/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7255);
+/* harmony import */ var _unused_exprs__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(424);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_17__);
+/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(4405);
+
 
 
 
@@ -3369,32 +3372,30 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 break;
             case "Identifier": {
                 const map = topLocals().map;
-                if (map) {
-                    if (hasProperty(map, node.name)) {
-                        const name = map[node.name];
-                        if (typeof name === "string") {
-                            renameIdentifier(node, name);
-                        }
-                        const [, results] = state.lookupValue(node);
-                        if (results) {
-                            if (results.length !== 1 || results[0].results.length !== 1) {
-                                throw new Error(`Local ${node.name} had multiple lookup results`);
-                            }
-                            const parent = results[0].parent;
-                            if (!parent) {
-                                throw new Error(`Local ${node.name} had no parent`);
-                            }
-                            const decl = results[0].results[0];
-                            if (parent.type === "FunctionDeclaration" ||
-                                decl.type !== "VariableDeclarator") {
-                                // we can't optimize away function or catch parameters
-                                return [];
-                            }
-                            if (parent.type !== "BlockStatement") {
-                                throw new Error(`Local ${node.name} was not declared at block scope(??)`);
-                            }
-                            decl.used = true;
+                if (hasProperty(map, node.name)) {
+                    const name = map[node.name];
+                    if (typeof name === "string") {
+                        renameIdentifier(node, name);
+                    }
+                    const [, results] = state.lookupValue(node);
+                    if (results) {
+                        if (results.length !== 1 || results[0].results.length !== 1) {
+                            throw new Error(`Local ${node.name} had multiple lookup results`);
+                        }
+                        const parent = results[0].parent;
+                        if (!parent) {
+                            throw new Error(`Local ${node.name} had no parent`);
+                        }
+                        const decl = results[0].results[0];
+                        if (parent.type === "FunctionDeclaration" ||
+                            decl.type !== "VariableDeclarator") {
+                            // we can't optimize away function or catch parameters
+                            return [];
                         }
+                        if (parent.type !== "BlockStatement") {
+                            throw new Error(`Local ${node.name} was not declared at block scope(??)`);
+                        }
+                        decl.used = true;
                     }
                 }
                 return [];
@@ -3682,6 +3683,11 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     state.nextExposed = {};
     delete state.pre;
     delete state.post;
+    if (state.config?.minimizeModules ?? true) {
+        Object.values(fnMap).forEach((f) => {
+            minimizeModules(f.ast, state);
+        });
+    }
     Object.values(state.allFunctions).forEach((fns) => fns.forEach((fn) => sizeBasedPRE(state, fn)));
     const cleanup = (node) => {
         switch (node.type) {
@@ -4025,7 +4031,7 @@ function pragmaChecker(state, ast, diagnostics) {
             if (kind === "match") {
                 const haystack = formatAst(node)
                     .replace(/([\r\n]|\s)+/g, " ")
-                    .replace(/\b\w+\s\/\*>(\w+)<\*\//g, "$1");
+                    .replace(/\b\w+\s\/\*>([\w.]+)<\*\//g, "$1");
                 if (!matcher(quote, needle, haystack)) {
                     matcher(quote, needle, haystack);
                     diagnostic(state, comment, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
@@ -4950,79 +4956,42 @@ function buildConflictGraph(state, func) {
 function addEquiv(ts, key, equiv) {
     if (key === equiv)
         return true;
-    let keyVal = ts.get(key);
-    let equivVal = ts.get(equiv);
+    const keyVal = ts.get(key);
+    const equivVal = ts.get(equiv);
     if (!keyVal || !equivVal)
         return false;
     if (equivVal.equivSet) {
-        if (keyVal.equivSet) {
-            // key is already a member of a set, see if
-            // equiv is part of it.
-            let s = keyVal.equivSet.next;
-            do {
-                if (s === equiv) {
-                    // these two are already equivalent
-                    return true;
-                }
-                const next = ts.get(s);
-                if (!next || !next.equivSet) {
-                    throw new Error(`Inconsistent equivSet for ${tsKey(key)}: missing value for ${tsKey(s)}`);
-                }
-                s = next.equivSet.next;
-            } while (s !== key);
+        if (equivVal.equivSet.has(key)) {
+            return true;
         }
         // equiv is already a member of a set. remove it
         removeEquiv(ts, equiv);
     }
     // equiv is not (or no longer) part of an equivSet
-    keyVal = { ...keyVal };
     if (!keyVal.equivSet) {
-        keyVal.equivSet = { next: key };
+        keyVal.equivSet = new Set([key, equiv]);
+    }
+    else {
+        keyVal.equivSet.add(equiv);
     }
-    equivVal = { ...equivVal, equivSet: keyVal.equivSet };
-    keyVal.equivSet = { next: equiv };
-    ts.set(key, keyVal);
-    ts.set(equiv, equivVal);
+    equivVal.equivSet = keyVal.equivSet;
     return false;
 }
 function removeEquiv(ts, equiv) {
     const equivVal = ts.get(equiv);
     if (!equivVal?.equivSet)
         return;
-    let s = equivVal.equivSet.next;
-    do {
-        const next = ts.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(equiv)}: missing value for ${tsKey(s)}`);
-        }
-        if (next.equivSet.next === equiv) {
-            const { equivSet: _e, ...rest } = next;
-            if (equivVal.equivSet.next === s) {
-                // this is a pair. just kill both
-                ts.set(s, rest);
-            }
-            else {
-                ts.set(s, { ...rest, equivSet: equivVal.equivSet });
-            }
-            break;
-        }
-        s = next.equivSet.next;
-    } while (true);
-    const newVal = { ...equivVal };
-    delete newVal.equivSet;
-    ts.set(equiv, newVal);
+    equivVal.equivSet.delete(equiv);
+    if (equivVal.equivSet.size === 1) {
+        const other = Array.from(equivVal.equivSet)[0];
+        const otherVal = ts.get(other);
+        delete otherVal.equivSet;
+    }
+    delete equivVal.equivSet;
 }
 function getEquivSet(ts, k) {
-    const keys = new Set();
-    let s = k;
-    do {
-        const next = ts.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(k)}: missing value for ${tsKey(s)}`);
-        }
-        keys.add(s);
-        s = next.equivSet.next;
-    } while (s !== k);
+    const keys = ts.get(k)?.equivSet;
+    assert(keys);
     return keys;
 }
 function intersectEquiv(ts1, ts2, k) {
@@ -5034,21 +5003,26 @@ function intersectEquiv(ts1, ts2, k) {
         removeEquiv(ts1, k);
         return true;
     }
-    const keys = getEquivSet(ts2, k);
-    let ret = false;
-    let s = eq1.equivSet.next;
-    do {
-        const next = ts1.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(k)}: missing value for ${tsKey(s)}`);
-        }
-        if (!keys.has(s)) {
-            ret = true;
-            removeEquiv(ts1, s);
+    let removed = null;
+    eq1.equivSet.forEach((key) => {
+        if (!eq2.equivSet.has(key)) {
+            eq1.equivSet.delete(key);
+            if (!removed) {
+                removed = new Set();
+            }
+            removed.add(key);
         }
-        s = next.equivSet.next;
-    } while (s !== k);
-    return ret;
+    });
+    if (eq1.equivSet.size === 1) {
+        assert(eq1.equivSet.has(k));
+        delete eq1.equivSet;
+    }
+    if (removed) {
+        removed.forEach((k) => removed.size === 1
+            ? delete ts1.get(k).equivSet
+            : (ts1.get(k).equivSet = removed));
+    }
+    return false;
 }
 function clearAssocPaths(blockState, decl, v) {
     if (v.assocPaths?.size) {
@@ -5066,6 +5040,17 @@ function clearAssocPaths(blockState, decl, v) {
 function cloneTypeState(blockState) {
     const { map, trackedMemberDecls, liveCopyPropEvents, ...rest } = blockState;
     const clone = { map: new Map(map), ...rest };
+    clone.map.forEach((value, key) => {
+        if (value.equivSet) {
+            if (key === Array.from(value.equivSet)[0]) {
+                const equivSet = new Set(value.equivSet);
+                equivSet.forEach((k) => clone.map.set(k, { ...clone.map.get(k), equivSet }));
+            }
+        }
+        else {
+            clone.map.set(key, { ...value });
+        }
+    });
     if (trackedMemberDecls) {
         clone.trackedMemberDecls = new Map();
         trackedMemberDecls.forEach((value, key) => {
@@ -5100,12 +5085,9 @@ function addCopyPropEvent(blockState, item) {
     const liveCopyPropEvents = blockState.liveCopyPropEvents;
     const decl = item.event.decl;
     assert(declIsLocal(decl));
-    let tov = blockState.map.get(decl);
+    const tov = blockState.map.get(decl);
     assert(tov);
-    if (tov.copyPropItem !== item) {
-        tov = { ...tov, copyPropItem: item };
-        blockState.map.set(decl, tov);
-    }
+    tov.copyPropItem = item;
     item.contained.forEach((value, key) => {
         const decls = liveCopyPropEvents.get(key);
         if (!decls) {
@@ -5138,15 +5120,13 @@ function clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp) {
     blockState.liveCopyPropEvents
         ?.get(decl)
         ?.forEach((cpDecl) => {
-        let value = blockState.map.get(cpDecl);
+        const value = blockState.map.get(cpDecl);
         assert(value && value.copyPropItem);
         assert(Array.from(value.copyPropItem.contained).some(([key]) => {
             return decl === key;
         }));
         copyPropFailed(blockState, value.copyPropItem, nodeCopyProp);
-        value = { ...value };
         delete value.copyPropItem;
-        blockState.map.set(cpDecl, value);
     });
 }
 function validateTypeState(curState) {
@@ -5189,11 +5169,9 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
         if (tov.equivSet) {
             if (intersectEquiv(to.map, from.map, k)) {
                 changes = true;
-                tov = to.map.get(k);
             }
         }
         if (tov.assocPaths) {
-            tov = { ...tov };
             if (!fromv.assocPaths) {
                 changes = true;
                 delete tov.assocPaths;
@@ -5216,7 +5194,6 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
                     delete tov.assocPaths;
                 }
             }
-            to.map.set(k, tov);
         }
         // if both from and to have copyPropEvents, we can only
         // keep it if they're the same event.
@@ -5234,10 +5211,8 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
                     }
                     nodeCopyProp.set(fromv.copyPropItem.event.node, false);
                 }
-                tov = { ...tov };
                 delete tov.copyPropItem;
                 changes = true;
-                to.map.set(k, tov);
             }
             else {
                 assert(k === tov.copyPropItem.event.decl);
@@ -5248,7 +5223,7 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
             if (subtypeOf(fromv.curType, tov.curType))
                 return;
             if (subtypeOf(tov.curType, fromv.curType)) {
-                to.map.set(k, { ...tov, curType: fromv.curType });
+                tov.curType = fromv.curType;
                 changes = true;
                 return;
             }
@@ -5261,22 +5236,11 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
             if (wide)
                 result = wide;
         }
-        to.map.set(k, { ...tov, curType: result });
+        tov.curType = result;
         changes = true;
     });
     return changes;
 }
-function tsEquivs(state, key) {
-    const result = [];
-    let s = key;
-    do {
-        result.push(tsKey(s));
-        const next = state.get(s);
-        assert(next && next.equivSet);
-        s = next.equivSet.next;
-    } while (s !== key);
-    return `[(${result.join(", ")})]`;
-}
 function typeStateEntry(value, key) {
     return `${tsKey(key)} = ${display(value.curType)}`;
 }
@@ -5287,7 +5251,9 @@ function printBlockState(block, state, indent = "") {
         return;
     }
     state.map.forEach((value, key) => {
-        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state.map, key) : ""}`);
+        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet
+            ? " " + `[(${Array.from(value.equivSet).map(tsKey).join(", ")})]`
+            : ""}`);
     });
 }
 function updateAffected(blockState, objectType, baseDecl, assignedPath, affectedName, affected, assignedType) {
@@ -5295,7 +5261,6 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
         let droppedComponents = null;
         const entry = blockState.map.get(key);
         assert(entry && entry.assocPaths);
-        let newEntry = entry;
         entry.assocPaths.forEach((path) => {
             if (key === baseDecl && path === assignedPath) {
                 return;
@@ -5314,12 +5279,9 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                 });
                 if (pathItem === affectedName && couldBeShallow(type, objectType)) {
                     const newAssocKey = assocPath.map((av) => av.name ?? "*").join(".");
-                    if (newEntry === entry) {
-                        newEntry = { ...entry };
-                    }
                     if (newAssocKey !== path) {
-                        newEntry.assocPaths = new Set(newEntry.assocPaths);
-                        newEntry.assocPaths.delete(path);
+                        entry.assocPaths = new Set(entry.assocPaths);
+                        entry.assocPaths.delete(path);
                         // the "extra" path components will also have entries
                         // in blockState.trackedMemberDecls. Since they're gone
                         // from here, we (may) need to remove them from there
@@ -5331,8 +5293,7 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                         }
                         break;
                     }
-                    const baseType = updateByAssocPath(assocPath, assignedType, true);
-                    newEntry.curType = baseType;
+                    entry.curType = updateByAssocPath(assocPath, assignedType, true);
                     break;
                 }
                 if (pathItem === "*") {
@@ -5362,14 +5323,11 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                 }
             }
         });
-        if (newEntry !== entry) {
-            if (droppedComponents) {
-                newEntry.assocPaths.forEach((path) => path
-                    .split(".")
-                    .forEach((pathComponent) => droppedComponents.delete(pathComponent)));
-                droppedComponents.forEach((pathComponent) => blockState.trackedMemberDecls.get(pathComponent).delete(key));
-            }
-            blockState.map.set(key, newEntry);
+        if (droppedComponents) {
+            entry.assocPaths.forEach((path) => path
+                .split(".")
+                .forEach((pathComponent) => droppedComponents.delete(pathComponent)));
+            droppedComponents.forEach((pathComponent) => blockState.trackedMemberDecls.get(pathComponent).delete(key));
         }
     });
 }
@@ -5476,10 +5434,9 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
         const assocKey = assocValue.map((av) => av.name ?? "*").join(".");
         const newType = updateByAssocPath(assocValue, next, false);
         setStateEvent(blockState, decl.base, newType, newValue ? 1 /* UpdateKind.Inner */ : 0 /* UpdateKind.None */);
-        const tsv = { ...blockState.map.get(decl.base) };
+        const tsv = blockState.map.get(decl.base);
         tsv.assocPaths = new Set(tsv.assocPaths);
         tsv.assocPaths.add(assocKey);
-        blockState.map.set(decl.base, tsv);
         addTrackedMemberDecl(blockState, decl.base, assocKey);
         if (newValue) {
             const baseElem = assocValue[decl.path.length - 1];
@@ -5557,38 +5514,39 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                 // that foo is side-effect free, and accesses no globals.
                 clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp);
             }
+            const v = blockState.map.get(decl);
+            if (!v) {
+                blockState.map.set(decl, { curType: value });
+                return;
+            }
             if (updateKind !== 2 /* UpdateKind.Reassign */) {
                 /*
                  * If we're not re-assigning, the equivalencies don't
                  * change, so this update must be applied to every
                  * element of the set
                  */
-                const v = blockState.map.get(decl);
-                if (v?.equivSet) {
-                    let s = decl;
-                    do {
+                if (v.equivSet) {
+                    v.equivSet.forEach((s) => {
                         const next = blockState.map.get(s);
-                        if (!next || !next.equivSet) {
-                            throw new Error(`Inconsistent equivSet for ${tsKey(decl)}: missing value for ${tsKey(s)}`);
-                        }
-                        blockState.map.set(s, { ...next, curType: value });
-                        s = next.equivSet.next;
-                    } while (s !== decl);
+                        assert(next && next.equivSet?.has(s));
+                        next.curType = value;
+                    });
                 }
                 else {
-                    blockState.map.set(decl, { ...v, curType: value });
+                    v.curType = value;
                 }
             }
             else {
-                const v = blockState.map.get(decl);
                 removeEquiv(blockState.map, decl);
-                if (v?.assocPaths?.size) {
+                if (v.assocPaths?.size) {
                     clearAssocPaths(blockState, decl, v);
+                    delete v.assocPaths;
                 }
-                if (v?.copyPropItem) {
+                if (v.copyPropItem) {
                     copyPropFailed(blockState, v.copyPropItem, nodeCopyProp);
+                    delete v.copyPropItem;
                 }
-                blockState.map.set(decl, { curType: value });
+                v.curType = value;
             }
             return;
         }
@@ -5922,7 +5880,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                 break;
             }
             case "ref": {
-                let curEntry = getStateEntry(curState, event.decl);
+                const curEntry = getStateEntry(curState, event.decl);
                 typeMap.set(event.node, curEntry.curType);
                 nodeEquivs.delete(event.node);
                 if (curEntry.equivSet) {
@@ -5946,9 +5904,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             nodeCopyProp.set(curEntry.copyPropItem.event.node, event.node);
                         }
                         clearCopyProp(curState, curEntry.copyPropItem);
-                        curEntry = { ...curEntry };
                         delete curEntry.copyPropItem;
-                        curState.map.set(event.decl, curEntry);
                     }
                     else if (declIsNonLocal(event.decl)) {
                         clearRelatedCopyPropEvents(curState, null, nodeCopyProp);
@@ -5986,12 +5942,13 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             }
                         });
                     }
+                    let calleeEffects;
                     curState.map.forEach((tsv, decl) => {
                         let type = tsv.curType;
-                        if (!some(decl, (d) => d.type === "VariableDeclarator" &&
-                            (d.node.kind === "var" ||
-                                // even a "const" could have its "inner" type altered
-                                (type.value != null && (type.type & 32768 /* TypeTag.Object */) !== 0)))) {
+                        if ((type.value == null ||
+                            !(type.type &
+                                (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */))) &&
+                            !some(decl, (d) => d.type === "VariableDeclarator" && !isLocal(d))) {
                             return;
                         }
                         if (modifiableDecl(decl, callees)) {
@@ -6007,9 +5964,14 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                             curState.map.set(decl, { curType: typeConstraint(decl) });
                         }
-                        else if (type.value != null &&
-                            (!callees || !every(callees, (callee) => callee.info === false))) {
-                            if (type.type & 32768 /* TypeTag.Object */) {
+                        else if (type.type &
+                            (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */) &&
+                            (calleeEffects == null
+                                ? (calleeEffects =
+                                    !callees ||
+                                        !every(callees, (callee) => callee.info === false))
+                                : calleeEffects)) {
+                            if (type.value != null && type.type & 32768 /* TypeTag.Object */) {
                                 const odata = getObjectValue(tsv.curType);
                                 if (odata?.obj) {
                                     type = cloneType(type);
@@ -6017,18 +5979,12 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                     setUnionComponent(type, 32768 /* TypeTag.Object */, newData);
                                     if (tsv.assocPaths) {
                                         clearAssocPaths(curState, decl, tsv);
-                                        tsv = { ...tsv };
                                         delete tsv.assocPaths;
                                     }
-                                    if (tsv.copyPropItem) {
-                                        copyPropFailed(curState, tsv.copyPropItem, nodeCopyProp);
-                                        tsv = { ...tsv };
-                                        delete tsv.copyPropItem;
-                                    }
-                                    clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
-                                    curState.map.set(decl, { ...tsv, curType: type });
+                                    tsv.curType = type;
                                 }
                             }
+                            clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                         }
                     });
                     return true;
@@ -6050,10 +6006,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                         (event.node.type !== "AssignmentExpression" ||
                             event.node.operator !== "=")) {
                         copyPropFailed(curState, before.copyPropItem, nodeCopyProp);
-                        const v = { ...before };
-                        delete v.copyPropItem;
-                        assert(isTypeStateKey(event.decl));
-                        curState.map.set(event.decl, v);
+                        delete before.copyPropItem;
                     }
                 }
                 const expr = event.node.type === "VariableDeclarator"
@@ -6147,22 +6100,41 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                             decl.type === "BinaryExpression" ||
                                             decl.type === "Identifier"))) {
                                     const key = event.decl ?? null;
-                                    if (key &&
-                                        declIsLocal(key) &&
-                                        nodeCopyProp.has(event.node)) {
-                                        // we might have
-                                        //
-                                        //   var x = foo();
-                                        //   var y = x + 1;
-                                        //   bar();
-                                        //   return y;
-                                        //
-                                        // In that case, its ok to drop "x = foo()" and rewrite as y = foo() + 1"
-                                        // OR its ok to drop "y = x + 1" and rewrite as "return x + 1".
-                                        // But we can't do both, and rewrite as "bar(); return foo() + 1;"
-                                        // So just disable copy prop for *this* node. We'll re-run and have a
-                                        // second chance later.
-                                        return false;
+                                    if (key && declIsLocal(key)) {
+                                        if (nodeCopyProp.has(event.node)) {
+                                            // we might have
+                                            //
+                                            //   var x = foo();
+                                            //   var y = x + 1;
+                                            //   bar();
+                                            //   return y;
+                                            //
+                                            // In that case, its ok to drop "x = foo()" and rewrite as y = foo() + 1"
+                                            // OR its ok to drop "y = x + 1" and rewrite as "return x + 1".
+                                            // But we can't do both, and rewrite as "bar(); return foo() + 1;"
+                                            // So just disable copy prop for *this* node. We'll re-run and have a
+                                            // second chance later.
+                                            return false;
+                                        }
+                                        else if (event.node.type === "AssignmentExpression" &&
+                                            event.node.operator !== "=" &&
+                                            nodeCopyProp.has(event.node.left)) {
+                                            // If we're copy proping into the lhs of an update
+                                            // assignment, we're going to have to rewrite it.
+                                            // similar to the above, don't also do forward copy
+                                            // prop. eg
+                                            //
+                                            //  var x = a + b;
+                                            //  x += c;
+                                            //  return x;
+                                            //
+                                            // becomes
+                                            //
+                                            //  var x;
+                                            //  x = (a + b) + c;
+                                            //  return x; // <- dont propagate to here (yet), in case a+b has changed.
+                                            return false;
+                                        }
                                     }
                                     const item = contained.get(key);
                                     if (!item) {
@@ -6351,7 +6323,22 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                     }
                 }
             }));
-        traverseAst(func.node.body, null, (node) => {
+        traverseAst(func.node.body, (node) => {
+            if (node.type === "AssignmentExpression" &&
+                node.operator !== "=" &&
+                nodeCopyProp.has(node.left)) {
+                const left = cloneDeep(node.left);
+                const right = withLoc({
+                    type: "BinaryExpression",
+                    operator: node.operator.slice(0, -1),
+                    left: withLocDeep(node.left, node.right, false, true),
+                    right: node.right,
+                }, node.left, node.right);
+                node.operator = "=";
+                node.left = left;
+                node.right = right;
+            }
+        }, (node) => {
             const copyNode = nodeCopyProp.get(node);
             if (copyNode) {
                 if (node.type === "AssignmentExpression") {
@@ -6370,10 +6357,18 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                     return dup;
                 }
                 if (copyNode.type === "AssignmentExpression") {
+                    const replacement = copyNode.operator === "="
+                        ? copyNode.right
+                        : {
+                            type: "BinaryExpression",
+                            operator: copyNode.operator.slice(0, -1),
+                            left: copyNode.left,
+                            right: copyNode.right,
+                        };
                     if (logThisRun) {
-                        console.log(`copy-prop ${formatAstLongLines(node)} => ${formatAstLongLines(copyNode.right)}`);
+                        console.log(`copy-prop ${formatAstLongLines(node)} => ${formatAstLongLines(replacement)}`);
                     }
-                    return withLocDeep(copyNode.right, node, node, false);
+                    return withLocDeep(replacement, node, node, false);
                 }
                 else if (copyNode.type === "VariableDeclarator") {
                     assert(copyNode.init);
@@ -6706,7 +6701,9 @@ function couldBeObj(a, b) {
 /* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
 /* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(333);
-/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1638);
+/* harmony import */ var _minimize_locals__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(736);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(1638);
+
 
 
 
@@ -6715,18 +6712,18 @@ function couldBeObj(a, b) {
 
 
 function cloneAnt(antMap) {
-    const ant = new Map();
-    antMap.forEach((s, k) => ant.set(k, new Set(s)));
-    return ant;
+    return new Map(antMap);
 }
 function addAnt(antMap, decl, node) {
     assert(node.type === "Identifier");
     const ant = antMap.get(decl);
-    if (!ant) {
-        antMap.set(decl, new Set([node]));
+    if (ant === false || ant === node)
+        return;
+    if (ant === undefined) {
+        antMap.set(decl, node);
     }
     else {
-        ant.add(node);
+        antMap.set(decl, false);
     }
 }
 function cloneState(blockState) {
@@ -6762,18 +6759,10 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
             else {
                 changed = Array.from(to.anticipated).reduce((changed, [decl, toant]) => {
                     const fromant = from.anticipated.get(decl);
-                    if (!fromant) {
+                    if (toant !== fromant) {
                         to.anticipated.delete(decl);
                         changed = true;
                     }
-                    else {
-                        toant.forEach((node) => {
-                            if (!fromant.has(node)) {
-                                toant.delete(node);
-                                changed = true;
-                            }
-                        });
-                    }
                     return changed;
                 }, changed);
             }
@@ -6786,17 +6775,15 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
             else {
                 changed = Array.from(from.partiallyAnticipated).reduce((changed, [decl, fromant]) => {
                     const toant = to.partiallyAnticipated.get(decl);
-                    if (!toant) {
+                    if (toant === undefined) {
                         to.partiallyAnticipated.set(decl, fromant);
                         changed = true;
                     }
                     else {
-                        fromant.forEach((node) => {
-                            if (!toant.has(node)) {
-                                changed = true;
-                                toant.add(node);
-                            }
-                        });
+                        if (toant !== fromant) {
+                            changed = true;
+                            to.partiallyAnticipated.set(decl, false);
+                        }
                     }
                     return changed;
                 }, changed);
@@ -6860,7 +6847,7 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
                                 }
                                 addAnt(curState.partiallyAnticipated, event.decl, event.node);
                                 if (logThisRun) {
-                                    console.log(`  antrefs: ${curState.partiallyAnticipated.get(event.decl)?.size ?? 0} ${curState.anticipated.get(event.decl)?.size ?? 0}`);
+                                    console.log(`  antrefs: ${curState.partiallyAnticipated.get(event.decl) !== false} ${curState.anticipated.get(event.decl) !== false}`);
                                 }
                             }
                             curState.dead.delete(event.decl);
@@ -6881,25 +6868,21 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
                             }
                             else {
                                 deadStores.delete(event.node);
-                                if (assignNode &&
-                                    declIsLocal(event.decl) &&
-                                    curState.partiallyAnticipated) {
+                                copyPropStores.delete(event.node);
+                                if (declIsLocal(event.decl) && curState.partiallyAnticipated) {
                                     const pant = curState.partiallyAnticipated.get(event.decl);
-                                    if (pant && pant.size === 1) {
+                                    if (pant) {
                                         if (logThisRun) {
-                                            console.log(`  is copy-prop-candidate ${curState.anticipated?.get(event.decl)?.size ?? 0}`);
+                                            console.log(`  is copy-prop-candidate ${curState.anticipated?.get(event.decl) === pant}`);
                                         }
                                         copyPropStores.set(event.node, {
-                                            ref: Array.from(pant)[0],
-                                            ant: curState.anticipated?.get(event.decl)?.size === 1,
+                                            ref: pant,
+                                            ant: curState.anticipated?.get(event.decl) === pant,
                                         });
                                     }
                                     curState.partiallyAnticipated.delete(event.decl);
                                     curState.anticipated?.delete(event.decl);
                                 }
-                                else {
-                                    copyPropStores.delete(event.node);
-                                }
                             }
                             if (nodeConflicts) {
                                 const conflicts = new Set(locals);
@@ -6988,7 +6971,10 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
             console.log(`${formatAst(dead)} (${sourceLocation(dead.loc)})`));
     }
     let changes = false;
-    traverseAst(func.node.body, null, (node, parent) => {
+    traverseAst(func.node.body, null, (node) => {
+        const cleaned = variableCleanup(node);
+        if (cleaned !== null)
+            return cleaned;
         if (node.type === "ExpressionStatement" &&
             node.expression.type === "AssignmentExpression" &&
             deadStores.has(node.expression)) {
@@ -7010,40 +6996,17 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
             changes = true;
             return { type: "Literal", value: null, raw: "null" };
         }
-        if (node.type === "VariableDeclaration") {
-            const result = [];
-            for (let i = 0; i < node.declarations.length; i++) {
-                const decl = node.declarations[i];
-                if (decl.init && deadStores.has(decl)) {
-                    const body = unused(state, decl.init);
-                    if (body.length) {
-                        if (!parent ||
-                            (parent.type !== "BlockStatement" && parent.type !== "SwitchCase")) {
-                            // Must be the init in a for statement. Fixing
-                            // it would be complicated, so just punt for now.
-                            break;
-                        }
-                        const newDeclaration = withLoc({ ...node }, node, decl.id);
-                        if (i + 1 < node.declarations.length) {
-                            newDeclaration.declarations = node.declarations.splice(0, i + 1);
-                            result.push(newDeclaration);
-                            withLoc(node, node.declarations[0], node);
-                            i = -1;
-                        }
-                        else {
-                            result.push(node);
-                        }
-                        result.push(...body);
-                    }
-                    changes = true;
-                    delete decl.init;
-                }
-            }
-            if (result.length) {
-                if (!result.includes(node)) {
-                    result.push(node);
+        if (node.type === "VariableDeclarator") {
+            const decl = node;
+            if (decl.init && deadStores.has(decl)) {
+                const body = unused(state, decl.init);
+                delete decl.init;
+                changes = true;
+                if (!body.length) {
+                    return null;
                 }
-                return result;
+                body.unshift(decl);
+                return body;
             }
         }
         return null;
@@ -9342,7 +9305,7 @@ function restrictByEquality(a, b) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony export minimizeLocals */
+/* unused harmony exports minimizeLocals, variableCleanup */
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6817);
@@ -9516,11 +9479,6 @@ function minimizeLocals(state, func) {
                     return null;
                 }
                 break;
-            case "ExpressionStatement":
-                if (node.expression.type === "Literal") {
-                    return false;
-                }
-                break;
             case "UpdateExpression":
                 if (info) {
                     assert(node.argument.type === "Identifier");
@@ -9541,7 +9499,7 @@ function minimizeLocals(state, func) {
                     }
                     // VariableDeclarations aren't allowed to have
                     // AssignmentExpressions in them, but we'll fix that
-                    // below
+                    // via variableCleanup
                     return withLoc({
                         type: "AssignmentExpression",
                         operator: "=",
@@ -9554,79 +9512,297 @@ function minimizeLocals(state, func) {
                     }, node, node);
                 }
                 break;
-            case "VariableDeclaration":
-                if (node.declarations.some((decl) => decl.type !== "VariableDeclarator")) {
-                    const results = [];
-                    node.declarations.forEach((decl) => {
-                        if (isExpression(decl)) {
-                            results.push(withLoc({ type: "ExpressionStatement", expression: decl }, decl, decl));
-                        }
-                        else if (decl.init) {
-                            results.push(withLoc({
-                                type: "ExpressionStatement",
-                                expression: withLoc({
-                                    type: "AssignmentExpression",
-                                    operator: "=",
-                                    left: withLoc({
-                                        type: "Identifier",
-                                        name: variableDeclarationName(decl.id),
-                                    }, decl.id, decl.id),
-                                    right: decl.init,
-                                }, decl, decl),
-                            }, decl, decl));
-                        }
-                    });
-                    node.declarations = node.declarations.filter((decl) => {
-                        if (decl.type === "VariableDeclarator") {
-                            delete decl.init;
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (node.declarations.length) {
-                        withLocDeep(node, node, false);
-                        results.unshift(node);
+        }
+        assert(!info);
+        return variableCleanup(node);
+    });
+    return;
+}
+function variableCleanup(node) {
+    switch (node.type) {
+        case "ExpressionStatement":
+            if (node.expression.type === "Literal") {
+                return false;
+            }
+            break;
+        case "VariableDeclaration":
+            if (node.declarations.some((decl) => decl.type !== "VariableDeclarator")) {
+                const results = [];
+                node.declarations.forEach((decl) => {
+                    if (isStatement(decl)) {
+                        results.push(decl);
+                    }
+                    else if (isExpression(decl)) {
+                        results.push(withLoc({ type: "ExpressionStatement", expression: decl }, decl, decl));
+                    }
+                    else if (decl.init) {
+                        results.push(withLoc({
+                            type: "ExpressionStatement",
+                            expression: withLoc({
+                                type: "AssignmentExpression",
+                                operator: "=",
+                                left: withLoc({
+                                    type: "Identifier",
+                                    name: variableDeclarationName(decl.id),
+                                }, decl.id, decl.id),
+                                right: decl.init,
+                            }, decl, decl),
+                        }, decl, decl));
                     }
-                    // if this was the init of a ForStatement, this will
-                    // replace its init with a BlockStatement, so we have to
-                    // fix that below.
-                    return results;
+                });
+                node.declarations = node.declarations.filter((decl) => {
+                    if (decl.type === "VariableDeclarator") {
+                        delete decl.init;
+                        return true;
+                    }
+                    return false;
+                });
+                if (node.declarations.length) {
+                    withLocDeep(node, node, false);
+                    results.unshift(node);
                 }
-                break;
-            case "ForStatement":
-                if (node.init) {
-                    if (node.init.type === "BlockStatement") {
-                        const result = node.init;
-                        delete node.init;
-                        result.body.push(node);
-                        if (node.loc && result.loc) {
-                            // result has the range of the original VariableDeclaration
-                            // but now we're moving that ahead of the 'for', so to keep
-                            // things straight, we need to set the for's start to be
-                            // where result ended, and result's end to be where the for
-                            // ends (since that block now encloses the for)
-                            node.start = result.end;
-                            node.loc.start = result.loc.end;
-                            result.end = node.end;
-                            result.loc.end = node.loc.end;
+                // if this was the init of a ForStatement, this will
+                // replace its init with a BlockStatement, so we have to
+                // fix that below.
+                return results;
+            }
+            break;
+        case "ForStatement":
+            if (node.init) {
+                if (node.init.type === "BlockStatement") {
+                    const result = node.init;
+                    delete node.init;
+                    result.body.push(node);
+                    if (node.loc && result.loc) {
+                        // result has the range of the original VariableDeclaration
+                        // but now we're moving that ahead of the 'for', so to keep
+                        // things straight, we need to set the for's start to be
+                        // where result ended, and result's end to be where the for
+                        // ends (since that block now encloses the for)
+                        node.start = result.end;
+                        node.loc.start = result.loc.end;
+                        result.end = node.end;
+                        result.loc.end = node.loc.end;
+                    }
+                    return result;
+                }
+                if (node.init.type === "Literal") {
+                    delete node.init;
+                }
+            }
+            break;
+        case "SequenceExpression":
+            if (node.expressions.some((e) => e.type === "Literal")) {
+                node.expressions = node.expressions.filter((e) => e.type !== "Literal");
+            }
+            break;
+    }
+    return null;
+}
+
+
+/***/ }),
+
+/***/ 4416:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export minimizeModules */
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
+
+
+
+function minimizeModules(ast, state) {
+    const { pre, post } = state;
+    try {
+        const replacementMap = new Map();
+        const conflictingNames = new Set();
+        state.pre = (node) => {
+            if (state.inType)
+                return null;
+            switch (node.type) {
+                case "ModuleDeclaration":
+                case "ClassDeclaration":
+                case "FunctionDeclaration":
+                    return ["body"];
+                case "Using":
+                    conflictingNames.add(node.as?.name ??
+                        (node.id.type === "Identifier"
+                            ? node.id.name
+                            : node.id.property.name));
+                    return [];
+                case "ImportModule":
+                    conflictingNames.add(node.id.type === "Identifier" ? node.id.name : node.id.property.name);
+                    return [];
+                case "Identifier":
+                case "MemberExpression": {
+                    let current = node;
+                    const parts = [];
+                    while (current.type === "MemberExpression" && !current.computed) {
+                        parts.unshift(current);
+                        current = current.object;
+                    }
+                    if (current.type !== "Identifier" &&
+                        current.type !== "ThisExpression") {
+                        break;
+                    }
+                    let toReplace = null;
+                    let module = null;
+                    let addImport = false;
+                    let [, results] = state.lookupValue(current, null);
+                    let i = 0;
+                    for (; results &&
+                        results.length === 1 &&
+                        results[0].results.length === 1 &&
+                        (results[0].results[0].type === "Program" ||
+                            results[0].results[0].type === "ClassDeclaration" ||
+                            results[0].results[0].type === "ModuleDeclaration"); i++) {
+                        if (current.type === "Identifier" &&
+                            results[0].results[0].type === "ModuleDeclaration" &&
+                            isImportCandidate(results[0].results[0])) {
+                            const directResults = i
+                                ? state.lookupValue(current, null)
+                                : results;
+                            if (directResults &&
+                                directResults.length === 1 &&
+                                directResults[0].results.length === 1 &&
+                                directResults[0].results[0] === results[0].results[0]) {
+                                // we would find the same thing if we just looked up
+                                // current directly.
+                                toReplace = (i ? parts[i - 1] : current);
+                                module = results[0].results[0];
+                                if (findUsingForNode(state, state.stack, state.stack.length - 1, current) === directResults[0].results[0]) {
+                                    // we already find it via an import, so we don't need
+                                    // a new import.
+                                    addImport = false;
+                                }
+                                else {
+                                    addImport = true;
+                                }
+                            }
+                            else {
+                                toReplace = parts[i - 1];
+                                module = results[0].results[0];
+                                addImport = true;
+                            }
                         }
-                        return result;
+                        if (i === parts.length)
+                            break;
+                        current = parts[i].property;
+                        results = lookupNext(state, results, "decls", current);
                     }
-                    if (node.init.type === "Literal") {
-                        delete node.init;
+                    if (toReplace) {
+                        assert(module);
+                        replacementMap.set(toReplace, { module, addImport });
                     }
+                    else if (parts.length === 0) {
+                        assert(node.type === "Identifier");
+                        conflictingNames.add(node.name);
+                    }
+                    else if (parts[0].object.type === "Identifier") {
+                        conflictingNames.add(parts[0].object.name);
+                    }
+                    return [];
                 }
-                break;
-            case "SequenceExpression":
-                if (node.expressions.some((e) => e.type === "Literal")) {
-                    node.expressions = node.expressions.filter((e) => e.type !== "Literal");
+            }
+            return null;
+        };
+        collectNamespaces(ast, state);
+        const mappedNames = new Map();
+        replacementMap.forEach((value, key) => {
+            let name;
+            if (value.addImport) {
+                name = mappedNames.get(value.module);
+                if (!name) {
+                    name = value.module.name;
+                    for (let i = 0; conflictingNames.has(name); i++) {
+                        name = `${value.module.name}_${i}`;
+                    }
+                    mappedNames.set(value.module, name);
+                    conflictingNames.add(name);
                 }
-                break;
-        }
-        assert(!info);
-        return null;
+            }
+            else {
+                name = key.type === "Identifier" ? key.name : key.property.name;
+            }
+            const original = formatAstLongLines(key);
+            const repl = key;
+            repl.type = "Identifier";
+            repl.name = name;
+            if (name !== original) {
+                repl.original = original;
+            }
+            delete repl.property;
+            delete repl.object;
+            delete repl.computed;
+        });
+        mappedNames.forEach((name, module) => {
+            const id = makeScopedName(module.fullName.slice(2));
+            const as = name !== (id.type === "Identifier" ? id : id.property).name &&
+                makeIdentifier(name);
+            const using = withLocDeep(as ? { type: "Using", id, as } : { type: "Using", id }, ast, false, true);
+            ast.body.unshift(using);
+        });
+    }
+    finally {
+        state.pre = pre;
+        state.post = post;
+    }
+}
+/**
+ * There's a bug in garmin's runtime (although the compiler could
+ * work around it). See
+ *
+ *   https://forums.garmin.com/developer/connect-iq/i/bug-reports/referencing-an-imported-module-doesn-t-run-its-parent-s-init
+ *
+ * What this means is that if a module's parent isn't `globals`
+ * and it needs to be initialized, then we can't risk
+ * importing it, because the parent module might not get initialized
+ * in time.
+ */
+function isImportCandidate(module) {
+    if (module.fullName.startsWith("$.Toybox."))
+        return true;
+    if (module.fullName.startsWith("$.Rez."))
+        return false;
+    assert(module.stack);
+    if (module.stack.length === 1)
+        return true;
+    return module.stack.every((elem) => {
+        if (!elem.sn.decls)
+            return false;
+        if (elem.sn.type === "Program")
+            return true;
+        if (elem.sn.type !== "ModuleDeclaration")
+            return false;
+        return Object.values(elem.sn.decls).every((decls) => decls.every((decl) => {
+            if (decl.type !== "VariableDeclarator")
+                return true;
+            if (!decl.node.init)
+                return true;
+            if (decl.node.init.type === "UnaryExpression" &&
+                decl.node.init.operator === ":") {
+                return true;
+            }
+            if (decl.node.init.type !== "Literal")
+                return false;
+            switch (typeof decl.node.init.value) {
+                case "boolean":
+                    return true;
+                case "bigint":
+                    return false;
+                case "number":
+                    return !/[dl]$/i.test(decl.node.init.raw);
+                case "object":
+                    return decl.node.init.value === null;
+            }
+            return false;
+        }));
     });
-    return;
 }