@markw65/monkeyc-optimizer 1.0.43 → 1.0.45

package/build/optimizer.cjs

@@ -3585,6 +3585,17 @@ function manifestAnnotations(manifest) {
         .children("iq:annotation")
         .text();
 }
+function manifestLanguages(manifest) {
+    if (manifest.body instanceof Error) {
+        throw manifest.body;
+    }
+    return manifest.body
+        .children()
+        .filter((c) => c.name === "iq:application" || c.name === "iq:barrel")
+        .children("iq:languages")
+        .children("iq:language")
+        .text();
+}
 async function checkManifest(manifest, products) {
     if (manifest.body instanceof Error) {
         throw manifest.body;
@@ -3973,10 +3984,6 @@ async function resolve_literals(qualifier, default_source, deviceInfo, cache) {
     const lang = qualifier["lang"];
     if (lang) {
         await Promise.all(Object.keys(lang).map((key) => {
-            if (!(0,external_api_cjs_namespaceObject.hasProperty)(deviceInfo.languages, key)) {
-                delete lang[key];
-                return null;
-            }
             return resolve_one_file_list(lang, key);
         }));
         if (Object.keys(lang).length === 0)
@@ -4479,6 +4486,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options, cac
             jungles,
             resources,
             buildDependencies,
+            devices,
         };
     }
     catch (e) {
@@ -4509,17 +4517,22 @@ const external_child_process_namespaceObject = require("child_process");
 
 
 async function launchSimulator(force = true) {
-    if (!force && (await checkIfSimulatorRunning()))
-        return;
-    const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
-    const child = (0,external_child_process_namespaceObject.execFile)(external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq"));
-    child.unref();
-    for (let i = 0;; i++) {
-        if (await checkIfSimulatorRunning())
-            return;
-        if (i === 5)
+    try {
+        if (!force && (await checkIfSimulatorRunning()))
             return;
-        await new Promise((r) => setTimeout(r, 200));
+        const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
+        const child = (0,external_child_process_namespaceObject.execFile)(external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq"));
+        child.unref();
+        for (let i = 0;; i++) {
+            if (await checkIfSimulatorRunning())
+                return;
+            if (i === 5)
+                return;
+            await new Promise((r) => setTimeout(r, 200));
+        }
+    }
+    catch (e) {
+        console.log(e);
     }
 }
 function checkIfSimulatorRunning() {
@@ -4534,7 +4547,7 @@ function checkIfSimulatorRunningOn(port) {
         socket.on("end", () => resolve(listening));
         socket.connect(port, "localhost");
         socket.end();
-    });
+    }).catch(() => false);
 }
 function simulateProgram(prg, device, test = false, logger) {
     const args = [prg, device];
@@ -4789,13 +4802,73 @@ function getNodeValue(node) {
         return [node, "Long"];
     }
     if (type === "string") {
-        return [node, "String"];
+        return node.raw.startsWith("'")
+            ? [node, "Char"]
+            : [node, "String"];
     }
     if (type === "boolean") {
         return [node, "Boolean"];
     }
     throw new Error(`Literal has unknown type '${type}'`);
 }
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    const result = dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
+        }
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+    if (!result)
+        throw new Error("Failed to make a ScopedName");
+    return result;
+}
 
 ;// CONCATENATED MODULE: ./src/function-info.ts
 
@@ -4848,6 +4921,8 @@ function recordCalledFuncs(func, callees) {
 }
 function functionMayModify(state, func, decl) {
     const info = func.info;
+    if (info === false)
+        return false;
     if (!info || info.modifiedUnknown)
         return true;
     if (info.resolvedDecls) {
@@ -4860,7 +4935,7 @@ function functionMayModify(state, func, decl) {
     const visited = new Set();
     const resolved = new Set();
     const resolveDecls = (f) => {
-        if (visited.has(f))
+        if (f.info === false || visited.has(f))
             return true;
         if (!f.info)
             return false;
@@ -4922,6 +4997,16 @@ function findCalleesForNew(lookupDefs) {
         .flatMap(initializer)
         .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
 }
+function findCalleesByNode(state, callee) {
+    const name = callee.type === "Identifier"
+        ? callee.name
+        : callee.type === "MemberExpression" && !callee.computed
+            ? callee.property.name
+            : null;
+    if (!name)
+        return null;
+    return ((hasProperty(state.allFunctions, name) && state.allFunctions[name]) || null);
+}
 
 ;// CONCATENATED MODULE: ./src/optimizer-types.ts
 var StateNodeAttributes;
@@ -5885,13 +5970,17 @@ function pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
         return re.test(haystack);
     };
     next();
     traverseAst(ast, (node) => {
-        if (index >= comments.length)
+        if (index >= comments.length ||
+            node.type === "Line" ||
+            node.type === "Block" ||
+            node.type === "MultiLine") {
             return false;
+        }
         if (node.start && node.start >= (comment.end || Infinity)) {
             const { kind, quote, needle } = matchers.shift();
             if (kind === "match") {
@@ -6037,7 +6126,7 @@ function buildReducedGraph(state, func, notice) {
     try {
         const localState = new LocalState(func.node);
         const ret = localState.curBlock;
-        state.stack = func.stack;
+        state.stack = [...func.stack];
         const stmtStack = [func.node];
         let tryActive = 0;
         state.pre = (node) => {
@@ -6052,6 +6141,8 @@ function buildReducedGraph(state, func, notice) {
                 stmtStack.push(node);
             }
             switch (node.type) {
+                case "FunctionDeclaration":
+                    return ["body"];
                 case "AttributeList":
                     return [];
                 case "SwitchStatement": {
@@ -6268,11 +6359,6 @@ function buildReducedGraph(state, func, notice) {
                 }
                 case "VariableDeclarator":
                     return ["init"];
-                case "MemberExpression":
-                    if (!node.computed) {
-                        return ["object"];
-                    }
-                    break;
                 case "UnaryExpression":
                     if (node.operator === ":") {
                         return [];
@@ -6308,6 +6394,14 @@ function buildReducedGraph(state, func, notice) {
                 case "ContinueStatement":
                     localState.terminal(node.type);
                     return [];
+                case "CallExpression":
+                    if (node.callee.type === "Identifier") {
+                        const extra = state.stack.splice(func.stack.length);
+                        state.traverse(node.callee);
+                        state.stack.push(...extra);
+                        return ["arguments"];
+                    }
+                    break;
             }
             return null;
         };
@@ -6469,142 +6563,94 @@ function getPreOrder(head) {
 
 // EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
 var priorityqueuejs = __webpack_require__(2789);
-;// CONCATENATED MODULE: ./src/pre.ts
+;// CONCATENATED MODULE: ./src/data-flow.ts
+
 
 
 
 
 
-/**
- * This implements a pseudo Partial Redundancy Elimination
- * pass. It isn't quite like traditional PRE because we're
- * aiming to minimize size, not dynamic instructions. So
- * for us, its worthwhile to take something like:
- *
- * switch (x) {
- *   case 1: foo(A.B); break;
- *   case 2: foo(C); break;
- *   case 3: bar(A.B); break;
- * }
- *
- * and rewrite it as
- *
- * var tmp = A.B;
- * switch (x) {
- *   case 1: foo(tmp); break;
- *   case 2: foo(C); break;
- *   case 3: bar(tmp); break;
- * }
- *
- * because even though A.B wasn't used on all paths where we
- * inserted the temporary, we still reduced the code size.
- */
-const logging = false;
 function declFullName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return decl.raw || decl.value?.toString() || "null";
+    }
+    if ((0,external_api_cjs_namespaceObject.isStateNode)(decl))
+        return decl.fullName;
     switch (decl.type) {
-        case "Literal":
-            return decl.raw || decl.value?.toString() || "null";
-        case "VariableDeclarator":
-            return decl.fullName;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.init
+                ? `${decl.id.name}:${(0,external_api_cjs_namespaceObject.formatAst)(decl.init)}`
+                : decl.id.name;
         default:
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
 function declName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
+    }
+    if ((0,external_api_cjs_namespaceObject.isStateNode)(decl))
+        return decl.name;
     switch (decl.type) {
-        case "Literal":
-            return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
-        case "VariableDeclarator":
-            return decl.name;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.id.name;
         default:
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
-function logAntState(s, decl) {
-    const defs = Array.from(s.ant).reduce((defs, event) => {
-        if (event.type === "def" || event.type === "mod")
-            defs++;
-        return defs;
-    }, 0);
-    console.log(`  - ${declFullName(decl)}: ${candidateCost(s)} bytes, ${s.ant.size - defs} refs, ${defs} defs, ${s.live ? "" : "!"}live, ${s.isIsolated ? "" : "!"}isolated`);
-    console.log(`    - members: ${Array.from(s.members)
-        .map(([block, live]) => block.order + (live ? "t" : "f"))
-        .join(", ")}`);
-}
-function logAntDecls(antDecls) {
-    antDecls.forEach(logAntState);
-}
-function sizeBasedPRE(state, func) {
-    if (!func.node.body)
-        return;
-    if (!state.config ||
-        !state.config.sizeBasedPRE ||
-        (typeof state.config.sizeBasedPRE === "string" &&
-            state.config.sizeBasedPRE !== func.fullName)) {
-        return;
-    }
-    const { graph: head, identifiers } = buildPREGraph(state, func);
-    const candidates = computeAttributes(state, head);
-    if (candidates) {
-        if (logging) {
-            console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
-            logAntDecls(candidates);
-        }
-        const nodeMap = new Map();
-        const declMap = new Map();
-        const variableDecl = withLoc({
-            type: "VariableDeclaration",
-            declarations: [],
-            kind: "var",
-        }, func.node.body);
-        variableDecl.end = variableDecl.start;
-        variableDecl.loc.end = variableDecl.loc.start;
-        candidates.forEach((s, decl) => {
-            let name;
-            let i = 0;
-            do {
-                name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
-                if (!identifiers.has(name)) {
-                    identifiers.add(name);
-                    break;
-                }
-                i++;
-            } while (true);
-            declMap.set(decl, name);
-            variableDecl.declarations.push(withLoc({
-                type: "VariableDeclarator",
-                id: withLoc({ type: "Identifier", name }, variableDecl),
-                kind: "var",
-            }, variableDecl));
-            s.ant.forEach((event) => {
-                const events = nodeMap.get(event.node);
-                if (!events) {
-                    nodeMap.set(event.node, [event]);
-                }
-                else {
-                    events.push(event);
-                }
-            });
-        });
-        applyReplacements(func.node, nodeMap, declMap);
-        func.node.body.body.unshift(variableDecl);
-    }
-}
 function unhandledExpression(node) {
     throw new Error(`Unhandled expression type: ${node.type}`);
 }
-function buildPREGraph(state, func) {
+function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wantsAllRefs) {
+    const uniqueDeclMap = new Map();
     const findDecl = (node) => {
         if (node.type === "Identifier" ||
             (node.type === "MemberExpression" && !node.computed)) {
             const [, results] = state.lookup(node);
-            if (results &&
-                results.length === 1 &&
-                results[0].parent?.type != "BlockStatement" &&
-                results[0].results.length === 1 &&
-                results[0].results[0].type === "VariableDeclarator") {
-                return results[0].results[0];
-            }
+            const decls = (results &&
+                results.reduce((decls, result) => result.results.reduce((decls, result) => {
+                    if (!wantsAllRefs &&
+                        (result.type !== "VariableDeclarator" || (0,external_api_cjs_namespaceObject.isLocal)(result))) {
+                        return decls;
+                    }
+                    if (!decls)
+                        return result;
+                    if (Array.isArray(decls)) {
+                        decls.push(result);
+                        return decls;
+                    }
+                    else {
+                        return [decls, result];
+                    }
+                }, decls), null)) ||
+                null;
+            if (!Array.isArray(decls))
+                return decls;
+            // We use EventDecl as a Map key, so we need to
+            // uniquify it. Note that from any given function,
+            // if state.lookup finds a set of non locals, it will
+            // always find the same set, so we can use the first
+            // such as the unique identifier.
+            const canon = uniqueDeclMap.get(decls[0]);
+            if (!canon) {
+                uniqueDeclMap.set(decls[0], decls);
+                return decls;
+            }
+            if (canon.length != decls.length ||
+                !canon.every((v, i) => v === decls[i])) {
+                throw new Error(`Canonical representation of ${declFullName(canon)} did not match`);
+            }
+            return canon;
         }
         return null;
     };
@@ -6612,18 +6658,22 @@ function buildPREGraph(state, func) {
     const identifiers = new Set();
     const liveDefs = new Map();
     const liveStmts = new Map();
-    const liveDef = (def, stmt) => {
-        let curNodes = liveDefs.get(def);
-        if (!curNodes) {
-            liveDefs.set(def, (curNodes = new Set()));
-        }
-        curNodes.add(stmt);
-        let defs = liveStmts.get(stmt);
-        if (!defs) {
-            liveStmts.set(stmt, (defs = new Map()));
+    const liveDef = trackInsertionPoints
+        ? (def, stmt) => {
+            let curNodes = liveDefs.get(def);
+            if (!curNodes) {
+                liveDefs.set(def, (curNodes = new Set()));
+            }
+            curNodes.add(stmt);
+            let defs = liveStmts.get(stmt);
+            if (!defs) {
+                liveStmts.set(stmt, (defs = new Map()));
+            }
+            defs.set(def, (defs.get(def) || 0) + 1);
         }
-        defs.set(def, (defs.get(def) || 0) + 1);
-    };
+        : () => {
+            /* do nothing */
+        };
     return {
         identifiers,
         graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
@@ -6658,7 +6708,7 @@ function buildPREGraph(state, func) {
                 case "ParenthesizedExpression":
                     break;
                 case "Literal":
-                    if (refCost(node) > LocalRefCost) {
+                    if (wantsLiteral(node)) {
                         const result = getNodeValue(node);
                         const key = result[1] +
                             (result[0].value === null
@@ -6680,34 +6730,40 @@ function buildPREGraph(state, func) {
                 case "Identifier":
                     identifiers.add(node.name);
                 // fall through
-                case "MemberExpression":
-                    {
-                        const decl = findDecl(node);
-                        if (decl && decl.type === "VariableDeclarator") {
-                            const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
-                                liveDefs.get(decl);
-                            if (defStmts) {
-                                break;
-                                /*
-                                // hold off on this for now. we need to communicate
-                                // which defs need to be fixed, which involves yet-another
-                                // table.
-              
-                                if (defStmts.size !== 1) break;
-                                const fixable = isFixableStmt([...defStmts][0]);
-                                if (fixable === false) break;
-                                cost += fixable;
-                              */
+                case "MemberExpression": {
+                    const decls = findDecl(node);
+                    if (!decls)
+                        break;
+                    if (trackInsertionPoints &&
+                        (0,external_util_cjs_namespaceObject.some)(decls, (decl) => {
+                            if (decl.type === "VariableDeclarator") {
+                                const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
+                                    liveDefs.get(decl);
+                                if (defStmts) {
+                                    return true;
+                                    /*
+                                      // hold off on this for now. we need to communicate
+                                      // which defs need to be fixed, which involves yet-another
+                                      // table.
+                
+                                      if (defStmts.size !== 1) break;
+                                      const fixable = isFixableStmt([...defStmts][0]);
+                                      if (fixable === false) break;
+                                      cost += fixable;
+                                    */
+                                }
                             }
-                            return {
-                                type: "ref",
-                                node,
-                                decl,
-                                mayThrow,
-                            };
-                        }
+                            return false;
+                        })) {
+                        break;
                     }
-                    break;
+                    return {
+                        type: "ref",
+                        node,
+                        decl: decls,
+                        mayThrow,
+                    };
+                }
                 case "VariableDeclarator": {
                     const decl = findDecl(node.id.type === "BinaryExpression" ? node.id.left : node.id);
                     if (decl) {
@@ -6755,8 +6811,10 @@ function buildPREGraph(state, func) {
                 }
                 case "CallExpression": {
                     liveDef(null, stmt);
-                    const [, results] = state.lookup(node.callee);
-                    const callees = results ? findCallees(results) : null;
+                    const [, results] = state.lookupNonlocal(node.callee);
+                    const callees = results
+                        ? findCallees(results)
+                        : findCalleesByNode(state, node.callee);
                     return { type: "mod", node, mayThrow, callees };
                 }
                 default:
@@ -6771,6 +6829,132 @@ function buildPREGraph(state, func) {
         }),
     };
 }
+class DataflowQueue {
+    constructor() {
+        this.enqueued = new Set();
+        this.queue = new priorityqueuejs((b, a) => (a.order || 0) - (b.order || 0));
+    }
+    enqueue(block) {
+        if (!this.enqueued.has(block)) {
+            this.enqueued.add(block);
+            this.queue.enq(block);
+        }
+    }
+    dequeue() {
+        const block = this.queue.deq();
+        this.enqueued.delete(block);
+        return block;
+    }
+    empty() {
+        return this.queue.isEmpty();
+    }
+}
+
+;// CONCATENATED MODULE: ./src/pre.ts
+
+
+
+
+
+
+/**
+ * This implements a pseudo Partial Redundancy Elimination
+ * pass. It isn't quite like traditional PRE because we're
+ * aiming to minimize size, not dynamic instructions. So
+ * for us, its worthwhile to take something like:
+ *
+ * switch (x) {
+ *   case 1: foo(A.B); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(A.B); break;
+ * }
+ *
+ * and rewrite it as
+ *
+ * var tmp = A.B;
+ * switch (x) {
+ *   case 1: foo(tmp); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(tmp); break;
+ * }
+ *
+ * because even though A.B wasn't used on all paths where we
+ * inserted the temporary, we still reduced the code size.
+ */
+const logging = false;
+function logAntState(s, decl) {
+    const defs = Array.from(s.ant).reduce((defs, event) => {
+        if (event.type === "def" || event.type === "mod")
+            defs++;
+        return defs;
+    }, 0);
+    console.log(`  - ${declFullName(decl)}: ${candidateCost(s)} bytes, ${s.ant.size - defs} refs, ${defs} defs, ${s.live ? "" : "!"}live, ${s.isIsolated ? "" : "!"}isolated`);
+    console.log(`    - members: ${Array.from(s.members)
+        .map(([block, live]) => block.order + (live ? "t" : "f"))
+        .join(", ")}`);
+}
+function logAntDecls(antDecls) {
+    antDecls.forEach(logAntState);
+}
+function sizeBasedPRE(state, func) {
+    if (!func.node.body)
+        return;
+    if (!state.config ||
+        !state.config.sizeBasedPRE ||
+        (typeof state.config.sizeBasedPRE === "string" &&
+            state.config.sizeBasedPRE !== func.fullName)) {
+        return;
+    }
+    const { graph: head, identifiers } = buildPREGraph(state, func);
+    const candidates = computeAttributes(state, head);
+    if (candidates) {
+        if (logging) {
+            console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
+            logAntDecls(candidates);
+        }
+        const nodeMap = new Map();
+        const declMap = new Map();
+        const variableDecl = withLoc({
+            type: "VariableDeclaration",
+            declarations: [],
+            kind: "var",
+        }, func.node.body);
+        variableDecl.end = variableDecl.start;
+        variableDecl.loc.end = variableDecl.loc.start;
+        candidates.forEach((s, decl) => {
+            let name;
+            let i = 0;
+            do {
+                name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
+                if (!identifiers.has(name)) {
+                    identifiers.add(name);
+                    break;
+                }
+                i++;
+            } while (true);
+            declMap.set(decl, name);
+            variableDecl.declarations.push(withLoc({
+                type: "VariableDeclarator",
+                id: withLoc({ type: "Identifier", name }, variableDecl),
+                kind: "var",
+            }, variableDecl));
+            s.ant.forEach((event) => {
+                const events = nodeMap.get(event.node);
+                if (!events) {
+                    nodeMap.set(event.node, [event]);
+                }
+                else {
+                    events.push(event);
+                }
+            });
+        });
+        applyReplacements(func.node, nodeMap, declMap);
+        func.node.body.body.unshift(variableDecl);
+    }
+}
+function buildPREGraph(state, func) {
+    return buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+}
 function anticipatedDecls() {
     return new Map();
 }
@@ -6926,26 +7110,18 @@ function computeAttributes(state, head) {
                 .join(", ")}`);
             if (block.events) {
                 block.events.forEach((event) => event.type !== "exn" &&
-                    console.log(`    ${event.type}: ${event.decl ? declFullName(event.decl) : "??"}`));
+                    console.log(`    ${event.type}: ${event.decl
+                        ? declFullName(event.decl)
+                        : event.node
+                            ? (0,external_api_cjs_namespaceObject.formatAst)(event.node)
+                            : "??"}`));
             }
             console.log(`Succs: ${(block.succs || [])
                 .map((block) => block.order)
                 .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
         });
     }
-    const enqueued = new Set();
-    const queue = new priorityqueuejs((b, a) => (a.order || 0) - (b.order || 0));
-    const enqueue = (block) => {
-        if (!enqueued.has(block)) {
-            enqueued.add(block);
-            queue.enq(block);
-        }
-    };
-    const dequeue = () => {
-        const block = queue.deq();
-        enqueued.delete(block);
-        return block;
-    };
+    const queue = new DataflowQueue();
     const blockStates = [];
     /*
       Algorithm
@@ -6979,9 +7155,9 @@ function computeAttributes(state, head) {
         }
         return result;
     };
-    order.forEach((block) => enqueue(block));
-    while (queue.size()) {
-        const top = dequeue();
+    order.forEach((block) => queue.enqueue(block));
+    while (!queue.empty()) {
+        const top = queue.dequeue();
         if (top.order === undefined) {
             throw new Error(`Unreachable block was visited!`);
         }
@@ -7020,13 +7196,13 @@ function computeAttributes(state, head) {
                         break;
                     }
                     case "mod": {
-                        curState.forEach((candidates, decl) => {
-                            if (decl.type === "VariableDeclarator" &&
+                        curState.forEach((candidates, decls) => {
+                            if ((0,external_util_cjs_namespaceObject.some)(decls, (decl) => decl.type === "VariableDeclarator" &&
                                 decl.node.kind === "var" &&
                                 candidates.live &&
                                 (!event.callees ||
-                                    event.callees.some((callee) => functionMayModify(state, callee, decl)))) {
-                                candidates.ant.add(getMod(event, decl, candidates.node));
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl))))) {
+                                candidates.ant.add(getMod(event, decls, candidates.node));
                                 candidates.live = false;
                             }
                         });
@@ -7078,7 +7254,7 @@ function computeAttributes(state, head) {
             logAntDecls(curState);
         }
         if (top.preds) {
-            top.preds.forEach((pred) => enqueue(pred));
+            top.preds.forEach((pred) => queue.enqueue(pred));
         }
     }
     const candidateDecls = anticipatedDecls();
@@ -7832,7 +8008,7 @@ function getLiteralNode(node) {
             case "-": {
                 const [arg, type] = getNodeValue(node.argument);
                 if (type === "Number" || type === "Long") {
-                    return replacementLiteral(arg, -arg.value, type);
+                    return replacementLiteral(node, -arg.value, type);
                 }
             }
         }
@@ -7882,8 +8058,14 @@ function isBooleanExpression(state, node) {
     }
     return false;
 }
+function roundToFloat(value) {
+    return new Float32Array([value])[0];
+}
 function replacementLiteral(arg, value, type) {
-    if (typeof value === "boolean") {
+    if (value === null) {
+        type = "Null";
+    }
+    else if (typeof value === "boolean") {
         type = "Boolean";
     }
     else if (type === "Number") {
@@ -7892,32 +8074,213 @@ function replacementLiteral(arg, value, type) {
     else if (type === "Long") {
         value = BigInt.asIntN(64, BigInt(value));
     }
+    else if (type === "Float") {
+        value = roundToFloat(Number(value));
+    }
+    let raw = type === "String"
+        ? JSON.stringify(value)
+        : type === "Char"
+            ? value === "'"
+                ? "'\\''"
+                : "'" + JSON.stringify(value).slice(1, -1) + "'"
+            : value == null
+                ? "null"
+                : value.toString();
+    if (type === "Long") {
+        raw += "l";
+    }
+    else if (type === "Double") {
+        raw += "d";
+    }
+    else if (type === "Float") {
+        if (prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
+            raw += "f";
+        }
+        else {
+            const match = raw.match(/^(-)?(\d*)\.(\d+)(e\d+)?/);
+            if (match && match[2].length + match[3].length > 9) {
+                for (let l = 9 - match[2].length; l > 0; l--) {
+                    const s = `${match[1] || ""}${match[2]}.${match[3].substring(0, l)}${match[4] || ""}`;
+                    if (value !== roundToFloat(parseFloat(s)))
+                        break;
+                    raw = s;
+                }
+            }
+        }
+    }
+    const { start, end, loc } = arg;
     return {
-        ...arg,
+        type: "Literal",
         value,
-        raw: value.toString() + (type === "Long" ? "l" : ""),
+        raw,
+        start,
+        end,
+        loc,
     };
 }
+function classify(arg) {
+    switch (arg) {
+        case "Number":
+            return { big: false, int: true };
+        case "Long":
+            return { big: true, int: true };
+        case "Float":
+            return { big: false, int: false };
+        case "Double":
+            return { big: true, int: false };
+    }
+    return null;
+}
+function common_arith_types(left, right) {
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (l.big || r.big) {
+        return l.int && r.int
+            ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+            : ["Double", (v) => Number(v)];
+    }
+    else {
+        return l.int && r.int
+            ? ["Number", (v) => BigInt.asIntN(32, BigInt(v))]
+            : ["Float", (v) => roundToFloat(Number(v))];
+    }
+}
+function common_bitwise_types(left, right) {
+    if (left === "Boolean" && right === "Boolean") {
+        return ["Boolean", (v) => (v ? true : false)];
+    }
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (!l.int || !r.int)
+        return null;
+    return l.big || r.big
+        ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+        : ["Number", (v) => Number(BigInt.asIntN(32, BigInt(v)))];
+}
+function plus_types(left, right) {
+    if (left === "String" || right === "String") {
+        // Boolean + String is an error, and
+        // Float/Double + String is legal, but its hard to predict
+        // the way the float will be formatted (and it won't match
+        // what javascript would do by default)
+        if (/Float|Double|Boolean/.test(left + right)) {
+            return null;
+        }
+        return ["String", String];
+    }
+    if (left === "Char" || right === "Char") {
+        if (left === right) {
+            // adding two chars produces a string
+            return ["String", String];
+        }
+        if (/Number|Long/.test(left + right)) {
+            return ["Char", (v) => v];
+        }
+    }
+    return common_arith_types(left, right);
+}
+function shift_mod_types(left, right) {
+    const result = common_bitwise_types(left, right);
+    if (result && result[0] === "Boolean") {
+        return null;
+    }
+    return result;
+}
+function equalsFn(left, right) {
+    const lt = typeof left;
+    const rt = typeof right;
+    return lt === "string" || rt === "string"
+        ? // two string literals will compare unequal, becuase string
+            // equality is object equality.
+            false
+        : (lt === "number" || lt === "bigint") &&
+            (rt === "number" || rt === "bigint")
+            ? // numeric types are compared for value equality
+                left == right
+            : // otherwise types and values must match
+                left === right;
+}
 const operators = {
-    "+": (left, right) => left + right,
-    "-": (left, right) => left - right,
-    "*": (left, right) => left * right,
-    "/": (left, right) => left / right,
-    "%": (left, right) => left % right,
-    "&": (left, right) => left & right,
-    "|": (left, right) => left | right,
-    "^": (left, right) => left ^ right,
-    "<<": (left, right) => left << (right & 127n),
-    ">>": (left, right) => left >> (right & 127n),
-    "==": (left, right) => 
-    // two string literals will compare unequal, becuase string
-    // equality is object equality.
-    typeof left === "string" ? false : left === right,
-    "!=": (left, right) => typeof left === "string" ? true : left !== right,
-    "<=": (left, right) => left <= right,
-    ">=": (left, right) => left >= right,
-    "<": (left, right) => left < right,
-    ">": (left, right) => left > right,
+    "+": {
+        typeFn: plus_types,
+        valueFn: (left, right) => typeof left === "string" && typeof right !== "string"
+            ? String.fromCharCode(left.charCodeAt(0) + Number(right))
+            : typeof left !== "string" && typeof right === "string"
+                ? String.fromCharCode(right.charCodeAt(0) + Number(left))
+                : left + right,
+    },
+    "-": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left - right,
+    },
+    "*": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left * right,
+    },
+    "/": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left / right,
+    },
+    "%": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => left % right,
+    },
+    "&": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left & right,
+    },
+    "|": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left | right,
+    },
+    "^": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left ^ right,
+    },
+    "<<": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left << right
+            : left << right,
+    },
+    ">>": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left >> right
+            : left >> right,
+    },
+    "==": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: equalsFn,
+    },
+    "!=": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: (left, right) => !equalsFn(left, right),
+    },
+    "<=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left <= right,
+    },
+    ">=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left >= right,
+    },
+    "<": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left < right,
+    },
+    ">": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left > right,
+    },
     as: null,
     instanceof: null,
     has: null,
@@ -7930,23 +8293,31 @@ function optimizeNode(state, node) {
                 break;
             switch (node.operator) {
                 case "+":
-                    if (type === "Number" || type === "Long") {
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double" ||
+                        type === "Char" ||
+                        type === "String") {
                         return arg;
                     }
                     break;
                 case "-":
-                    if (type === "Number" || type === "Long") {
-                        return replacementLiteral(arg, -arg.value, type);
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double") {
+                        return replacementLiteral(node, -arg.value, type);
                     }
                     break;
                 case "!":
                 case "~":
                     {
                         if (type === "Number" || type === "Long") {
-                            return replacementLiteral(arg, ~BigInt(arg.value), type);
+                            return replacementLiteral(node, ~BigInt(arg.value), type);
                         }
                         if (type === "Boolean" && node.operator == "!") {
-                            return replacementLiteral(arg, !arg.value, type);
+                            return replacementLiteral(node, !arg.value, type);
                         }
                     }
                     break;
@@ -7960,23 +8331,13 @@ function optimizeNode(state, node) {
                 const [right, right_type] = getNodeValue(node.right);
                 if (!left || !right)
                     break;
-                let value = null;
-                let type;
-                if ((left_type != "Number" && left_type != "Long") ||
-                    left_type != right_type) {
-                    if (node.operator !== "==" && node.operator !== "!=") {
-                        break;
-                    }
-                    value = operators[node.operator](left.value, right.value);
-                    type = "Boolean";
-                }
-                else {
-                    type = left_type;
-                    value = op(BigInt(left.value), BigInt(right.value));
-                }
+                const type = op.typeFn(left_type, right_type);
+                if (!type)
+                    break;
+                const value = op.valueFn(type[1](left.value), type[1](right.value));
                 if (value === null)
                     break;
-                return replacementLiteral(left, value, type);
+                return replacementLiteral(node, value, type[0]);
             }
             break;
         }
@@ -8429,7 +8790,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 if (!state.currentFunction) {
                     throw new Error(`Finished function ${state.stack.slice(-1)[0].fullName}, but it was not marked current`);
                 }
-                state.currentFunction.info = state.currentFunction.next_info;
+                state.currentFunction.info = state.currentFunction.next_info || false;
                 delete state.currentFunction.next_info;
                 delete state.currentFunction;
                 break;
@@ -8992,7 +9353,7 @@ async function createLocalBarrels(targets, options) {
 async function generateOptimizedProject(options) {
     const config = await getConfig(options);
     const workspace = config.workspace;
-    const { manifest, targets, xml, jungles } = await get_jungle(config.jungleFiles, config);
+    const { manifest, targets, xml, devices, resources, buildDependencies } = await get_jungle(config.jungleFiles, config);
     if (xml.body instanceof Error) {
         throw xml.body;
     }
@@ -9004,7 +9365,7 @@ async function generateOptimizedProject(options) {
             xml.body.elements[0].loc || undefined;
         throw error;
     }
-    const dependencyFiles = [manifest, ...jungles];
+    const dependencyFiles = Object.keys(resources).concat(Object.keys(buildDependencies));
     await createLocalBarrels(targets, config);
     const buildConfigs = {};
     const products = {};
@@ -9102,13 +9463,35 @@ async function generateOptimizedProject(options) {
         relative_manifest = "manifest.xml";
     }
     const parts = [`project.manifest=${relative_manifest}`];
-    const process_field = (prefix, base, name, mapper = null) => {
+    const map_field = (base, name, mapper = null) => {
         const obj = base[name];
         if (!obj)
-            return;
+            return null;
         const map_one = (s) => (mapper ? mapper(s) : s);
         const map = (s) => Array.isArray(s) ? `[${s.map(map_one).join(";")}]` : map_one(s);
-        parts.push(`${prefix}${name} = ${obj.map(map).join(";")}`);
+        return `${obj.map(map).join(";")}`;
+    };
+    const process_field = (prefix, base, name, mapper = null) => {
+        const mapped = map_field(base, name, mapper);
+        if (!mapped)
+            return;
+        parts.push(`${prefix}${name} = ${mapped}`);
+    };
+    const languagesToInclude = Object.fromEntries((manifestLanguages(xml) || []).map((lang) => [lang, true]));
+    const unsupportedLangsCache = {};
+    let availableDefaults = null;
+    const nextAvailableDefault = () => {
+        if (!availableDefaults) {
+            availableDefaults = Object.keys(Object.values(devices).reduce((m, d) => {
+                m[d.deviceFamily] = true;
+                const match = d.deviceFamily.match(/^(\w+)-\d+x\d+/);
+                if (match)
+                    m[match[1]] = true;
+                return m;
+            }, {})).sort();
+            availableDefaults.unshift("base");
+        }
+        return availableDefaults.shift();
     };
     targets.forEach((target) => {
         if (!buildConfigs[configKey(target)])
@@ -9145,8 +9528,39 @@ async function generateOptimizedProject(options) {
         process_field(prefix, qualifier, "excludeAnnotations");
         const qlang = qualifier.lang;
         if (qlang) {
+            const devLang = devices[product].languages;
+            const unsupportedLangs = Object.keys(qlang)
+                .sort()
+                .map((key) => {
+                if ((0,external_api_cjs_namespaceObject.hasProperty)(devLang, key) ||
+                    !(0,external_api_cjs_namespaceObject.hasProperty)(languagesToInclude, key)) {
+                    return null;
+                }
+                const mapped = map_field(qlang, key, relative_path);
+                if (!mapped)
+                    return null;
+                return [key, mapped];
+            })
+                .filter((a) => a != null);
+            let keysToSkip = null;
+            if (unsupportedLangs.length) {
+                const key = JSON.stringify(unsupportedLangs);
+                if (!(0,external_api_cjs_namespaceObject.hasProperty)(unsupportedLangsCache, key)) {
+                    const base = nextAvailableDefault();
+                    if (base) {
+                        unsupportedLangs.forEach(([key, value]) => parts.push(`${base}.lang.${key} = ${value}`));
+                        unsupportedLangsCache[key] = `${base}.lang`;
+                    }
+                }
+                if ((0,external_api_cjs_namespaceObject.hasProperty)(unsupportedLangsCache, key)) {
+                    keysToSkip = Object.fromEntries(unsupportedLangs);
+                    parts.push(`${prefix}lang = $(${unsupportedLangsCache[key]})`);
+                }
+            }
             Object.keys(qlang).forEach((key) => {
-                process_field(`${prefix}lang.`, qlang, key, relative_path);
+                (0,external_api_cjs_namespaceObject.hasProperty)(keysToSkip, key) ||
+                    !(0,external_api_cjs_namespaceObject.hasProperty)(languagesToInclude, key) ||
+                    process_field(`${prefix}lang.`, qlang, key, relative_path);
             });
         }
     });
@@ -9266,7 +9680,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1670458646779 < opt_time) {
+        if (source_time < opt_time && 1672601827382 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -9293,7 +9707,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.0.43",
+                optimizerVersion: "1.0.45",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));