@markw65/monkeyc-optimizer 1.0.9 → 1.0.12

package/build/api.cjs

@@ -1,10 +1,22 @@
-0 && (module.exports = {LiteralIntegerRe,getApiMapping,hasProperty,collectNamespaces,traverseAst,formatAst});
+0 && (module.exports = {getApiMapping,hasProperty,isStateNode,variableDeclarationName,collectNamespaces,traverseAst,formatAst});
 /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	// The require scope
 /******/ 	var __webpack_require__ = {};
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports
@@ -40,772 +52,827 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "LiteralIntegerRe": () => (/* binding */ api_LiteralIntegerRe),
   "collectNamespaces": () => (/* binding */ api_collectNamespaces),
   "formatAst": () => (/* binding */ formatAst),
   "getApiMapping": () => (/* binding */ api_getApiMapping),
   "hasProperty": () => (/* binding */ api_hasProperty),
-  "traverseAst": () => (/* binding */ api_traverseAst)
+  "isStateNode": () => (/* binding */ api_isStateNode),
+  "traverseAst": () => (/* binding */ api_traverseAst),
+  "variableDeclarationName": () => (/* binding */ api_variableDeclarationName)
 });
 
 ;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
 const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
+var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettier_plugin_monkeyc_namespaceObject);
 ;// CONCATENATED MODULE: external "fs/promises"
 const promises_namespaceObject = require("fs/promises");
 ;// CONCATENATED MODULE: external "prettier/standalone.js"
 const standalone_js_namespaceObject = require("prettier/standalone.js");
+var standalone_js_default = /*#__PURE__*/__webpack_require__.n(standalone_js_namespaceObject);
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
-;// CONCATENATED MODULE: ./src/mc-rewrite.js
-
+;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
 
 
 function processImports(allImports, lookup) {
-  allImports.forEach(({ node, stack }) => {
-    const [name, module] = lookup(node.id, node.as && node.as.name, stack);
-    if (name && module) {
-      const [parent] = stack.slice(-1);
-      if (!parent.decls) parent.decls = {};
-      if (!hasProperty(parent.decls, name)) parent.decls[name] = [];
-      module.forEach((m) => {
-        if (m.type == "ModuleDeclaration") {
-          pushUnique(parent.decls[name], m);
+    allImports.forEach(({ node, stack }) => {
+        const [name, module] = lookup(node.id, "as" in node && node.as && node.as.name, stack);
+        if (name && module) {
+            const [parent] = stack.slice(-1);
+            if (!parent.decls)
+                parent.decls = {};
+            if (!hasProperty(parent.decls, name))
+                parent.decls[name] = [];
+            module.forEach((m) => {
+                if (isStateNode(m) && m.type == "ModuleDeclaration") {
+                    pushUnique(parent.decls[name], m);
+                }
+            });
         }
-      });
-    }
-  });
+    });
 }
-
 function collectClassInfo(state) {
-  state.allClasses.forEach((elm) => {
-    if (elm.node.superClass) {
-      const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
-      if (classes) {
-        elm.superClass = classes.filter((c) => c.type == "ClassDeclaration");
-      }
-      // set it "true" if there is a superClass, but we can't find it.
-      if (!elm.superClass || !elm.superClass.length) elm.superClass = true;
-    }
-  });
-
-  const markOverrides = (cls, scls) => {
-    if (scls === true) return;
-    scls.forEach((c) => {
-      c.decls &&
-        Object.values(c.decls).forEach((f) => {
-          if (f.type == "FunctionDeclaration") {
-            if (hasProperty(cls.decls, f.name)) {
-              f.hasOverride = true;
-            }
-          }
+    state.allClasses.forEach((elm) => {
+        if (elm.node.superClass) {
+            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const superClass = classes &&
+                classes.filter((c) => isStateNode(c) && c.type === "ClassDeclaration");
+            // set it "true" if there is a superClass, but we can't find it.
+            elm.superClass = superClass && superClass.length ? superClass : true;
+        }
+    });
+    const markOverrides = (cls, scls) => {
+        if (scls === true)
+            return;
+        scls.forEach((c) => {
+            c.decls &&
+                Object.values(c.decls).forEach((funcs) => {
+                    funcs.forEach((f) => {
+                        if (isStateNode(f) &&
+                            f.type === "FunctionDeclaration" &&
+                            hasProperty(cls.decls, f.name)) {
+                            f.node.hasOverride = true;
+                        }
+                    });
+                });
+            if (c.superClass)
+                markOverrides(cls, c.superClass);
         });
-      if (c.superClass) markOverrides(cls, c.superClass);
+    };
+    state.allClasses.forEach((elm) => {
+        if (elm.superClass)
+            markOverrides(elm, elm.superClass);
     });
-  };
-
-  state.allClasses.forEach((elm) => {
-    if (elm.superClass) markOverrides(elm, elm.superClass);
-  });
 }
-
-async function analyze(fileNames, buildConfig) {
-  const excludeAnnotations =
-    buildConfig && buildConfig.excludeAnnotations
-      ? Object.fromEntries(buildConfig.excludeAnnotations.map((a) => [a, true]))
-      : {};
-
-  const allImports = [];
-  const state = {
-    allFunctions: [],
-    allClasses: [],
-    shouldExclude(node) {
-      if (node.attrs && node.attrs.attrs) {
-        if (
-          node.attrs.attrs.filter((attr) => {
-            if (attr.type != "UnaryExpression") return false;
-            if (attr.argument.type != "Identifier") return false;
-            return hasProperty(excludeAnnotations, attr.argument.name);
-          }).length
-        ) {
-          return true;
-        }
-      }
-    },
-    post(node) {
-      switch (node.type) {
-        case "FunctionDeclaration":
-        case "ClassDeclaration": {
-          const [scope] = state.stack.slice(-1);
-          const stack = state.stack.slice(0, -1);
-          scope.stack = stack;
-          (node.type == "FunctionDeclaration"
-            ? state.allFunctions
-            : state.allClasses
-          ).push(scope);
-          return;
+function getFileSources(fnMap) {
+    return Promise.all(Object.entries(fnMap).map(([name, value]) => {
+        return (value.monkeyCSource ||
+            fs
+                .readFile(name)
+                .then((data) => (value.monkeyCSource = data.toString().replace(/\r\n/g, "\n"))));
+    })).then(() => { });
+}
+function getFileASTs(fnMap) {
+    return getFileSources(fnMap).then(() => Object.entries(fnMap).reduce((ok, [name, value]) => {
+        if (!value.ast) {
+            try {
+                value.ast = MonkeyC.parsers.monkeyc.parse(value.monkeyCSource, null, {
+                    filepath: name,
+                });
+            }
+            catch (e) {
+                ok = false;
+                if (e instanceof Error) {
+                    value.parserError = e;
+                }
+                else {
+                    value.parserError = new Error("An unknown parser error occurred");
+                }
+            }
         }
-        case "Using":
-        case "ImportModule":
-          allImports.push({ node, stack: state.stack.slice() });
-          return;
-      }
-    },
-  };
-
-  await getApiMapping(state);
-
-  // Mark all functions from api.mir as "special" by
-  // setting their bodies to null. In api.mir, they're
-  // all empty, which makes it look like they're
-  // do-nothing functions.
-  const markApi = (node) => {
-    if (node.type == "FunctionDeclaration") {
-      node.node.body = null;
-    }
-    if (node.decls) {
-      Object.values(node.decls).forEach(markApi);
-    }
-  };
-  markApi(state.stack[0]);
-
-  const files = await Promise.all(
-    fileNames.map(async (name) => ({
-      name,
-      monkeyCSource: (await fs.readFile(name))
-        .toString()
-        .replace(/\r\n/g, "\n"),
-    }))
-  );
-
-  files.forEach((f) => {
-    f.ast = MonkeyC.parsers.monkeyc.parse(f.monkeyCSource, {
-      grammarSource: f.name,
-    });
-    f.ast.source = f.name;
-    f.ast.monkeyCSource = f.monkeyCSource;
-    delete f.monkeyCSource;
-    collectNamespaces(f.ast, state);
-  });
-
-  delete state.shouldExclude;
-  delete state.post;
-
-  processImports(allImports, state.lookup);
-  collectClassInfo(state);
-
-  return { files, state };
+        return ok;
+    }, true));
 }
-
-function getLiteralNode(node) {
-  if (Array.isArray(node)) {
-    if (!node.length) return null;
-    if (node.length === 1) return getLiteralNode(node[0]);
-    let result;
-    if (
-      node.every((n) => {
-        const lit = getLiteralNode(n);
-        if (!lit) return false;
-        if (!result) {
-          result = lit;
-        } else {
-          if (lit.value !== result.value) return false;
+async function analyze(fnMap) {
+    let excludeAnnotations;
+    let hasTests = false;
+    const allImports = [];
+    const state = {
+        allFunctions: [],
+        allClasses: [],
+        shouldExclude(node) {
+            if ("attrs" in node &&
+                node.attrs &&
+                "attrs" in node.attrs &&
+                node.attrs.attrs) {
+                return node.attrs.attrs.reduce((drop, attr) => {
+                    if (attr.type != "UnaryExpression")
+                        return drop;
+                    if (attr.argument.type != "Identifier")
+                        return drop;
+                    if (hasProperty(excludeAnnotations, attr.argument.name)) {
+                        return true;
+                    }
+                    if (attr.argument.name == "test") {
+                        hasTests = true;
+                    }
+                    return drop;
+                }, false);
+            }
+            return null;
+        },
+        post(node) {
+            switch (node.type) {
+                case "FunctionDeclaration":
+                case "ClassDeclaration": {
+                    const [scope] = state.stack.slice(-1);
+                    const stack = state.stack.slice(0, -1);
+                    scope.stack = stack;
+                    if (scope.type == "FunctionDeclaration") {
+                        state.allFunctions.push(scope);
+                    }
+                    else {
+                        state.allClasses.push(scope);
+                    }
+                    return null;
+                }
+                case "Using":
+                case "ImportModule":
+                    allImports.push({ node, stack: state.stack.slice() });
+                    return null;
+            }
+        },
+    };
+    await getApiMapping(state);
+    // Mark all functions from api.mir as "special" by
+    // setting their bodies to null. In api.mir, they're
+    // all empty, which makes it look like they're
+    // do-nothing functions.
+    const markApi = (node) => {
+        if (node.type == "FunctionDeclaration") {
+            node.node.body = null;
         }
-        return true;
-      })
-    ) {
-      return result;
-    }
-    return null;
-  }
-  if (node.type == "Literal") return node;
-  if (node.type == "BinaryExpression" && node.operator == "as") {
-    return getLiteralNode(node.left) && node;
-  }
-  if (node.type == "UnaryExpression") {
-    if (node.argument.type != "Literal") return null;
-    switch (node.operator) {
-      case "-":
-        if (typeof node.argument.value == "number") {
-          return {
-            ...node.argument,
-            value: -node.argument.value,
-            raw: "-" + node.argument.value,
-            enumType: node.enumType,
-          };
+        if ("decls" in node) {
+            Object.values(node.decls).forEach((v) => v.forEach(markApi));
         }
-    }
-  }
+    };
+    markApi(state.stack[0]);
+    await getFileASTs(fnMap);
+    Object.entries(fnMap).forEach(([name, value]) => {
+        const { ast, parserError } = value;
+        if (!ast) {
+            throw parserError || new Error(`Failed to parse ${name}`);
+        }
+        excludeAnnotations = value.excludeAnnotations;
+        hasTests = false;
+        collectNamespaces(ast, state);
+        value.hasTests = hasTests;
+    });
+    delete state.shouldExclude;
+    delete state.post;
+    processImports(allImports, state.lookup);
+    collectClassInfo(state);
+    return state;
 }
-
-function getNodeValue(node) {
-  if (
-    node.type == "BinaryExpression" &&
-    node.operator == "as" &&
-    node.right.type == "TypeSpecList" &&
-    node.right.ts.length == 1 &&
-    typeof node.right.ts[0] == "string"
-  ) {
-    // this is a cast we inserted to retain the type of an enum
-    // any arithmetic on it will revert to "Number", or "Long",
-    // so just ignore it.
-    return getNodeValue(node.left);
-  }
-  if (node.type != "Literal") {
-    return [null, null];
-  }
-  let type = node.value === null ? "Null" : typeof node.value;
-  if (type === "number") {
-    const match = LiteralIntegerRe.exec(node.raw);
-    if (match) {
-      type = match[2] == "l" ? "Long" : "Number";
-    } else if (node.raw.endsWith("d")) {
-      type = "Double";
-    } else {
-      type = "Float";
-    }
-  } else if (type === "string") {
-    type = "String";
-  } else if (type === "boolean") {
-    type = "Boolean";
-  } else {
-    type = "Unknown";
-  }
-  return [node, type];
+function compareLiteralLike(a, b) {
+    while (a.type === "BinaryExpression")
+        a = a.left;
+    while (b.type === "BinaryExpression")
+        b = b.left;
+    return a.type === "Literal" && b.type === "Literal" && a.value === b.value;
 }
-
-function optimizeNode(node) {
-  switch (node.type) {
-    case "UnaryExpression": {
-      const [arg, type] = getNodeValue(node.argument);
-      if (arg === null) break;
-      switch (node.operator) {
-        case "+":
-          if (type === "Number" || type === "Long") {
-            return arg;
-          }
-          break;
-        case "-":
-          if (type === "Number" || type === "Long") {
-            return {
-              ...arg,
-              value: -arg.value,
-              raw: (-arg.value).toString() + (type === "Long" ? "l" : ""),
-            };
-          }
-          break;
-        case "!":
-        case "~":
-          {
-            let value;
-            if (type === "Number" || type === "Long") {
-              value = -arg.value - 1;
-            } else if (type === "Boolean" && node.operator == "!") {
-              value = !arg.value;
+function getLiteralFromDecls(decls) {
+    if (!decls.length)
+        return null;
+    let result = null;
+    if (decls.every((d) => {
+        if (d.type === "EnumStringMember" ||
+            (d.type === "VariableDeclarator" && d.kind === "const")) {
+            const init = getLiteralNode(d.init);
+            if (!init)
+                return false;
+            if (!result) {
+                result = init;
+                return true;
             }
-            if (value !== undefined) {
-              return {
-                ...arg,
-                value,
-                raw: value.toString() + (type === "Long" ? "l" : ""),
-              };
+            else {
+                return compareLiteralLike(init, result);
             }
-          }
-          break;
-      }
-      break;
-    }
-    case "BinaryExpression": {
-      const operators = {
-        "+": (left, right) => left + right,
-        "-": (left, right) => left - right,
-        "*": (left, right) => left * right,
-        "/": (left, right) => Math.trunc(left / right),
-        "%": (left, right) => left % right,
-        "&": (left, right, type) => (type === "Number" ? left & right : null),
-        "|": (left, right, type) => (type === "Number" ? left | right : null),
-        "<<": (left, right, type) => (type === "Number" ? left << right : null),
-        ">>": (left, right, type) => (type === "Number" ? left >> right : null),
-      };
-      const op = operators[node.operator];
-      if (op) {
-        const [left, left_type] = getNodeValue(node.left);
-        const [right, right_type] = getNodeValue(node.right);
-        if (!left || !right) break;
-        if (
-          left_type != right_type ||
-          (left_type != "Number" && left_type != "Long")
-        ) {
-          break;
         }
-        const value = op(left.value, right.value, left_type);
-        if (value === null) break;
-        return {
-          ...left,
-          value,
-          raw: value.toString() + (left_type === "Long" ? "l" : ""),
-        };
-      }
-      break;
+        return false;
+    })) {
+        return result;
     }
-    case "FunctionDeclaration":
-      if (node.body && evaluateFunction(node, null) !== false) {
-        node.optimizable = true;
-      }
-      break;
-  }
+    return null;
 }
-
-function evaluateFunction(func, args) {
-  if (args && args.length != func.params.length) {
-    return false;
-  }
-  const paramValues =
-    args && Object.fromEntries(func.params.map((p, i) => [p.name, args[i]]));
-  let ret = null;
-  const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
-  try {
-    traverseAst(
-      body,
-      (node) => {
-        switch (node.type) {
-          case "BlockStatement":
-          case "ReturnStatement":
-          case "UnaryExpression":
-          case "BinaryExpression":
-          case "Literal":
-          case "Identifier":
-            return;
-          default:
-            throw new Error("Bad node type");
+function getLiteralNode(node) {
+    if (node.type == "Literal")
+        return node;
+    if (node.type == "BinaryExpression" && node.operator == "as") {
+        return getLiteralNode(node.left) && node;
+    }
+    if (node.type == "UnaryExpression") {
+        if (node.argument.type != "Literal")
+            return null;
+        switch (node.operator) {
+            case "-":
+                if (typeof node.argument.value == "number") {
+                    return {
+                        ...node.argument,
+                        value: -node.argument.value,
+                        raw: "-" + node.argument.value,
+                        enumType: node.enumType,
+                    };
+                }
         }
-      },
-      args &&
-        ((node) => {
-          switch (node.type) {
-            case "ReturnStatement":
-              ret = node.argument;
-              return;
-            case "BlockStatement":
-            case "Literal":
-              return;
-            case "Identifier":
-              if (hasProperty(paramValues, node.name)) {
-                return paramValues[node.name];
-              }
-            // fall through;
-            default: {
-              const repl = optimizeNode(node);
-              if (repl && repl.type === "Literal") return repl;
-              throw new Error("Didn't optimize");
-            }
-          }
-        })
-    );
-    return ret;
-  } catch (e) {
-    return false;
-  }
-}
-
-async function optimizeMonkeyC(fileNames, buildConfig) {
-  const { files, state } = await analyze(fileNames, buildConfig);
-  const replace = (node, obj) => {
-    for (const k of Object.keys(node)) {
-      delete node[k];
     }
-    if (obj.enumType) {
-      obj = {
-        type: "BinaryExpression",
-        operator: "as",
-        left: obj,
-        right: { type: "TypeSpecList", ts: [obj.enumType] },
-      };
+    return null;
+}
+function getNodeValue(node) {
+    if (node.type == "BinaryExpression" &&
+        node.operator == "as" &&
+        node.right.type == "TypeSpecList" &&
+        node.right.ts.length == 1 &&
+        typeof node.right.ts[0] == "string") {
+        // this is a cast we inserted to retain the type of an enum
+        // any arithmetic on it will revert to "Number", or "Long",
+        // so just ignore it.
+        return getNodeValue(node.left);
     }
-    for (const [k, v] of Object.entries(obj)) {
-      node[k] = v;
+    if (node.type != "Literal") {
+        return [null, null];
     }
-  };
-  const lookupAndReplace = (node) => {
-    const [, objects] = state.lookup(node);
-    if (!objects) {
-      return false;
+    let type = node.value === null ? "Null" : typeof node.value;
+    if (type === "number") {
+        const match = LiteralIntegerRe.exec(node.raw);
+        if (match) {
+            type = match[2] == "l" ? "Long" : "Number";
+        }
+        else if (node.raw.endsWith("d")) {
+            type = "Double";
+        }
+        else {
+            type = "Float";
+        }
     }
-    const obj = getLiteralNode(objects);
-    if (!obj) {
-      return false;
+    else if (type === "string") {
+        type = "String";
     }
-    replace(node, obj);
-    return true;
-  };
-
-  /*
-   * Might this function be called from somewhere, including
-   * callbacks from the api (eg getSettingsView, etc).
-   */
-  const maybeCalled = (func) => {
-    if (!func.body) {
-      // this is an api.mir function. It can be called
-      return true;
+    else if (type === "boolean") {
+        type = "Boolean";
     }
-    if (hasProperty(state.exposed, func.id.name)) return true;
-    if (hasProperty(state.calledFunctions, func.id.name)) {
-      return (
-        state.calledFunctions[func.id.name].find((f) => f === func) !== null
-      );
+    else {
+        type = "Unknown";
     }
-  };
-  /*
-   * Does elm (a class) have a maybeCalled function called name,
-   * anywhere in its superClass chain.
-   */
-  const checkInherited = (elm, name) =>
-    elm.superClass === true ||
-    elm.superClass.some(
-      (sc) =>
-        (hasProperty(sc.decls, name) &&
-          sc.decls[name].some(
-            (f) => f.type == "FunctionDeclaration" && maybeCalled(f)
-          )) ||
-        (sc.superClass && checkInherited(sc, name))
-    );
-
-  state.localsStack = [{}];
-  state.exposed = {};
-  state.calledFunctions = {};
-  state.pre = (node) => {
+    return [node, type];
+}
+function optimizeNode(node) {
     switch (node.type) {
-      case "ConditionalExpression":
-      case "IfStatement":
-      case "DoWhileStatement":
-      case "WhileStatement":
-        state.traverse(node.test);
-        const [value, type] = getNodeValue(node.test);
-        if (value) {
-          let result = null;
-          if (type === "Null") {
-            result = false;
-          } else if (
-            type === "Boolean" ||
-            type === "Number" ||
-            type === "Long"
-          ) {
-            result = !!value.value;
-          }
-          if (result !== null) {
-            if (
-              node.type === "IfStatement" ||
-              node.type === "ConditionalExpression"
-            ) {
-              if (result === false) {
-                node.consequent = null;
-              } else {
-                node.alternate = null;
-              }
-              node.test = result;
-            } else if (node.type === "WhileStatement") {
-              if (result === false) {
-                node.body = null;
-              }
-            } else if (node.type === "DoWhileStatement") {
-              if (result === false) {
-                node.test = null;
-              }
-            } else {
-              throw new Error("Unexpected Node type");
+        case "UnaryExpression": {
+            const [arg, type] = getNodeValue(node.argument);
+            if (arg === null)
+                break;
+            switch (node.operator) {
+                case "+":
+                    if (type === "Number" || type === "Long") {
+                        return arg;
+                    }
+                    break;
+                case "-":
+                    if (type === "Number" || type === "Long") {
+                        return {
+                            ...arg,
+                            value: -arg.value,
+                            raw: (-arg.value).toString() + (type === "Long" ? "l" : ""),
+                        };
+                    }
+                    break;
+                case "!":
+                case "~":
+                    {
+                        let value;
+                        if (type === "Number" || type === "Long") {
+                            value = -arg.value - 1;
+                        }
+                        else if (type === "Boolean" && node.operator == "!") {
+                            value = !arg.value;
+                        }
+                        if (value !== undefined) {
+                            return {
+                                ...arg,
+                                value,
+                                raw: value.toString() + (type === "Long" ? "l" : ""),
+                            };
+                        }
+                    }
+                    break;
             }
-          }
+            break;
         }
-        return;
-
-      case "EnumDeclaration":
-        return false;
-      case "ForStatement": {
-        const map = state.localsStack.slice(-1).pop().map;
-        if (map) {
-          state.localsStack.push({ node, map: { ...map } });
+        case "BinaryExpression": {
+            const operators = {
+                "+": (left, right) => left + right,
+                "-": (left, right) => left - right,
+                "*": (left, right) => left * right,
+                "/": (left, right) => Math.trunc(left / right),
+                "%": (left, right) => left % right,
+                "&": (left, right, type) => type === "Number" ? left & right : null,
+                "|": (left, right, type) => type === "Number" ? left | right : null,
+                "<<": (left, right, type) => type === "Number" ? left << right : null,
+                ">>": (left, right, type) => type === "Number" ? left >> right : null,
+            };
+            const op = operators[node.operator];
+            if (op) {
+                const [left, left_type] = getNodeValue(node.left);
+                const [right, right_type] = getNodeValue(node.right);
+                if (!left || !right)
+                    break;
+                if (left_type != right_type ||
+                    (left_type != "Number" && left_type != "Long")) {
+                    break;
+                }
+                const value = op(left.value, right.value, left_type);
+                if (value === null)
+                    break;
+                return {
+                    ...left,
+                    value,
+                    raw: value.toString() + (left_type === "Long" ? "l" : ""),
+                };
+            }
+            break;
         }
-        break;
-      }
-      case "VariableDeclarator": {
-        const locals = state.localsStack.slice(-1).pop();
-        const { map } = locals;
-        if (map) {
-          if (hasProperty(map, node.id.name)) {
-            // We already have a variable with this name in scope
-            // Recent monkeyc compilers complain, so rename it
-            let suffix = 0;
-            let node_name = node.id.name;
-            const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
-            if (match) {
-              node_name = match[1];
-              suffix = parseInt(match[2], 10) + 1;
+        case "FunctionDeclaration":
+            if (node.body && evaluateFunction(node, null) !== false) {
+                node.optimizable = true;
             }
-            if (!locals.inners) {
-              // find all the names declared in this scope, to avoid
-              // more conflicts
-              locals.inners = {};
-              traverseAst(locals.node, (node) => {
-                if (node.type === "VariableDeclarator") {
-                  locals.inners[node.id.name] = true;
-                }
-              });
+            break;
+    }
+    return null;
+}
+function evaluateFunction(func, args) {
+    if (args && args.length != func.params.length) {
+        return false;
+    }
+    const paramValues = args &&
+        Object.fromEntries(func.params.map((p, i) => [variableDeclarationName(p), args[i]]));
+    let ret = null;
+    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    try {
+        traverseAst(body, (node) => {
+            switch (node.type) {
+                case "BlockStatement":
+                case "ReturnStatement":
+                case "UnaryExpression":
+                case "BinaryExpression":
+                case "Literal":
+                case "Identifier":
+                    return;
+                default:
+                    throw new Error("Bad node type");
             }
-            let name;
-            while (true) {
-              name = `pmcr_${node_name}_${suffix}`;
-              if (
-                !hasProperty(map, name) &&
-                !hasProperty(locals.inners, name)
-              ) {
-                // we also need to ensure that we don't hide the name of
-                // an outer module, class, function, enum or variable,
-                // since someone might want to access it from this scope.
-                let ok = false;
-                let i;
-                for (i = state.stack.length; i--; ) {
-                  const elm = state.stack[i];
-                  if (ok) {
-                    if (hasProperty(elm.decls, name)) {
-                      break;
+        }, args &&
+            ((node) => {
+                switch (node.type) {
+                    case "ReturnStatement":
+                        ret = node.argument;
+                        return null;
+                    case "BlockStatement":
+                    case "Literal":
+                        return null;
+                    case "Identifier":
+                        if (hasProperty(paramValues, node.name)) {
+                            return paramValues[node.name];
+                        }
+                    // fall through;
+                    default: {
+                        const repl = optimizeNode(node);
+                        if (repl && repl.type === "Literal")
+                            return repl;
+                        throw new Error("Didn't optimize");
                     }
-                  } else if (elm.node.type === "FunctionDeclaration") {
-                    ok = true;
-                  }
                 }
-                if (i < 0) {
-                  break;
-                }
-              }
-              suffix++;
-            }
-            map[node.id.name] = name;
-            map[name] = true;
-            node.id.name = name;
-          } else {
-            map[node.id.name] = true;
-          }
-        }
-        return ["init"];
-      }
-      case "UnaryExpression":
-        if (node.operator == ":") {
-          // If we produce a Symbol, for a given name,
-          // its possible that someone uses that symbol
-          // indirectly, so we can't remove any enums or
-          // constants with that name (we can still replace
-          // uses of those constants though).
-          state.exposed[node.argument.name] = true;
-          // In any case, we can't replace *this* use of the
-          // symbol with its value...
-          return false;
+            }));
+        return ret;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function optimizeMonkeyC(fnMap) {
+    const state = await analyze(fnMap);
+    const replace = (node, obj) => {
+        for (const k of Object.keys(node)) {
+            delete node[k];
         }
-        break;
-      case "Identifier": {
-        const map = state.localsStack.slice(-1).pop().map;
-        if (map) {
-          if (hasProperty(map, node.name)) {
-            const name = map[node.name];
-            if (name !== true) {
-              node.name = name;
-            }
-          }
+        if (obj.enumType) {
+            obj = {
+                type: "BinaryExpression",
+                operator: "as",
+                left: obj,
+                right: { type: "TypeSpecList", ts: [obj.enumType] },
+            };
         }
-        if (hasProperty(state.index, node.name)) {
-          if (!lookupAndReplace(node)) {
-            state.exposed[node.name] = true;
-          }
+        for (const [k, v] of Object.entries(obj)) {
+            node[k] = v;
         }
-        return false;
-      }
-      case "MemberExpression":
-        if (node.property.type === "Identifier" && !node.computed) {
-          if (hasProperty(state.index, node.property.name)) {
-            if (lookupAndReplace(node)) {
-              return false;
-            } else {
-              state.exposed[node.property.name] = true;
-            }
-          }
-          // Don't optimize the property.
-          return ["object"];
+    };
+    const lookupAndReplace = (node) => {
+        const [, objects] = state.lookup(node);
+        if (!objects) {
+            return false;
         }
-        break;
-      case "BlockStatement": {
-        const map = state.localsStack.slice(-1).pop().map;
-        if (map) {
-          state.localsStack.push({
-            node,
-            map: { ...map },
-          });
+        const obj = getLiteralFromDecls(objects);
+        if (!obj) {
+            return false;
         }
-        break;
-      }
-      case "FunctionDeclaration": {
-        const map = {};
-        node.params && node.params.forEach((p) => (map[p.name] = true));
-        state.localsStack.push({ node, map });
-        const [parent] = state.stack.slice(-2);
-        if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
-          let used = false;
-          if (node.id.name == "initialize") {
-            used = true;
-          } else if (parent.superClass) {
-            used = checkInherited(parent, node.id.name);
-          }
-          if (used) {
-            if (!hasProperty(state.calledFunctions, node.id.name)) {
-              state.calledFunctions[node.id.name] = [];
-            }
-            state.calledFunctions[node.id.name].push(node);
-          }
+        replace(node, obj);
+        return true;
+    };
+    /*
+     * Might this function be called from somewhere, including
+     * callbacks from the api (eg getSettingsView, etc).
+     */
+    const maybeCalled = (func) => {
+        if (!func.body) {
+            // this is an api.mir function. It can be called
+            return true;
         }
-      }
-    }
-  };
-  state.post = (node) => {
-    if (state.localsStack.slice(-1).pop().node === node) {
-      state.localsStack.pop();
-    }
-    const opt = optimizeNode(node);
-    if (opt) {
-      replace(node, opt);
-      return;
-    }
-    switch (node.type) {
-      case "ConditionalExpression":
-      case "IfStatement":
-        if (typeof node.test === "boolean") {
-          const rep = node.test ? node.consequent : node.alternate;
-          if (!rep) return false;
-          replace(node, rep);
+        if (hasProperty(state.exposed, func.id.name))
+            return true;
+        if (func.attrs &&
+            func.attrs.attrs &&
+            func.attrs.attrs.some((attr) => {
+                if (attr.type != "UnaryExpression")
+                    return false;
+                if (attr.argument.type != "Identifier")
+                    return false;
+                return attr.argument.name == "test";
+            })) {
+            return true;
         }
-        break;
-      case "WhileStatement":
-        if (!node.body) return false;
-        break;
-      case "DoWhileStatement":
-        if (!node.test) return node.body;
-        break;
-
-      case "CallExpression": {
-        const [name, callees] = state.lookup(node.callee);
-        if (!callees || !callees.length) {
-          const n =
-            name ||
-            node.callee.name ||
-            (node.callee.property && node.callee.property.name);
-          if (n) {
-            state.exposed[n] = true;
-          } else {
-            // There are unnamed CallExpressions, such as new [size]
-            // So there's nothing to do here.
-          }
-          return;
+        if (hasProperty(state.calledFunctions, func.id.name)) {
+            return (state.calledFunctions[func.id.name].find((f) => f === func) !== null);
         }
-        if (callees.length == 1) {
-          const callee = callees[0].node;
-          if (
-            callee.optimizable &&
-            !callee.hasOverride &&
-            node.arguments.every((n) => getNodeValue(n)[0] !== null)
-          ) {
-            const ret = evaluateFunction(callee, node.arguments);
-            if (ret) {
-              replace(node, ret);
-              return;
+        return false;
+    };
+    /*
+     * Does elm (a class) have a maybeCalled function called name,
+     * anywhere in its superClass chain.
+     */
+    const checkInherited = (elm, name) => elm.superClass === true ||
+        elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
+            sc.decls[name].some((f) => isStateNode(f) &&
+                f.type == "FunctionDeclaration" &&
+                maybeCalled(f.node))) ||
+            (sc.superClass && checkInherited(sc, name)));
+    state.localsStack = [{}];
+    state.exposed = {};
+    state.calledFunctions = {};
+    state.pre = (node) => {
+        switch (node.type) {
+            case "ConditionalExpression":
+            case "IfStatement":
+            case "DoWhileStatement":
+            case "WhileStatement":
+                state.traverse(node.test);
+                const [value, type] = getNodeValue(node.test);
+                if (value) {
+                    let result = null;
+                    if (type === "Null") {
+                        result = false;
+                    }
+                    else if (type === "Boolean" ||
+                        type === "Number" ||
+                        type === "Long") {
+                        result = !!value.value;
+                    }
+                    if (result !== null) {
+                        if (node.type === "IfStatement" ||
+                            node.type === "ConditionalExpression") {
+                            if (result === false) {
+                                node.consequent = null;
+                            }
+                            else {
+                                node.alternate = null;
+                            }
+                            node.test = null;
+                        }
+                        else if (node.type === "WhileStatement") {
+                            if (result === false) {
+                                node.body = null;
+                            }
+                        }
+                        else if (node.type === "DoWhileStatement") {
+                            if (result === false) {
+                                node.test = null;
+                            }
+                        }
+                        else {
+                            throw new Error("Unexpected Node type");
+                        }
+                    }
+                }
+                return null;
+            case "EnumDeclaration":
+                return false;
+            case "ForStatement": {
+                const map = state.localsStack.slice(-1).pop().map;
+                if (map) {
+                    state.localsStack.push({ node, map: { ...map } });
+                }
+                break;
+            }
+            case "VariableDeclarator": {
+                const locals = state.localsStack.slice(-1).pop();
+                const { map } = locals;
+                if (map) {
+                    const declName = variableDeclarationName(node.id);
+                    if (hasProperty(map, declName)) {
+                        // We already have a variable with this name in scope
+                        // Recent monkeyc compilers complain, so rename it
+                        let suffix = 0;
+                        let node_name = declName;
+                        const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
+                        if (match) {
+                            node_name = match[1];
+                            suffix = parseInt(match[2], 10) + 1;
+                        }
+                        if (!locals.inners) {
+                            // find all the names declared in this scope, to avoid
+                            // more conflicts
+                            locals.inners = {};
+                            traverseAst(locals.node, (node) => {
+                                if (node.type === "VariableDeclarator") {
+                                    locals.inners[variableDeclarationName(node.id)] = true;
+                                }
+                            });
+                        }
+                        let name;
+                        while (true) {
+                            name = `pmcr_${node_name}_${suffix}`;
+                            if (!hasProperty(map, name) &&
+                                !hasProperty(locals.inners, name)) {
+                                // we also need to ensure that we don't hide the name of
+                                // an outer module, class, function, enum or variable,
+                                // since someone might want to access it from this scope.
+                                let ok = false;
+                                let i;
+                                for (i = state.stack.length; i--;) {
+                                    const elm = state.stack[i];
+                                    if (ok) {
+                                        if (hasProperty(elm.decls, name)) {
+                                            break;
+                                        }
+                                    }
+                                    else if (elm.node.type === "FunctionDeclaration") {
+                                        ok = true;
+                                    }
+                                }
+                                if (i < 0) {
+                                    break;
+                                }
+                            }
+                            suffix++;
+                        }
+                        map[declName] = name;
+                        map[name] = true;
+                        if (node.id.type === "Identifier") {
+                            node.id.name = name;
+                        }
+                        else {
+                            node.id.left.name = name;
+                        }
+                    }
+                    else {
+                        map[declName] = true;
+                    }
+                }
+                return ["init"];
+            }
+            case "UnaryExpression":
+                if (node.operator == ":") {
+                    // If we produce a Symbol, for a given name,
+                    // its possible that someone uses that symbol
+                    // indirectly, so we can't remove any enums or
+                    // constants with that name (we can still replace
+                    // uses of those constants though).
+                    state.exposed[node.argument.name] = true;
+                    // In any case, we can't replace *this* use of the
+                    // symbol with its value...
+                    return false;
+                }
+                break;
+            case "Identifier": {
+                const map = state.localsStack.slice(-1).pop().map;
+                if (map) {
+                    if (hasProperty(map, node.name)) {
+                        const name = map[node.name];
+                        if (name !== true) {
+                            node.name = name;
+                        }
+                    }
+                }
+                if (hasProperty(state.index, node.name)) {
+                    if (!lookupAndReplace(node)) {
+                        state.exposed[node.name] = true;
+                    }
+                }
+                return false;
+            }
+            case "MemberExpression":
+                if (node.property.type === "Identifier" && !node.computed) {
+                    if (hasProperty(state.index, node.property.name)) {
+                        if (lookupAndReplace(node)) {
+                            return false;
+                        }
+                        else {
+                            state.exposed[node.property.name] = true;
+                        }
+                    }
+                    // Don't optimize the property.
+                    return ["object"];
+                }
+                break;
+            case "BlockStatement": {
+                const map = state.localsStack.slice(-1).pop().map;
+                if (map) {
+                    state.localsStack.push({
+                        node,
+                        map: { ...map },
+                    });
+                }
+                break;
+            }
+            case "FunctionDeclaration": {
+                const map = {};
+                node.params &&
+                    node.params.forEach((p) => (map[variableDeclarationName(p)] = true));
+                state.localsStack.push({ node, map });
+                const [parent] = state.stack.slice(-2);
+                if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
+                    let used = false;
+                    if (node.id.name == "initialize") {
+                        used = true;
+                    }
+                    else if (parent.superClass) {
+                        used = checkInherited(parent, node.id.name);
+                    }
+                    if (used) {
+                        if (!hasProperty(state.calledFunctions, node.id.name)) {
+                            state.calledFunctions[node.id.name] = [];
+                        }
+                        state.calledFunctions[node.id.name].push(node);
+                    }
+                }
             }
-          }
         }
-        if (!hasProperty(state.calledFunctions, name)) {
-          state.calledFunctions[name] = [];
+        return null;
+    };
+    state.post = (node) => {
+        if (state.localsStack.slice(-1).pop().node === node) {
+            state.localsStack.pop();
         }
-        callees.forEach((c) => state.calledFunctions[name].push(c.node));
-        break;
-      }
-    }
-  };
-  files.forEach((f) => {
-    collectNamespaces(f.ast, state);
-  });
-  files.forEach((f) => {
-    traverseAst(f.ast, null, (node) => {
-      switch (node.type) {
-        case "EnumStringBody":
-          if (
-            node.members.every((m) => {
-              const name = m.name || m.id.name;
-              return (
-                hasProperty(state.index, name) &&
-                !hasProperty(state.exposed, name)
-              );
-            })
-          ) {
-            node.enumType = [
-              ...new Set(
-                node.members.map((m) => {
-                  if (!m.init) return "Number";
-                  const [node, type] = getNodeValue(m.init);
-                  if (!node) {
-                    throw new Error("Failed to get type for eliminated enum");
-                  }
-                  return type;
-                })
-              ),
-            ].join(" or ");
-            node.members.splice(0);
-          }
-          break;
-        case "EnumDeclaration":
-          if (!node.body.members.length) {
-            if (!node.id) return false;
-            if (!node.body.enumType) {
-              throw new Error("Missing enumType on optimized enum");
+        const opt = optimizeNode(node);
+        if (opt) {
+            replace(node, opt);
+            return null;
+        }
+        switch (node.type) {
+            case "ConditionalExpression":
+            case "IfStatement":
+                if (node.test === null) {
+                    const rep = node.consequent || node.alternate;
+                    if (!rep)
+                        return false;
+                    replace(node, rep);
+                }
+                break;
+            case "WhileStatement":
+                if (!node.body)
+                    return false;
+                break;
+            case "DoWhileStatement":
+                if (!node.test)
+                    return node.body;
+                break;
+            case "CallExpression": {
+                const [name, callees] = state.lookup(node.callee);
+                if (!callees || !callees.length) {
+                    const n = name ||
+                        ("name" in node.callee && node.callee.name) ||
+                        ("property" in node.callee &&
+                            node.callee.property &&
+                            "name" in node.callee.property &&
+                            node.callee.property.name);
+                    if (n) {
+                        state.exposed[n] = true;
+                    }
+                    else {
+                        // There are unnamed CallExpressions, such as new [size]
+                        // So there's nothing to do here.
+                    }
+                    return null;
+                }
+                if (callees.length == 1) {
+                    const callee = isStateNode(callees[0]) && callees[0].node;
+                    if (callee.type == "FunctionDeclaration" &&
+                        callee.optimizable &&
+                        !callee.hasOverride &&
+                        node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
+                        const ret = evaluateFunction(callee, node.arguments);
+                        if (ret) {
+                            replace(node, ret);
+                            return null;
+                        }
+                    }
+                }
+                if (!hasProperty(state.calledFunctions, name)) {
+                    state.calledFunctions[name] = [];
+                }
+                callees.forEach((c) => isStateNode(c) && state.calledFunctions[name].push(c.node));
+                break;
             }
-            replace(node, {
-              type: "TypedefDeclaration",
-              id: node.id,
-              ts: {
-                type: "UnaryExpression",
-                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                prefix: true,
-                operator: " as",
-              },
-            });
-          }
-          break;
-        case "VariableDeclaration": {
-          node.declarations = node.declarations.filter(
-            (d) =>
-              !hasProperty(state.index, d.id.name) ||
-              hasProperty(state.exposed, d.id.name)
-          );
-          if (!node.declarations.length) {
-            return false;
-          }
-          break;
         }
-        case "ClassElement":
-          if (!node.item) {
-            return false;
-          }
-          break;
-        case "FunctionDeclaration":
-          if (!maybeCalled(node)) {
-            return false;
-          }
-          break;
-      }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        collectNamespaces(f.ast, state);
+    });
+    Object.values(fnMap).forEach((f) => {
+        traverseAst(f.ast, null, (node) => {
+            switch (node.type) {
+                case "EnumStringBody":
+                    if (node.members.every((m) => {
+                        const name = "name" in m ? m.name : m.id.name;
+                        return (hasProperty(state.index, name) &&
+                            !hasProperty(state.exposed, name));
+                    })) {
+                        node.enumType = [
+                            ...new Set(node.members.map((m) => {
+                                if (!("init" in m))
+                                    return "Number";
+                                const [node, type] = getNodeValue(m.init);
+                                if (!node) {
+                                    throw new Error("Failed to get type for eliminated enum");
+                                }
+                                return type;
+                            })),
+                        ].join(" or ");
+                        node.members.splice(0);
+                    }
+                    break;
+                case "EnumDeclaration":
+                    if (!node.body.members.length) {
+                        if (!node.id)
+                            return false;
+                        if (!node.body["enumType"]) {
+                            throw new Error("Missing enumType on optimized enum");
+                        }
+                        replace(node, {
+                            type: "TypedefDeclaration",
+                            id: node.id,
+                            ts: {
+                                type: "UnaryExpression",
+                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                                prefix: true,
+                                operator: " as",
+                            },
+                        });
+                    }
+                    break;
+                case "VariableDeclaration": {
+                    node.declarations = node.declarations.filter((d) => {
+                        const name = variableDeclarationName(d.id);
+                        return (!hasProperty(state.index, name) ||
+                            hasProperty(state.exposed, name));
+                    });
+                    if (!node.declarations.length) {
+                        return false;
+                    }
+                    break;
+                }
+                case "ClassElement":
+                    if (!node.item) {
+                        return false;
+                    }
+                    break;
+                case "FunctionDeclaration":
+                    if (!maybeCalled(node)) {
+                        return false;
+                    }
+                    break;
+            }
+            return null;
+        });
     });
-  });
-
-  return files;
 }
 
-;// CONCATENATED MODULE: ./src/negative-fixups.js
+;// CONCATENATED MODULE: ./src/negative-fixups.ts
 /*
  * This is strange. It pretty much has to be a bug in the sdk,
  * but its the same in every sdk.
@@ -823,48 +890,47 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
  * so we can fix them after reading api.mir.
  */
 const negativeFixups = [
-  "Toybox.Communications.BLE_CONNECTION_UNAVAILABLE",
-  "Toybox.Communications.INVALID_HTTP_BODY_IN_REQUEST",
-  "Toybox.Communications.REQUEST_CANCELLED",
-  "Toybox.Communications.UNSUPPORTED_CONTENT_TYPE_IN_RESPONSE",
-  "Toybox.Communications.UNABLE_TO_PROCESS_IMAGE",
-  "Toybox.Communications.NETWORK_RESPONSE_OUT_OF_MEMORY",
-  "Toybox.Communications.BLE_REQUEST_CANCELLED",
-  "Toybox.Communications.INVALID_HTTP_METHOD_IN_REQUEST",
-  "Toybox.Communications.BLE_NO_DATA",
-  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_REQUEST",
-  "Toybox.Communications.BLE_ERROR",
-  "Toybox.Communications.NETWORK_RESPONSE_TOO_LARGE",
-  "Toybox.Communications.INVALID_HTTP_BODY_IN_NETWORK_RESPONSE",
-  "Toybox.Communications.BLE_REQUEST_TOO_LARGE",
-  "Toybox.Communications.UNABLE_TO_PROCESS_MEDIA",
-  "Toybox.Communications.REQUEST_CONNECTION_DROPPED",
-  "Toybox.Communications.BLE_UNKNOWN_SEND_ERROR",
-  "Toybox.Communications.BLE_QUEUE_FULL",
-  "Toybox.Communications.STORAGE_FULL",
-  "Toybox.Communications.BLE_SERVER_TIMEOUT",
-  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_NETWORK_RESPONSE",
-  "Toybox.Communications.SECURE_CONNECTION_REQUIRED",
-  "Toybox.Communications.NETWORK_REQUEST_TIMED_OUT",
-  "Toybox.Communications.BLE_HOST_TIMEOUT",
-  "Toybox.Communications.UNABLE_TO_PROCESS_HLS",
-  "Toybox.Graphics.COLOR_TRANSPARENT",
-  "Toybox.AntPlus.INVALID_SPEED",
-  "Toybox.AntPlus.INVALID_CADENCE",
-  "Toybox.WatchUi.LAYOUT_VALIGN_START",
-  "Toybox.WatchUi.LAYOUT_VALIGN_TOP",
-  "Toybox.WatchUi.LAYOUT_VALIGN_BOTTOM",
-  "Toybox.WatchUi.LAYOUT_VALIGN_CENTER",
-  "Toybox.WatchUi.LAYOUT_HALIGN_RIGHT",
-  "Toybox.WatchUi.LAYOUT_HALIGN_CENTER",
-  "Toybox.WatchUi.LAYOUT_HALIGN_START",
-  "Toybox.WatchUi.LAYOUT_HALIGN_LEFT",
+    "Toybox.Communications.BLE_CONNECTION_UNAVAILABLE",
+    "Toybox.Communications.INVALID_HTTP_BODY_IN_REQUEST",
+    "Toybox.Communications.REQUEST_CANCELLED",
+    "Toybox.Communications.UNSUPPORTED_CONTENT_TYPE_IN_RESPONSE",
+    "Toybox.Communications.UNABLE_TO_PROCESS_IMAGE",
+    "Toybox.Communications.NETWORK_RESPONSE_OUT_OF_MEMORY",
+    "Toybox.Communications.BLE_REQUEST_CANCELLED",
+    "Toybox.Communications.INVALID_HTTP_METHOD_IN_REQUEST",
+    "Toybox.Communications.BLE_NO_DATA",
+    "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_REQUEST",
+    "Toybox.Communications.BLE_ERROR",
+    "Toybox.Communications.NETWORK_RESPONSE_TOO_LARGE",
+    "Toybox.Communications.INVALID_HTTP_BODY_IN_NETWORK_RESPONSE",
+    "Toybox.Communications.BLE_REQUEST_TOO_LARGE",
+    "Toybox.Communications.UNABLE_TO_PROCESS_MEDIA",
+    "Toybox.Communications.REQUEST_CONNECTION_DROPPED",
+    "Toybox.Communications.BLE_UNKNOWN_SEND_ERROR",
+    "Toybox.Communications.BLE_QUEUE_FULL",
+    "Toybox.Communications.STORAGE_FULL",
+    "Toybox.Communications.BLE_SERVER_TIMEOUT",
+    "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_NETWORK_RESPONSE",
+    "Toybox.Communications.SECURE_CONNECTION_REQUIRED",
+    "Toybox.Communications.NETWORK_REQUEST_TIMED_OUT",
+    "Toybox.Communications.BLE_HOST_TIMEOUT",
+    "Toybox.Communications.UNABLE_TO_PROCESS_HLS",
+    "Toybox.Graphics.COLOR_TRANSPARENT",
+    "Toybox.AntPlus.INVALID_SPEED",
+    "Toybox.AntPlus.INVALID_CADENCE",
+    "Toybox.WatchUi.LAYOUT_VALIGN_START",
+    "Toybox.WatchUi.LAYOUT_VALIGN_TOP",
+    "Toybox.WatchUi.LAYOUT_VALIGN_BOTTOM",
+    "Toybox.WatchUi.LAYOUT_VALIGN_CENTER",
+    "Toybox.WatchUi.LAYOUT_HALIGN_RIGHT",
+    "Toybox.WatchUi.LAYOUT_HALIGN_CENTER",
+    "Toybox.WatchUi.LAYOUT_HALIGN_START",
+    "Toybox.WatchUi.LAYOUT_HALIGN_LEFT",
 ];
 
 ;// CONCATENATED MODULE: external "./sdk-util.cjs"
 const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
-;// CONCATENATED MODULE: ./src/api.js
-
+;// CONCATENATED MODULE: ./src/api.ts
 
 
 
@@ -872,7 +938,6 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 
 
 
-const api_LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/i;
 /*
  * This is an unfortunate hack. I want to be able to extract things
  * like the types of all of a Class's variables (in particular the type
@@ -882,283 +947,307 @@ const api_LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/i;
  * undocumented. The same could be said of compiler.json and simulator.json,
  * but those are at least in a standard format.
  */
-
 // Extract all enum values from api.mir
 async function api_getApiMapping(state) {
-  // get the path to the currently active sdk
-  const parser = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc;
-
-  const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
-
-  const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
-    .toString()
-    .replace(/\r\n/g, "\n")
-    .replace(/^\s*\[.*?\]\s*$/gm, "")
-    //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
-    .replace(/^(\s*type)\s/gm, "$1def ");
-
-  try {
-    const result = api_collectNamespaces(parser.parse(api, {}), state);
-    negativeFixups.forEach((fixup) => {
-      const value = fixup.split(".").reduce((state, part) => {
-        const decls = state.decls[part];
-        if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
-          throw `Failed to find and fix negative constant ${fixup}`;
-        }
-        return decls[0];
-      }, result);
-      if (value.type != "Literal") {
-        throw `Negative constant ${fixup} was not a Literal`;
-      }
-      if (value.value > 0) {
-        value.value = -value.value;
-        value.raw = "-" + value.raw;
-      } else {
-        console.log(`Negative fixup ${fixup} was already negative!`);
-      }
-    });
-    return result;
-  } catch (e) {
-    console.error(e.toString());
-  }
+    // get the path to the currently active sdk
+    const parser = (prettier_plugin_monkeyc_default()).parsers.monkeyc;
+    const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
+    const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
+        .toString()
+        .replace(/\r\n/g, "\n")
+        .replace(/^\s*\[.*?\]\s*$/gm, "")
+        //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
+        .replace(/^(\s*type)\s/gm, "$1def ");
+    try {
+        const result = api_collectNamespaces(parser.parse(api, null, {
+            filepath: "api.mir",
+        }), state);
+        negativeFixups.forEach((fixup) => {
+            const value = fixup.split(".").reduce((state, part) => {
+                const decls = state.decls[part];
+                if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
+                    throw `Failed to find and fix negative constant ${fixup}`;
+                }
+                return decls[0];
+            }, result);
+            if (value.type !== "EnumStringMember" &&
+                (value.type !== "VariableDeclarator" || value.kind != "const")) {
+                throw `Negative constant ${fixup} did not refer to a constant`;
+            }
+            const init = value.init;
+            if (init.type !== "Literal") {
+                throw `Negative constant ${fixup} was not a Literal`;
+            }
+            if (init.value > 0) {
+                init.value = -init.value;
+                init.raw = "-" + init.raw;
+            }
+            else {
+                console.log(`Negative fixup ${fixup} was already negative!`);
+            }
+        });
+        return result;
+    }
+    catch (e) {
+        console.error(e.toString());
+        return null;
+    }
 }
-
 function api_hasProperty(obj, prop) {
-  return obj && Object.prototype.hasOwnProperty.call(obj, prop);
+    return obj && Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function api_isStateNode(node) {
+    return api_hasProperty(node, "node");
+}
+function api_variableDeclarationName(node) {
+    return ("left" in node ? node.left : node).name;
 }
-
 function api_collectNamespaces(ast, state) {
-  state = state || {};
-  if (!state.index) state.index = {};
-  if (!state.stack) {
-    state.stack = [{ type: "Program", name: "$", fullName: "$" }];
-  }
-  const checkOne = (ns, name) => {
-    if (api_hasProperty(ns.decls, name)) {
-      return ns.decls[name];
+    state = state || {};
+    if (!state.index)
+        state.index = {};
+    if (!state.stack) {
+        state.stack = [
+            { type: "Program", name: "$", fullName: "$", node: undefined },
+        ];
     }
-    return null;
-  };
-  state.lookup = (node, name, stack) => {
-    stack || (stack = state.stack);
-    switch (node.type) {
-      case "MemberExpression": {
-        if (node.property.type != "Identifier" || node.computed) break;
-        const [, module] = state.lookup(node.object, name, stack);
-        if (module && module.length === 1) {
-          const result = checkOne(module[0], node.property.name);
-          if (result) {
-            return [name || node.property.name, result];
-          }
-        }
-        break;
-      }
-      case "ThisExpression":
-        return [name, stack.slice(-1)];
-      case "Identifier": {
-        if (node.name == "$") {
-          return [name || node.name, [stack[0]]];
-        }
-        for (let i = stack.length; i--; ) {
-          const result = checkOne(stack[i], node.name);
-          if (result) {
-            return [name || node.name, result];
-          }
+    const checkOne = (ns, name) => {
+        if (api_isStateNode(ns) && api_hasProperty(ns.decls, name)) {
+            return ns.decls[name];
         }
-        break;
-      }
-    }
-    return [null, null];
-  };
-
-  state.traverse = (root) =>
-    api_traverseAst(
-      root,
-      (node) => {
-        try {
-          if (state.shouldExclude && state.shouldExclude(node)) {
-            // don't visit any children, but do call post
-            return [];
-          }
-          switch (node.type) {
-            case "Program":
-              if (state.stack.length != 1) {
-                throw new Error("Unexpected stack length for Program node");
-              }
-              if (node.source) {
-                state.stack[0].source = node.source;
-              }
-              break;
-            case "BlockStatement": {
-              const [parent] = state.stack.slice(-1);
-              if (
-                parent.type != "FunctionDeclaration" &&
-                parent.type != "BlockStatement"
-              ) {
+        return null;
+    };
+    state.lookup = (node, name, stack) => {
+        stack || (stack = state.stack);
+        switch (node.type) {
+            case "MemberExpression": {
+                if (node.property.type != "Identifier" || node.computed)
+                    break;
+                const [, module, where] = state.lookup(node.object, name, stack);
+                if (module && module.length === 1) {
+                    const result = checkOne(module[0], node.property.name);
+                    if (result) {
+                        return [
+                            name || node.property.name,
+                            result,
+                            where.concat(module[0]),
+                        ];
+                    }
+                }
                 break;
-              }
-              // fall through
             }
-            case "ClassDeclaration":
-            case "FunctionDeclaration":
-            case "ModuleDeclaration":
-              if (node.id || node.type == "BlockStatement") {
-                const [parent] = state.stack.slice(-1);
-                const elm = {
-                  type: node.type,
-                  name: node.id && node.id.name,
-                  node,
-                };
-                state.stack.push(elm);
-                elm.fullName = state.stack
-                  .map((e) => e.name)
-                  .filter((e) => e != null)
-                  .join(".");
-                if (elm.name) {
-                  if (!parent.decls) parent.decls = {};
-                  if (api_hasProperty(parent.decls, elm.name)) {
-                    const what =
-                      node.type == "ModuleDeclaration" ? "type" : "node";
-                    const e = parent.decls[elm.name].find(
-                      (d) => d[what] == elm[what]
-                    );
-                    if (e != null) {
-                      e.node = node;
-                      state.stack.splice(-1, 1, e);
-                      break;
+            case "ThisExpression": {
+                for (let i = stack.length; i--;) {
+                    const si = stack[i];
+                    if (si.type == "ModuleDeclaration" ||
+                        si.type == "ClassDeclaration" ||
+                        !i) {
+                        return [name || si.name, [si], stack.slice(0, i)];
                     }
-                  } else {
-                    parent.decls[elm.name] = [];
-                  }
-                  parent.decls[elm.name].push(elm);
                 }
-              }
-              break;
-            // an EnumDeclaration doesn't create a scope, but
-            // it does create a type (if it has a name)
-            case "EnumDeclaration": {
-              if (!node.id) break;
-              const [parent] = state.stack.slice(-1);
-              const name = (parent.fullName + "." + node.id.name).replace(
-                /^\$\./,
-                ""
-              );
-              node.body.members.forEach((m) => ((m.init || m).enumType = name));
-            }
-            // fall through
-            case "TypedefDeclaration": {
-              const [parent] = state.stack.slice(-1);
-              if (!parent.decls) parent.decls = {};
-              if (!api_hasProperty(parent.decls, node.id.name)) {
-                parent.decls[node.id.name] = [];
-              }
-              (0,external_util_cjs_namespaceObject.pushUnique)(
-                parent.decls[node.id.name],
-                node.ts ? formatAst(node.ts.argument) : node.id.name
-              );
-              break;
+                break;
             }
-            case "VariableDeclaration": {
-              const [parent] = state.stack.slice(-1);
-              if (!parent.decls) parent.decls = {};
-              node.declarations.forEach((decl) => {
-                if (!api_hasProperty(parent.decls, decl.id.name)) {
-                  parent.decls[decl.id.name] = [];
+            case "Identifier": {
+                if (node.name == "$") {
+                    return [name || node.name, [stack[0]], []];
                 }
-                if (node.kind == "const") {
-                  (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[decl.id.name], decl.init);
-                  if (!api_hasProperty(state.index, decl.id.name)) {
-                    state.index[decl.id.name] = [];
-                  }
-                  (0,external_util_cjs_namespaceObject.pushUnique)(state.index[decl.id.name], parent);
-                } else if (decl.id.ts) {
-                  (0,external_util_cjs_namespaceObject.pushUnique)(
-                    parent.decls[decl.id.name],
-                    formatAst(decl.id.ts.argument)
-                  );
+                for (let i = stack.length; i--;) {
+                    const result = checkOne(stack[i], node.name);
+                    if (result) {
+                        return [name || node.name, result, stack.slice(0, i + 1)];
+                    }
                 }
-              });
-              break;
+                break;
+            }
+        }
+        return [null, null, null];
+    };
+    state.traverse = (root) => api_traverseAst(root, (node) => {
+        try {
+            if (state.shouldExclude && state.shouldExclude(node)) {
+                // don't visit any children, but do call post
+                return [];
             }
-            case "EnumStringBody": {
-              const [parent] = state.stack.slice(-1);
-              const values = parent.decls || (parent.decls = {});
-              let prev = -1;
-              node.members.forEach((m) => {
-                let name, init;
-                if (m.type == "EnumStringMember") {
-                  name = m.id.name;
-                  init = getLiteralNode(m.init);
-                  if (!init) {
-                    throw new Error("Unexpected enum initializer");
-                  }
-                  if (init != m.init) {
-                    m.init = init;
-                  }
-                  if (
-                    init.type == "Literal" &&
-                    api_LiteralIntegerRe.test(init.raw)
-                  ) {
-                    prev = init.value;
-                  }
-                } else {
-                  name = m.name;
-                  prev += 1;
-                  if (!state.constants) {
-                    state.constants = {};
-                  }
-                  const key = m.enumType ? `${m.enumType}:${prev}` : prev;
-                  init = state.constants[key];
-                  if (!init) {
-                    init = state.constants[key] = {
-                      type: "Literal",
-                      value: prev,
-                      raw: prev.toString(),
-                      enumType: m.enumType,
+            switch (node.type) {
+                case "Program":
+                    if (state.stack.length != 1) {
+                        throw new Error("Unexpected stack length for Program node");
+                    }
+                    break;
+                case "BlockStatement": {
+                    const [parent] = state.stack.slice(-1);
+                    if (parent.type != "FunctionDeclaration" &&
+                        parent.type != "BlockStatement") {
+                        break;
+                    }
+                    // fall through
+                }
+                case "ClassDeclaration":
+                case "FunctionDeclaration":
+                case "ModuleDeclaration": {
+                    const [parent] = state.stack.slice(-1);
+                    const name = "id" in node ? node.id && node.id.name : null;
+                    const fullName = state.stack
+                        .map((e) => e.name)
+                        .concat(name)
+                        .filter((e) => e != null)
+                        .join(".");
+                    const elm = {
+                        type: node.type,
+                        name,
+                        fullName,
+                        node,
                     };
-                  }
+                    state.stack.push(elm);
+                    if (name) {
+                        if (!parent.decls)
+                            parent.decls = {};
+                        if (api_hasProperty(parent.decls, elm.name)) {
+                            const what = node.type == "ModuleDeclaration" ? "type" : "node";
+                            const e = parent.decls[name].find((d) => api_isStateNode(d) && d[what] == elm[what]);
+                            if (e != null) {
+                                e.node = node;
+                                state.stack.splice(-1, 1, e);
+                                break;
+                            }
+                        }
+                        else {
+                            parent.decls[elm.name] = [];
+                        }
+                        if (node.type === "FunctionDeclaration" &&
+                            node.params &&
+                            node.params.length) {
+                            elm.decls = {};
+                            node.params.forEach((p) => (elm.decls[api_variableDeclarationName(p)] = [p]));
+                        }
+                        parent.decls[elm.name].push(elm);
+                    }
+                    break;
                 }
-                if (!api_hasProperty(values, name)) {
-                  values[name] = [];
+                // an EnumDeclaration doesn't create a scope, but
+                // it does create a type (if it has a name)
+                case "EnumDeclaration": {
+                    if (!node.id)
+                        break;
+                    const [parent] = state.stack.slice(-1);
+                    const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
+                    node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
                 }
-                (0,external_util_cjs_namespaceObject.pushUnique)(values[name], init);
-                if (!api_hasProperty(state.index, name)) {
-                  state.index[name] = [];
+                // fall through
+                case "TypedefDeclaration": {
+                    const [parent] = state.stack.slice(-1);
+                    if (!parent.decls)
+                        parent.decls = {};
+                    if (!api_hasProperty(parent.decls, node.id.name)) {
+                        parent.decls[node.id.name] = [];
+                    }
+                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[node.id.name], node);
+                    break;
+                }
+                case "VariableDeclaration": {
+                    const [parent] = state.stack.slice(-1);
+                    if (!parent.decls)
+                        parent.decls = {};
+                    node.declarations.forEach((decl) => {
+                        const name = api_variableDeclarationName(decl.id);
+                        if (!api_hasProperty(parent.decls, name)) {
+                            parent.decls[name] = [];
+                        }
+                        decl.kind = node.kind;
+                        (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[name], decl);
+                        if (node.kind == "const") {
+                            if (!api_hasProperty(state.index, name)) {
+                                state.index[name] = [];
+                            }
+                            (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
+                        }
+                    });
+                    break;
+                }
+                case "EnumStringBody": {
+                    const [parent] = state.stack.slice(-1);
+                    const values = parent.decls || (parent.decls = {});
+                    let prev = -1;
+                    node.members.forEach((m, i) => {
+                        if (m.type == "Identifier") {
+                            prev += 1;
+                            m = node.members[i] = {
+                                type: "EnumStringMember",
+                                loc: m.loc,
+                                start: m.start,
+                                end: m.end,
+                                id: m,
+                                init: {
+                                    type: "Literal",
+                                    value: prev,
+                                    raw: prev.toString(),
+                                    enumType: m.enumType,
+                                    loc: m.loc,
+                                    start: m.start,
+                                    end: m.end,
+                                },
+                            };
+                        }
+                        const name = m.id.name;
+                        const init = getLiteralNode(m.init);
+                        if (!init) {
+                            throw new Error("Unexpected enum initializer");
+                        }
+                        if (init != m.init) {
+                            m.init = init;
+                        }
+                        if (init.type == "Literal" && prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
+                            prev = init.value;
+                        }
+                        if (!api_hasProperty(values, name)) {
+                            values[name] = [];
+                        }
+                        (0,external_util_cjs_namespaceObject.pushUnique)(values[name], m);
+                        if (!api_hasProperty(state.index, name)) {
+                            state.index[name] = [];
+                        }
+                        (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
+                    });
+                    break;
                 }
-                (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
-              });
-              break;
             }
-          }
-          if (state.pre) return state.pre(node);
-        } catch (e) {
-          handleException(state, node, e);
+            if (state.pre)
+                return state.pre(node);
+        }
+        catch (e) {
+            handleException(state, node, e);
         }
-      },
-      (node) => {
+        return null;
+    }, (node) => {
         try {
-          let ret;
-          if (state.shouldExclude && state.shouldExclude(node)) {
-            // delete the node.
-            return false;
-          }
-          if (state.post) ret = state.post(node);
-          if (state.stack.slice(-1).pop().node === node) {
-            state.stack.pop();
-          }
-          return ret;
-        } catch (e) {
-          handleException(state, node, e);
+            let ret;
+            if (state.shouldExclude && state.shouldExclude(node)) {
+                // delete the node.
+                return false;
+            }
+            if (state.post)
+                ret = state.post(node);
+            if (state.stack.slice(-1).pop().node === node) {
+                state.stack.pop();
+            }
+            return ret;
+        }
+        catch (e) {
+            handleException(state, node, e);
         }
-      }
-    );
-  state.traverse(ast);
-  if (state.stack.length != 1) {
-    throw new Error("Invalid AST!");
-  }
-  return state.stack[0];
+    });
+    state.traverse(ast);
+    if (state.stack.length != 1) {
+        throw new Error("Invalid AST!");
+    }
+    if (state.stack[0].type != "Program") {
+        throw new Error("Bottom of stack was not a Program!");
+    }
+    return state.stack[0];
+}
+function isMCTreeNode(node) {
+    return node && typeof node === "object" && "type" in node;
 }
-
 /*
  * Traverse the ast rooted at node, calling pre before
  * visiting each node, and post after.
@@ -1173,84 +1262,83 @@ function api_collectNamespaces(ast, state) {
  *    removed.
  */
 function api_traverseAst(node, pre, post) {
-  const nodes = pre && pre(node);
-  if (nodes === false) return;
-  for (const key of nodes || Object.keys(node)) {
-    const value = node[key];
-    if (!value) continue;
-    if (Array.isArray(value)) {
-      const deletions = value.reduce((state, obj, i) => {
-        const repl = api_traverseAst(obj, pre, post);
-        if (repl === false) {
-          if (!state) state = {};
-          state[i] = true;
-        } else if (repl != null) {
-          value[i] = repl;
+    const nodes = pre && pre(node);
+    if (nodes === false)
+        return;
+    for (const key of nodes || Object.keys(node)) {
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            const values = value;
+            const deletions = values.reduce((state, obj, i) => {
+                if (isMCTreeNode(obj)) {
+                    const repl = api_traverseAst(obj, pre, post);
+                    if (repl === false) {
+                        if (!state)
+                            state = {};
+                        state[i] = true;
+                    }
+                    else if (repl != null) {
+                        values[i] = repl;
+                    }
+                }
+                return state;
+            }, null);
+            if (deletions) {
+                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true));
+            }
+        }
+        else if (isMCTreeNode(value)) {
+            const repl = api_traverseAst(value, pre, post);
+            if (repl === false) {
+                delete node[key];
+            }
+            else if (repl != null) {
+                node[key] = repl;
+            }
         }
-        return state;
-      }, null);
-      if (deletions) {
-        value.splice(
-          0,
-          value.length,
-          ...value.filter((obj, i) => deletions[i] !== true)
-        );
-      }
-    } else if (typeof value == "object" && value.type) {
-      const repl = api_traverseAst(value, pre, post);
-      if (repl === false) {
-        delete node[key];
-      } else if (repl != null) {
-        node[key] = repl;
-      }
     }
-  }
-  return post && post(node);
+    return post && post(node);
 }
-
-function formatAst(node, options) {
-  if (!node.monkeyCSource && node.comments) {
-    // Prettier inserts comments by using the source location to
-    // find the original comment, rather than using the contents
-    // of the comment as reported by the comment nodes themselves.
-    // If all we've got is the ast, rather than the actual
-    // source code, this goes horribly wrong, so just drop all
-    // the comments.
-    delete node.comments;
-  }
-  // If we *do* have the original source, pass that in ahead of the
-  // json. The parser knows to just treat the last line of the input
-  // as the ast itself, and the printers will find what they're
-  // looking for in the source.
-  const source =
-    (node.monkeyCSource ? node.monkeyCSource + "\n" : "") +
-    JSON.stringify(node);
-  return standalone_js_namespaceObject.format(source, {
-    ...(options || {}),
-    parser: "monkeyc-json",
-    plugins: [prettier_plugin_monkeyc_namespaceObject],
-    endOfLine: "lf",
-  });
+function formatAst(node, monkeyCSource = null) {
+    if ("comments" in node && !monkeyCSource) {
+        // Prettier inserts comments by using the source location to
+        // find the original comment, rather than using the contents
+        // of the comment as reported by the comment nodes themselves.
+        // If all we've got is the ast, rather than the actual
+        // source code, this goes horribly wrong, so just drop all
+        // the comments.
+        delete node.comments;
+    }
+    // If we *do* have the original source, pass that in ahead of the
+    // json. The parser knows to just treat the last line of the input
+    // as the ast itself, and the printers will find what they're
+    // looking for in the source.
+    const source = (monkeyCSource || "") + "\n" + JSON.stringify(node);
+    return standalone_js_default().format(source, {
+        parser: "monkeyc-json",
+        plugins: [(prettier_plugin_monkeyc_default())],
+        endOfLine: "lf",
+    });
 }
-
 function handleException(state, node, exception) {
-  let message;
-  try {
-    const fullName = state.stack
-      .map((e) => e.name)
-      .concat(node.name)
-      .filter((e) => e != null)
-      .join(".");
-    const location = state.stack[0].source
-      ? `${state.stack[0].source}:${node.start || 0}:${node.end || 0}`
-      : "<unknown>";
-    message = `Got exception \`${exception.toString()}' while processing node ${fullName}:${
-      node.type
-    } from ${location}`;
-  } catch {
-    throw exception;
-  }
-  throw new Error(message);
+    let message;
+    try {
+        const fullName = state.stack
+            .map((e) => e.name)
+            .concat("name" in node && typeof node.name === "string" ? node.name : null)
+            .filter((e) => e != null)
+            .join(".");
+        const location = node.loc && node.loc.source
+            ? `${node.loc.source}:${node.start || 0}:${node.end || 0}`
+            : "<unknown>";
+        message = `Got exception \`${exception.toString()}' while processing node ${fullName}:${node.type} from ${location}`;
+    }
+    catch {
+        throw exception;
+    }
+    throw new Error(message);
 }
 
 var __webpack_export_target__ = exports;