@markw65/monkeyc-optimizer 1.1.12 → 1.1.13

package/build/api.cjs

@@ -2758,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);
+
 
 
 
@@ -3370,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 [];
@@ -3683,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) {
@@ -4026,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");
@@ -4951,8 +4956,8 @@ 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) {
@@ -4964,31 +4969,25 @@ function addEquiv(ts, key, equiv) {
     }
     // equiv is not (or no longer) part of an equivSet
     if (!keyVal.equivSet) {
-        keyVal = { ...keyVal };
         keyVal.equivSet = new Set([key, equiv]);
-        ts.set(key, keyVal);
     }
     else {
         keyVal.equivSet.add(equiv);
     }
-    equivVal = { ...equivVal, equivSet: keyVal.equivSet };
-    ts.set(equiv, equivVal);
+    equivVal.equivSet = keyVal.equivSet;
     return false;
 }
 function removeEquiv(ts, equiv) {
-    let equivVal = ts.get(equiv);
+    const equivVal = ts.get(equiv);
     if (!equivVal?.equivSet)
         return;
     equivVal.equivSet.delete(equiv);
     if (equivVal.equivSet.size === 1) {
         const other = Array.from(equivVal.equivSet)[0];
-        const otherVal = { ...ts.get(other) };
+        const otherVal = ts.get(other);
         delete otherVal.equivSet;
-        ts.set(other, otherVal);
     }
-    equivVal = { ...equivVal };
     delete equivVal.equivSet;
-    ts.set(equiv, equivVal);
 }
 function getEquivSet(ts, k) {
     const keys = ts.get(k)?.equivSet;
@@ -5042,9 +5041,14 @@ function cloneTypeState(blockState) {
     const { map, trackedMemberDecls, liveCopyPropEvents, ...rest } = blockState;
     const clone = { map: new Map(map), ...rest };
     clone.map.forEach((value, key) => {
-        if (value.equivSet && key === Array.from(value.equivSet)[0]) {
-            const equivSet = new Set(value.equivSet);
-            equivSet.forEach((k) => clone.map.set(k, { ...clone.map.get(k), equivSet }));
+        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) {
@@ -5081,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) {
@@ -5119,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) {
@@ -5170,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;
@@ -5197,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.
@@ -5215,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);
@@ -5229,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;
             }
@@ -5242,7 +5236,7 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
             if (wide)
                 result = wide;
         }
-        to.map.set(k, { ...tov, curType: result });
+        tov.curType = result;
         changes = true;
     });
     return changes;
@@ -5267,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;
@@ -5286,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
@@ -5303,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 === "*") {
@@ -5334,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));
         }
     });
 }
@@ -5448,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];
@@ -5529,34 +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) {
+                if (v.equivSet) {
                     v.equivSet.forEach((s) => {
                         const next = blockState.map.get(s);
                         assert(next && next.equivSet?.has(s));
-                        blockState.map.set(s, { ...next, curType: value });
+                        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;
         }
@@ -5890,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) {
@@ -5914,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);
@@ -5991,10 +5979,9 @@ 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;
                                     }
-                                    curState.map.set(decl, { ...tsv, curType: type });
+                                    tsv.curType = type;
                                 }
                             }
                             clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
@@ -6019,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"
@@ -6717,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);
+
 
 
 
@@ -6985,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)) {
@@ -7007,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;
@@ -9339,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);
@@ -9513,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");
@@ -9538,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: "=",
@@ -9551,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 (toReplace) {
+                        assert(module);
+                        replacementMap.set(toReplace, { module, addImport });
+                    }
+                    else if (parts.length === 0) {
+                        assert(node.type === "Identifier");
+                        conflictingNames.add(node.name);
                     }
-                    if (node.init.type === "Literal") {
-                        delete node.init;
+                    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;
 }