@markw65/monkeyc-optimizer 1.1.33 → 1.1.34

package/build/api.cjs

@@ -18,44 +18,44 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_7ANQTFGD.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_7ANQTFGD.collectNamespaces,
-  createDocumentationMap: () => import_chunk_7ANQTFGD.createDocumentationMap,
-  diagnostic: () => import_chunk_7ANQTFGD.diagnostic,
-  diagnosticHelper: () => import_chunk_7ANQTFGD.diagnosticHelper,
-  findNamesInScope: () => import_chunk_7ANQTFGD.findNamesInScope,
-  findUsingForNode: () => import_chunk_7ANQTFGD.findUsingForNode,
-  formatAst: () => import_chunk_7ANQTFGD.formatAst,
-  formatAstLongLines: () => import_chunk_7ANQTFGD.formatAstLongLines,
-  getApiFunctionInfo: () => import_chunk_7ANQTFGD.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_7ANQTFGD.getApiMapping,
-  getSuperClasses: () => import_chunk_7ANQTFGD.getSuperClasses,
+  checkCompilerVersion: () => import_chunk_QBCVUVLD.checkCompilerVersion,
+  collectNamespaces: () => import_chunk_QBCVUVLD.collectNamespaces,
+  createDocumentationMap: () => import_chunk_QBCVUVLD.createDocumentationMap,
+  diagnostic: () => import_chunk_QBCVUVLD.diagnostic,
+  diagnosticHelper: () => import_chunk_QBCVUVLD.diagnosticHelper,
+  findNamesInScope: () => import_chunk_QBCVUVLD.findNamesInScope,
+  findUsingForNode: () => import_chunk_QBCVUVLD.findUsingForNode,
+  formatAst: () => import_chunk_QBCVUVLD.formatAst,
+  formatAstLongLines: () => import_chunk_QBCVUVLD.formatAstLongLines,
+  getApiFunctionInfo: () => import_chunk_QBCVUVLD.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_QBCVUVLD.getApiMapping,
+  getSuperClasses: () => import_chunk_QBCVUVLD.getSuperClasses,
   hasProperty: () => import_chunk_MBTLUWXR.hasProperty,
-  isClassVariable: () => import_chunk_7ANQTFGD.isClassVariable,
-  isLocal: () => import_chunk_7ANQTFGD.isLocal,
-  isLookupCandidate: () => import_chunk_7ANQTFGD.isLookupCandidate,
-  isStateNode: () => import_chunk_7ANQTFGD.isStateNode,
-  lookupByFullName: () => import_chunk_7ANQTFGD.lookupByFullName,
-  lookupNext: () => import_chunk_7ANQTFGD.lookupNext,
-  lookupResultContains: () => import_chunk_7ANQTFGD.lookupResultContains,
-  lookupWithType: () => import_chunk_7ANQTFGD.lookupWithType,
-  makeToyboxLink: () => import_chunk_7ANQTFGD.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_7ANQTFGD.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_7ANQTFGD.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_7ANQTFGD.parseSdkVersion,
-  sameLookupResult: () => import_chunk_7ANQTFGD.sameLookupResult,
+  isClassVariable: () => import_chunk_QBCVUVLD.isClassVariable,
+  isLocal: () => import_chunk_QBCVUVLD.isLocal,
+  isLookupCandidate: () => import_chunk_QBCVUVLD.isLookupCandidate,
+  isStateNode: () => import_chunk_QBCVUVLD.isStateNode,
+  lookupByFullName: () => import_chunk_QBCVUVLD.lookupByFullName,
+  lookupNext: () => import_chunk_QBCVUVLD.lookupNext,
+  lookupResultContains: () => import_chunk_QBCVUVLD.lookupResultContains,
+  lookupWithType: () => import_chunk_QBCVUVLD.lookupWithType,
+  makeToyboxLink: () => import_chunk_QBCVUVLD.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_QBCVUVLD.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_QBCVUVLD.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_QBCVUVLD.parseSdkVersion,
+  sameLookupResult: () => import_chunk_QBCVUVLD.sameLookupResult,
   traverseAst: () => import_chunk_MBTLUWXR.traverseAst,
-  variableDeclarationName: () => import_chunk_7ANQTFGD.variableDeclarationName,
-  visitReferences: () => import_chunk_7ANQTFGD.visitReferences,
-  visit_resources: () => import_chunk_7ANQTFGD.visit_resources,
-  visitorNode: () => import_chunk_7ANQTFGD.visitorNode
+  variableDeclarationName: () => import_chunk_QBCVUVLD.variableDeclarationName,
+  visitReferences: () => import_chunk_QBCVUVLD.visitReferences,
+  visit_resources: () => import_chunk_QBCVUVLD.visit_resources,
+  visitorNode: () => import_chunk_QBCVUVLD.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_7ANQTFGD = require("./chunk-7ANQTFGD.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7ANQTFGD.init_api)();
+(0, import_chunk_QBCVUVLD.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/{chunk-7ANQTFGD.cjs → chunk-QBCVUVLD.cjs}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_7ANQTFGD_exports = {};
-__export(chunk_7ANQTFGD_exports, {
+var chunk_QBCVUVLD_exports = {};
+__export(chunk_QBCVUVLD_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -122,7 +122,7 @@ __export(chunk_7ANQTFGD_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_7ANQTFGD_exports);
+module.exports = __toCommonJS(chunk_QBCVUVLD_exports);
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -11724,19 +11724,70 @@ function getLhsConstraint(istate, node) {
       throw new Error("Checking types without a typeMap");
     }
     const object = istate.typeMap.get(node.object);
-    if (object && !node.computed) {
-      const [, trueDecls2] = findObjectDeclsByProperty(
-        istate.state,
-        object,
-        node
-      );
-      if (trueDecls2) {
-        lookupDefs = lookupNext(
+    if (object) {
+      if (node.computed) {
+        if (object.value) {
+          let result = null;
+          if (object.type & 512) {
+            const arr = getUnionComponent(
+              object,
+              512
+              /* Array */
+            );
+            if (arr) {
+              result = arr;
+            }
+          }
+          if (object.type & 1024) {
+            const dict = getUnionComponent(
+              object,
+              1024
+              /* Dictionary */
+            );
+            if (dict) {
+              if (result) {
+                result = cloneType(result);
+                unionInto(result, dict.value);
+              } else {
+                result = dict.value;
+              }
+            }
+          }
+          if (object.type & 32768) {
+            const obj = getUnionComponent(
+              object,
+              32768
+              /* Object */
+            );
+            if (obj && isByteArrayData(obj)) {
+              const t = {
+                type: 8 | 128
+                /* Char */
+              };
+              if (result) {
+                unionInto(t, result);
+              }
+              result = t;
+            }
+          }
+          if (result) {
+            return result;
+          }
+        }
+      } else {
+        const [, trueDecls2] = findObjectDeclsByProperty(
           istate.state,
-          [{ parent: null, results: trueDecls2 }],
-          "decls",
-          node.property
+          object,
+          node
         );
+        if (trueDecls2) {
+          lookupDefs = lookupNext(
+            istate.state,
+            [{ parent: null, results: trueDecls2 }],
+            "decls",
+            node.property
+          );
+        }
       }
     }
   }
@@ -11842,7 +11893,10 @@ function evaluateNode(istate, node) {
           });
           return;
         }
-        if (istate.checkTypes && !couldBe(left.value, right.value)) {
+        if (istate.checkTypes && !couldBe(left.value, right.value) && !subtypeOf({
+          type: 1 | 32768
+          /* Object */
+        }, right.value)) {
           diagnostic(
             istate.state,
             node,
@@ -12077,26 +12131,39 @@ function evaluateNode(istate, node) {
       if (!isLookupCandidate(node)) {
         const property = popIstate(istate, node.property);
         const object = popIstate(istate, node.object);
-        if (hasValue(object.value) && object.value.type === 512 && property.value.type & (8 | 16)) {
-          push({
-            value: object.value.value,
-            embeddedEffects: object.embeddedEffects || property.embeddedEffects,
-            node
-          });
-          break;
-        }
-        if (hasValue(object.value) && object.value.type === 1024 && property.value.type & object.value.value.key.type) {
-          const value2 = {
-            type: 1
-            /* Null */
-          };
-          unionInto(value2, object.value.value.value);
-          push({
-            value: value2,
-            embeddedEffects: object.embeddedEffects || property.embeddedEffects,
-            node
-          });
-          break;
+        if (hasValue(object.value)) {
+          if (object.value.type === 512 && property.value.type & (8 | 16)) {
+            push({
+              value: object.value.value,
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
+          if (object.value.type === 1024 && property.value.type & object.value.value.key.type) {
+            const value2 = {
+              type: 1
+              /* Null */
+            };
+            unionInto(value2, object.value.value.value);
+            push({
+              value: value2,
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
+          if (property.value.type & (8 | 16) && isByteArray(object.value)) {
+            push({
+              value: {
+                type: 8
+                /* Number */
+              },
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
         }
         push({
           value: {
@@ -12400,6 +12467,15 @@ function mustBeIdentical(a, b) {
   }
   return false;
 }
+function isByteArray(object) {
+  return hasValue(object) && object.type === 32768 && isByteArrayData(object.value);
+}
+function isByteArrayData(objectData) {
+  return objectData.klass.value && (0, import_chunk_PVBIKZYZ.every)(
+    objectData.klass.value,
+    (klass) => klass.fullName === "$.Toybox.Lang.ByteArray"
+  );
+}
 var init_interp = (0, import_chunk_ABYVSU2C.__esm)({
   "src/type-flow/interp.ts"() {
     "use strict";
@@ -12407,6 +12483,7 @@ var init_interp = (0, import_chunk_ABYVSU2C.__esm)({
     (0, import_chunk_MBTLUWXR.init_ast)();
     init_data_flow();
     init_optimizer_types();
+    (0, import_chunk_PVBIKZYZ.init_util)();
     init_could_be();
     init_interp_binary();
     init_interp_call();
@@ -14172,7 +14249,14 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
           next = findNextObjectType(istate, trueDecls, me);
         }
       } else {
-        if (cur.type & (4096 | 16384 | 32768)) {
+        let byteArray = false;
+        if (cur.type & 32768 && cur.value) {
+          const odata = getObjectValue(cur);
+          if (odata && isByteArrayData(odata)) {
+            byteArray = true;
+          }
+        }
+        if (cur.type & (4096 | 16384 | (byteArray ? 0 : 32768))) {
           next = {
             type: 524287
             /* Any */
@@ -14181,6 +14265,16 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
             updateAny = true;
           }
         } else {
+          if (byteArray) {
+            const t = {
+              type: 8
+              /* Number */
+            };
+            if (next) {
+              unionInto(t, next);
+            }
+            next = t;
+          }
           if (cur.type & 512) {
             const avalue = getUnionComponent(
               cur,
@@ -23752,7 +23846,7 @@ function simpleOpts(func, context) {
   return Array.from(func.blocks.values()).reduce((changes, block) => {
     for (let i = block.bytecodes.length; i--; ) {
       const cur = block.bytecodes[i];
-      if (cur.op === 0 || context.config.removeArgc && cur.op === 53) {
+      if (cur.op === 0 || cur.op === 1 && cur.arg === 0 || context.config.removeArgc && cur.op === 53) {
         block.bytecodes.splice(i, 1);
         changes = true;
         if (logging3) {
@@ -23770,6 +23864,18 @@ function simpleOpts(func, context) {
             logging3 && (0, import_chunk_PVBIKZYZ.log)(`${func.name}: deleting no-op shift (${shift})`);
             continue;
           }
+          if (shift === 1n && prev.op === 37) {
+            const dup = prev;
+            dup.op = 46;
+            dup.arg = 0;
+            dup.size = 2;
+            const add = cur;
+            add.op = 3;
+            delete add.arg;
+            add.size = 1;
+            logging3 && (0, import_chunk_PVBIKZYZ.log)(`${func.name}: converting "ipush 1; shlv" to "dup 0; addv"`);
+            continue;
+          }
           if (shift < (prev.op === 49 ? 64n : 31n)) {
             const mul = 1n << shift;
             if (prev.op === 37) {
@@ -25368,11 +25474,15 @@ var init_symbols = (0, import_chunk_ABYVSU2C.__esm)({
           const { startPc, name, parent } = functionEntry.attr;
           if (!startPc || !name)
             return;
+          const fullPc = Number(startPc.value.value);
+          if (fullPc >>> 28 !== 1) {
+            return;
+          }
+          const pc = fullPc & 16777215;
           const argc = functionEntry.children?.filter(
             (node) => node.type === "element" && node.name === "param"
           ).length || null;
           const fullName = (parent ? debugXml.processRefs(parent.value.value) + "." : "") + debugXml.processRefs(name.value.value);
-          const pc = Number(startPc.value.value) & 16777215;
           this.methods.set(pc, {
             name: fullName,
             id: null,
@@ -29907,7 +30017,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_PVBIKZYZ.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1690936956222 < opt_time) {
+      if (source_time < opt_time && 1692125151130 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -29945,7 +30055,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.33",
+            optimizerVersion: "1.1.34",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -30386,14 +30496,17 @@ async function optimizeProgram(filepath, devKey, output, config) {
   if (!output) {
     output = removeExt(filepath, ".prg") + ".opt.prg";
   }
-  const xmlBytes = await fs7.readFile(filepath + ".debug.xml").catch(() => "");
-  const debugXml = xml_util_exports.parseXml(xmlBytes.toString());
-  const key = devKey ? await getDevKey(devKey) : void 0;
-  const view = new DataView((await fs7.readFile(filepath)).buffer);
-  const { signature, buffer } = await optimizeProgramBuffer(
+  const [debugXml, apiDebugXml, key, view] = await Promise.all([
+    fs7.readFile(filepath + ".debug.xml").catch(() => "").then((xmlBytes) => xml_util_exports.parseXml(xmlBytes.toString())),
+    getSdkPath().then((sdk) => fs7.readFile(`${sdk}bin/api.debug.xml`)).catch(() => "").then((xmlBytes) => xml_util_exports.parseXml(xmlBytes.toString())),
+    devKey ? getDevKey(devKey) : void 0,
+    fs7.readFile(filepath).then((prgData) => new DataView(prgData.buffer))
+  ]);
+  const { signature, buffer } = optimizeProgramBuffer(
     filepath,
     view,
     debugXml,
+    apiDebugXml,
     key,
     config
   );
@@ -30414,7 +30527,7 @@ async function optimizeProgram(filepath, devKey, output, config) {
   await Promise.all(promises);
   return { signature, output };
 }
-function optimizeProgramBuffer(filepath, view, debugXml, key, config) {
+function optimizeProgramBuffer(filepath, view, debugXml, apiDebugXml, key, config) {
   const { sections } = readPrgWithOffsets(view);
   (0, import_chunk_PVBIKZYZ.logger)("readprg", 5, sections);
   const symbolTable = new SymbolTable();
@@ -30425,6 +30538,9 @@ function optimizeProgramBuffer(filepath, view, debugXml, key, config) {
     ].view);
   }
   symbolTable.parseXml(debugXml);
+  if (apiDebugXml) {
+    symbolTable.parseXml(apiDebugXml);
+  }
   const header = parseHeader(sections[
     -805253120
     /* HEADER */
@@ -30675,6 +30791,7 @@ function optimizePrgAndDebug(prgName, prgBuffer, prgOffset, prgLength, xmlName,
     prgName,
     new DataView(prgBuffer, prgOffset, prgLength),
     debugXml,
+    null,
     key,
     config
   );

package/build/optimizer.cjs

@@ -18,29 +18,29 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_7ANQTFGD.StateNodeAttributes,
-  buildOptimizedProject: () => import_chunk_7ANQTFGD.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_QBCVUVLD.StateNodeAttributes,
+  buildOptimizedProject: () => import_chunk_QBCVUVLD.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_PVBIKZYZ.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_7ANQTFGD.defaultConfig,
-  display: () => import_chunk_7ANQTFGD.display,
-  generateApiMirTests: () => import_chunk_7ANQTFGD.generateApiMirTests,
-  generateOneConfig: () => import_chunk_7ANQTFGD.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_7ANQTFGD.generateOptimizedProject,
-  getConfig: () => import_chunk_7ANQTFGD.getConfig,
-  getProjectAnalysis: () => import_chunk_7ANQTFGD.getProjectAnalysis,
-  get_jungle: () => import_chunk_7ANQTFGD.get_jungle,
-  isErrorWithLocation: () => import_chunk_7ANQTFGD.isErrorWithLocation,
-  launchSimulator: () => import_chunk_7ANQTFGD.launchSimulator,
-  manifestProducts: () => import_chunk_7ANQTFGD.manifestProducts,
-  mctree: () => import_chunk_7ANQTFGD.mctree,
-  simulateProgram: () => import_chunk_7ANQTFGD.simulateProgram
+  defaultConfig: () => import_chunk_QBCVUVLD.defaultConfig,
+  display: () => import_chunk_QBCVUVLD.display,
+  generateApiMirTests: () => import_chunk_QBCVUVLD.generateApiMirTests,
+  generateOneConfig: () => import_chunk_QBCVUVLD.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_QBCVUVLD.generateOptimizedProject,
+  getConfig: () => import_chunk_QBCVUVLD.getConfig,
+  getProjectAnalysis: () => import_chunk_QBCVUVLD.getProjectAnalysis,
+  get_jungle: () => import_chunk_QBCVUVLD.get_jungle,
+  isErrorWithLocation: () => import_chunk_QBCVUVLD.isErrorWithLocation,
+  launchSimulator: () => import_chunk_QBCVUVLD.launchSimulator,
+  manifestProducts: () => import_chunk_QBCVUVLD.manifestProducts,
+  mctree: () => import_chunk_QBCVUVLD.mctree,
+  simulateProgram: () => import_chunk_QBCVUVLD.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_7ANQTFGD = require("./chunk-7ANQTFGD.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7ANQTFGD.init_optimizer)();
+(0, import_chunk_QBCVUVLD.init_optimizer)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StateNodeAttributes,

package/build/sdk-util.cjs

@@ -18,25 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sdk_util_exports = {};
 __export(sdk_util_exports, {
-  SectionKinds: () => import_chunk_7ANQTFGD.SectionKinds,
-  appSupport: () => import_chunk_7ANQTFGD.appSupport,
-  connectiq: () => import_chunk_7ANQTFGD.connectiq,
-  getDeviceInfo: () => import_chunk_7ANQTFGD.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_7ANQTFGD.getFunctionDocumentation,
-  getLanguages: () => import_chunk_7ANQTFGD.getLanguages,
-  getSdkPath: () => import_chunk_7ANQTFGD.getSdkPath,
-  isWin: () => import_chunk_7ANQTFGD.isWin,
-  optimizeProgram: () => import_chunk_7ANQTFGD.optimizeProgram,
-  readPrg: () => import_chunk_7ANQTFGD.readPrg,
-  readPrgWithOffsets: () => import_chunk_7ANQTFGD.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_7ANQTFGD.xml_util_exports
+  SectionKinds: () => import_chunk_QBCVUVLD.SectionKinds,
+  appSupport: () => import_chunk_QBCVUVLD.appSupport,
+  connectiq: () => import_chunk_QBCVUVLD.connectiq,
+  getDeviceInfo: () => import_chunk_QBCVUVLD.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_QBCVUVLD.getFunctionDocumentation,
+  getLanguages: () => import_chunk_QBCVUVLD.getLanguages,
+  getSdkPath: () => import_chunk_QBCVUVLD.getSdkPath,
+  isWin: () => import_chunk_QBCVUVLD.isWin,
+  optimizeProgram: () => import_chunk_QBCVUVLD.optimizeProgram,
+  readPrg: () => import_chunk_QBCVUVLD.readPrg,
+  readPrgWithOffsets: () => import_chunk_QBCVUVLD.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_QBCVUVLD.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_7ANQTFGD = require("./chunk-7ANQTFGD.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7ANQTFGD.init_sdk_util)();
+(0, import_chunk_QBCVUVLD.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -26,7 +26,7 @@ export declare function findNamesInScope(declStack: StateNode[][], pattern: stri
     readonly parent: StateNode;
     readonly depth: number;
 }])[];
-export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ModuleStateNode | ClassStateNode | TypedefStateNode | ProgramStateNode | EnumStateNode | import("./optimizer-types").BlockStateNode | VariableStateNode)[];
 export declare function formatAstLongLines(node: mctree.Node): string;
 export declare function createDocumentationMap(functionDocumentation: {
     name: string;

package/build/src/readprg.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import * as crypto from "node:crypto";
 import { BuildConfig } from "./optimizer-types";
 import { SectionInfo } from "./readprg/bytecode";
-import { xmlUtil } from "./sdk-util";
 export declare function readPrg(path: string): Promise<{
     [k: string]: number;
 }>;
@@ -16,10 +14,6 @@ export declare function readPrgWithOffsets(view: DataView): {
     sections: Record<number, SectionInfo>;
 };
 export declare function optimizeProgram(filepath: string, devKey?: string | undefined, output?: string, config?: BuildConfig): Promise<unknown>;
-export declare function optimizeProgramBuffer(filepath: string, view: DataView, debugXml: xmlUtil.Document, key: crypto.KeyObject | undefined, config: BuildConfig | undefined): {
-    signature: Buffer | undefined;
-    buffer: Buffer;
-};
 export declare function optimizePrgAndDebug(prgName: string, prgBuffer: ArrayBuffer, prgOffset: number, prgLength: number, xmlName: string, xmlBuffer: ArrayBuffer, xmlOffset: number, xmlLength: number, key: crypto.KeyObject, config: BuildConfig | undefined): Promise<{
     sigBuffer: ArrayBufferLike | undefined;
     sigOffset: number | undefined;

package/build/src/src/api.d.ts

@@ -0,0 +1,51 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { hasProperty, traverseAst } from "./ast";
+import { JungleResourceMap } from "./jungles";
+import { ClassStateNode, Diagnostic, DiagnosticType, EnumStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, LookupResult, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode, VariableStateNode } from "./optimizer-types";
+import { visit_resources } from "./resources";
+import { xmlUtil } from "./sdk-util";
+import { TypeMap } from "./type-flow/interp";
+export { visitorNode, visitReferences } from "./visitor";
+export { traverseAst, hasProperty, visit_resources };
+export declare function parseSdkVersion(version: string | undefined): number;
+export declare function checkCompilerVersion(version: string, sdkVer: number): boolean | undefined;
+export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): Promise<ProgramStateNode>;
+export declare function isStateNode(node: {
+    type: string;
+}): node is StateNode;
+export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
+type DeclKind = "decls" | "type_decls";
+export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function lookupResultContains(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
+export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;
+export declare function lookupWithType(state: ProgramStateAnalysis, node: mctree.Node, typeMap: TypeMap | undefined | null, nonLocal?: boolean, stack?: ProgramStateStack | null): LookupResult;
+export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
+export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null, options?: Record<string, unknown> | null): string;
+export declare function findNamesInScope(declStack: StateNode[][], pattern: string | RegExp): (readonly [StateNodeDecl, {
+    readonly parent: StateNode;
+    readonly depth: number;
+}])[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
+export declare function formatAstLongLines(node: mctree.Node): string;
+export declare function createDocumentationMap(functionDocumentation: {
+    name: string;
+    parent: string;
+    doc: string;
+}[]): Promise<Map<string, string>>;
+export declare function makeToyboxLink(result: StateNodeDecl): string | null;
+export declare function lookupByFullName(state: ProgramStateAnalysis, fullName: string): StateNodeDecl[];
+export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier): ModuleStateNode | {
+    name: string;
+    decls: {
+        parent: StateNode;
+        results: StateNodeDecl[];
+    };
+}[] | null;
+export declare function getApiFunctionInfo(state: ProgramState, func: FunctionStateNode): FunctionInfo | false;
+export declare function markInvokeClassMethod(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function isLocal(v: VariableStateNode): boolean;
+export declare function isClassVariable(v: VariableStateNode): boolean;
+export declare function diagnostic(state: ProgramState, node: mctree.Node, message: string | null, type?: DiagnosticType, extra?: Diagnostic["extra"]): void;
+export declare function diagnosticHelper(diagnostics: Record<string, Diagnostic[]>, node: mctree.Node, message: string | null, type: DiagnosticType | undefined, extra: Diagnostic["extra"] | undefined, uniqueLocs: boolean): void;
+export declare function getSuperClasses(klass: ClassStateNode): Set<StateNode> | null;

package/build/src/src/ast.d.ts

@@ -0,0 +1,59 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import type { xmlUtil } from "./sdk-util";
+export declare function traverseAst(node: mctree.Node, pre?: null | ((node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[]), post?: (node: mctree.Node, parent: mctree.Node | undefined) => void | null | false | mctree.Node | mctree.Node[], parent?: mctree.Node | undefined): false | void | null | mctree.Node | mctree.Node[];
+export declare function isStatement(node: mctree.Node): node is mctree.Statement;
+export declare function isExpression(node: mctree.Node): node is mctree.Expression;
+export declare function mayThrow(node: mctree.Node): boolean;
+export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
+export declare function hasProperty<T>(obj: T, prop: string): boolean;
+export declare function withLoc<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined | false): T;
+export declare function withLocDeep<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined | false, inplace?: boolean): T;
+export declare function cloneDeep<T extends mctree.Node>(node: T): T;
+interface NumberLiteral extends mctree.Literal {
+    value: number;
+}
+interface LongLiteral extends mctree.Literal {
+    value: number | bigint;
+}
+interface StringLiteral extends mctree.Literal {
+    value: string;
+}
+interface CharLiteral extends mctree.Literal {
+    value: string;
+}
+interface BooleanLiteral extends mctree.Literal {
+    value: boolean;
+}
+interface NullLiteral extends mctree.Literal {
+    value: null;
+}
+type LiteralValues = [NumberLiteral, "Number" | "Float" | "Double"] | [LongLiteral, "Long"] | [StringLiteral, "String"] | [CharLiteral, "Char"] | [BooleanLiteral, "Boolean"] | [NullLiteral, "Null"];
+export declare function getNodeValue(node: mctree.Literal): LiteralValues;
+export declare function getNodeValue(node: mctree.Node): LiteralValues | [null, null];
+export declare function wrap<T extends mctree.Node>(node: T, loc?: mctree.SourceLocation | null): T;
+export declare function locRange(start: mctree.SourceLocation, end: mctree.SourceLocation): {
+    source: string | null | undefined;
+    start: mctree.Position;
+    end: mctree.Position;
+};
+export declare function adjustLoc(loc: xmlUtil.SourceLocation, start?: number, end?: number): {
+    readonly source: string | null | undefined;
+    readonly start: {
+        readonly offset: number;
+        readonly line: number;
+        readonly column: number;
+    };
+    readonly end: {
+        readonly offset: number;
+        readonly line: number;
+        readonly column: number;
+    };
+};
+export declare function makeIdentifier(name: string, loc?: mctree.SourceLocation | null | undefined): {
+    type: "Identifier";
+    name: string;
+};
+export declare function makeMemberExpression(object: mctree.ScopedName, property: mctree.Identifier): mctree.DottedName;
+export declare function makeScopedName(dotted: string, l?: mctree.SourceLocation): mctree.ScopedName;
+export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
+export {};