@markw65/monkeyc-optimizer 1.1.82 → 1.1.84

package/build/{chunk-TLXMWGYI.cjs → chunk-ZWQB5L34.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_TLXMWGYI_exports = {};
-__export(chunk_TLXMWGYI_exports, {
+var chunk_ZWQB5L34_exports = {};
+__export(chunk_ZWQB5L34_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -40,6 +40,7 @@ __export(chunk_TLXMWGYI_exports, {
   buildConfigDescription: () => buildConfigDescription,
   buildOptimizedProject: () => buildOptimizedProject,
   checkCompilerVersion: () => checkCompilerVersion,
+  clearDiagnostics: () => clearDiagnostics,
   collectNamespaces: () => collectNamespaces,
   connectiq: () => connectiq,
   couldBe: () => couldBe,
@@ -139,7 +140,7 @@ __export(chunk_TLXMWGYI_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_TLXMWGYI_exports);
+module.exports = __toCommonJS(chunk_ZWQB5L34_exports);
 var import_chunk_X7QCZR3F = require("./chunk-X7QCZR3F.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -5728,7 +5729,7 @@ var init_build_config = (0, import_chunk_ABYVSU2C.__esm)({
           },
           extraReferenceTypeChecks: {
             type: "boolean",
-            description: "Whether to warn about [unsafe operations on Arrays and Dictionaries](https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)) that Garmin's compiler allows",
+            markdownDescription: "Whether to warn about [unsafe operations on Arrays and Dictionaries](https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)) that Garmin's compiler allows",
             default: true,
             scope: "resource"
           },
@@ -6923,8 +6924,8 @@ function pragmaChecker(state, ast, diagnostics) {
     }
     if (node.start && node.start >= (comment.end || Infinity)) {
       const { kind, quote, needle } = matchers.shift();
+      const thisComment = comment;
       if (kind === "match") {
-        const thisComment = comment;
         promise = promise.then(
           () => formatAstLongLines(node).then((haystack) => {
             haystack = haystack.replace(/([\r\n]|\s)+/g, " ").replace(/\b\w+\s\/\*>([\w.]+)<\*\//g, "$1");
@@ -6979,7 +6980,7 @@ function pragmaChecker(state, ast, diagnostics) {
         if (!found) {
           diagnostic(
             state,
-            comment,
+            thisComment,
             `Missing error message '${needle}`,
             "ERROR"
           );
@@ -7618,745 +7619,312 @@ var init_control_flow = (0, import_chunk_ABYVSU2C.__esm)({
     };
   }
 });
-function unionInto(to, from) {
-  return unionHelper(to, from, -Infinity);
+function expandTypedef(t) {
+  const decls = getUnionComponent(
+    t,
+    262144
+    /* Typedef */
+  );
+  const tExpanded = cloneType(t);
+  clearValuesUnder(tExpanded, 262144, true);
+  (0, import_chunk_X7QCZR3F.forEach)(decls, (decl) => unionInto(tExpanded, decl.resolvedType));
+  return tExpanded;
 }
-function unionHelper(to, from, widenDepth) {
-  if (to == null || from == null) {
-    throw new Error("Null");
+function intersectEnum(t, e) {
+  const enumData = getUnionComponent(
+    e,
+    65536
+    /* Enum */
+  );
+  const e2 = cloneType(e);
+  const i = intersection(t, typeFromEnumValue(enumData));
+  if (e2.value != null) {
+    clearValuesUnder(e2, 65536, true);
+  } else {
+    e2.type &= ~65536;
   }
-  if (from.type === 0 || to === from)
-    return false;
-  if (to.type === 0) {
-    to.type = from.type;
-    to.value = from.value;
-    return true;
+  const rest = intersection(t, e2);
+  if (i.type === 0) {
+    return rest;
   }
-  const newTags = to.type | from.type;
-  if (!(from.type & ~SingletonTypeTagsConst)) {
-    if (newTags === to.type)
-      return false;
-    to.type = newTags;
-    return true;
+  const result = enumData ? { type: 65536, value: { ...enumData, value: i } } : cloneType(i);
+  unionInto(result, rest);
+  return result;
+}
+function intersection(a, b) {
+  if (a.type & 262144 && a.value != null) {
+    return intersection(expandTypedef(a), b);
   }
-  if (newTags === to.type) {
-    if (to.value === from.value || to.value == null) {
-      return false;
-    }
-    if (from.value == null) {
-      clearValuesUnder(to, from.type);
-      return true;
-    }
-    return mergeMultiple(to, from, widenDepth);
+  if (b.type & 262144 && b.value != null) {
+    return intersection(a, expandTypedef(b));
   }
-  if (to.value != null) {
-    if (from.value == null) {
-      clearValuesUnder(to, from.type);
-      return true;
+  let common = a.type & b.type & ~262144;
+  if (a.type & 32768 && b.type & ObjectLikeTagsConst && getObjectValue(a) == null) {
+    common |= b.type & ObjectLikeTagsConst;
+  }
+  if (b.type & 32768 && a.type & ObjectLikeTagsConst && getObjectValue(b) == null) {
+    common |= a.type & ObjectLikeTagsConst;
+  }
+  if (a.type & 65536 && b.type & EnumTagsConst && !(b.type & 65536)) {
+    return intersectEnum(b, a);
+  }
+  if (b.type & 65536 && a.type & EnumTagsConst && !(a.type & 65536)) {
+    return intersectEnum(a, b);
+  }
+  if (!common) {
+    return {
+      type: 0
+      /* Never */
+    };
+  }
+  if (a.value == null) {
+    if (b.value == null) {
+      return { type: common };
     }
-    mergeMultiple(to, from, widenDepth);
-    return true;
+    const result2 = cloneType(b);
+    clearValuesUnder(result2, b.type & ~common, true);
+    return result2;
   }
-  if (from.value == null) {
-    to.type = newTags;
-    return true;
+  if (b.value == null) {
+    const result2 = cloneType(a);
+    clearValuesUnder(result2, a.type & ~common, true);
+    return result2;
   }
-  const tmp = cloneType(from);
-  clearValuesUnder(tmp, to.type);
-  to.type = tmp.type;
-  to.value = tmp.value;
-  return true;
-}
-function mergeMultiple(to, from, widenDepth) {
-  const newTags = to.type | from.type;
-  let anyChanged = newTags !== to.type;
   let mask = 0;
   const result = {};
-  forEachUnionComponent(to, newTags, (ac) => {
-    const fromv = getUnionComponent(from, ac.type);
-    if (ac.value != null) {
-      if (fromv != null) {
-        const [value2, changed] = ac.value === fromv ? [fromv, false] : mergeSingle(
-          {
-            type: ac.type,
-            avalue: ac.value,
-            bvalue: fromv
-          },
-          widenDepth
-        );
-        if (changed)
-          anyChanged = true;
-        if (value2) {
-          mask |= ac.type;
-          result[ac.type] = value2;
-        }
-      } else if (!(from.type & ac.type)) {
-        mask |= ac.type;
-        result[ac.type] = ac.value;
-      } else {
-        anyChanged = true;
-      }
-    } else if (fromv && !(to.type & ac.type)) {
-      anyChanged = true;
+  forEachUnionComponent(a, common, (ac) => {
+    const bvalue = getUnionComponent(b, ac.type);
+    if (ac.value == null) {
+      if (!bvalue)
+        return;
+      result[ac.type] = bvalue;
       mask |= ac.type;
-      result[ac.type] = fromv;
+      return;
+    }
+    if (bvalue === null || ac.value === bvalue) {
+      result[ac.type] = ac.value;
+      mask |= ac.type;
+      return;
+    }
+    const ivalue = intersectionValue({
+      type: ac.type,
+      avalue: ac.value,
+      bvalue
+    });
+    if (ivalue != null) {
+      result[ac.type] = ivalue;
+      mask |= ac.type;
+      return;
+    } else {
+      common -= ac.type;
     }
   });
-  if (!anyChanged)
-    return false;
-  to.type = newTags;
-  if (!mask) {
-    delete to.value;
-    return true;
-  }
-  if (hasUnionData(newTags)) {
-    to.value = result;
-    to.value.mask = mask;
-    return true;
+  if (!mask)
+    return { type: common };
+  if (hasUnionData(common)) {
+    return { type: common, value: { ...result, mask } };
   }
   if (mask & mask - 1) {
-    throw new Error("Union incorrectly produced a UnionData");
+    throw new Error(
+      `Mask with non-union data had more than one bit set: ${mask}`
+    );
   }
-  to.value = result[mask];
-  return true;
+  return { type: common, value: result[mask] };
 }
-function mergeSingle(pair, widenDepth) {
-  function tryUnion(to, from) {
-    to = cloneType(to);
-    if (unionHelper(to, from, widenDepth + 1))
-      return to;
-    return null;
-  }
+function intersectionValue(pair) {
   switch (pair.type) {
     case 1:
     case 2:
     case 4:
-      throw new Error("Unexpected TypeTag in mergeSingle");
+    case 262144:
+      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
     case 8:
     case 16:
     case 32:
     case 64:
-    case 128:
     case 256:
+    case 128:
     case 131072:
-      return [null, true];
-    case 512: {
-      if (widenDepth > MaxWidenDepth) {
-        return [null, true];
-      }
-      const tupleTypes = /* @__PURE__ */ new Map();
-      const arrayTypes = [];
-      tupleForEach(
+      return pair.avalue === pair.bvalue ? pair.avalue : null;
+    case 512:
+      return tupleMap(
         pair.avalue,
-        (v) => {
-          const t = tupleTypes.get(v.length);
-          if (t) {
-            t.push(v);
-          } else {
-            tupleTypes.set(v.length, [v]);
-          }
-        },
-        (v) => arrayTypes.push(v)
+        (av) => tupleMap(
+          pair.bvalue,
+          (bv) => {
+            if (av.length !== bv.length)
+              return null;
+            const isect = av.map((t, i) => intersection(t, bv[i]));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => {
+            const isect = av.map((t) => intersection(bv, t));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => bv.length === 0 ? null : bv
+        ),
+        (av) => tupleMap(
+          pair.bvalue,
+          (bv) => {
+            const isect = bv.map((t) => intersection(av, t));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => {
+            const atype = intersection(av, bv);
+            return atype.type === 0 ? null : atype;
+          },
+          (bv) => bv.length === 0 ? null : bv
+        ),
+        (av) => {
+          const result = av.flat(1);
+          return result.length === 0 ? null : tupleReduce(result);
+        }
       );
-      const extraTypes = [];
-      tupleForEach(
-        pair.bvalue,
-        (v) => {
-          const tuples = tupleTypes.get(v.length);
-          if (!tuples?.some(
-            (t) => t.every((at, i) => {
-              const bt = v[i];
-              return subtypeOf(at, bt) && subtypeOf(bt, at);
-            })
-          )) {
-            extraTypes.push(v);
-          }
-        },
-        (v) => {
-          if (!arrayTypes.some((at) => subtypeOf(at, v) && subtypeOf(v, at))) {
-            extraTypes.push(v);
-          }
-        }
-      );
-      if (extraTypes.length) {
-        if (widenDepth >= 0) {
-          return [null, true];
-        }
-        const allTypes = (pair.avalue instanceof Set ? Array.from(pair.avalue) : [pair.avalue]).concat(extraTypes);
-        return [tupleReduce(allTypes), true];
-      }
-      return [pair.avalue, false];
-    }
     case 1024: {
-      if (widenDepth > MaxWidenDepth) {
-        return [null, true];
-      }
-      const avalue = pair.avalue;
-      const bvalue = pair.bvalue;
-      if (!avalue.value) {
-        if (!bvalue.value) {
-          const result = new Map(avalue);
-          let merged = false;
-          result.forEach((av, key2) => {
-            const bv = bvalue.get(key2);
-            if (!bv) {
-              result.delete(key2);
-              merged = true;
-              return;
+      if (!pair.avalue.value) {
+        if (!pair.bvalue.value) {
+          const result = new Map(pair.avalue);
+          pair.bvalue.forEach((bv, key) => {
+            const av = result.get(key);
+            if (av) {
+              bv = intersection(bv, av);
             }
-            av = cloneType(av);
-            if (unionHelper(av, bv, widenDepth + 1))
-              merged = true;
-            result.set(key2, av);
+            result.set(key, bv);
           });
-          return [result, merged];
+          return result;
         } else {
-          const result = new Map(avalue);
-          let merged = false;
-          result.forEach((av, key2) => {
-            const keyType = typeFromObjectLiteralKey(key2);
-            if (couldBe(keyType, bvalue.key)) {
-              const bv = tryUnion(av, bvalue.value);
-              if (bv) {
-                result.set(key2, bv);
-                merged = true;
-              }
-            }
-          });
-          return [result, merged];
+          return pair.bvalue;
         }
-      } else if (!bvalue.value) {
-        const result = new Map(bvalue);
-        let merged = false;
-        result.forEach((bv, key2) => {
-          const keyType = typeFromObjectLiteralKey(key2);
-          if (couldBe(keyType, avalue.key)) {
-            const av = tryUnion(bv, avalue.value);
-            if (av) {
-              result.set(key2, av);
-              merged = true;
-            }
-          }
-        });
-        return [result, merged];
-      }
-      const { key, value: value2 } = avalue;
-      const keyChange = tryUnion(key, bvalue.key);
-      const valueChange = tryUnion(value2, bvalue.value);
-      if (keyChange || valueChange) {
-        return [{ key: keyChange || key, value: valueChange || value2 }, true];
+      } else if (!pair.bvalue.value) {
+        return pair.avalue;
       }
-      return [pair.avalue, false];
+      const dkey = intersection(pair.avalue.key, pair.bvalue.key);
+      const dvalue = intersection(pair.avalue.value, pair.bvalue.value);
+      return dkey.type !== 0 && dvalue.type !== 0 ? { key: dkey, value: dvalue } : null;
     }
     case 2048: {
       if (pair.avalue.args.length !== pair.bvalue.args.length)
-        return [null, true];
-      const resultChange = tryUnion(pair.avalue.result, pair.bvalue.result);
-      const args = pair.avalue.args.map(
-        (arg, i) => intersection(arg, pair.bvalue.args[i])
-      );
-      if (args.some(
+        return null;
+      const mresult = intersection(pair.avalue.result, pair.bvalue.result);
+      if (mresult.type === 0)
+        return null;
+      const margs = pair.avalue.args.map((aarg, i) => {
+        aarg = cloneType(aarg);
+        unionInto(aarg, pair.bvalue.args[i]);
+        return aarg;
+      });
+      if (margs.some(
         (arg) => arg.type === 0
         /* Never */
-      )) {
-        return [null, true];
-      }
-      const argsChanged = args.some(
-        (arg, i) => !subtypeOf(pair.avalue.args[i], arg)
-      );
-      if (resultChange || argsChanged) {
-        return [{ result: resultChange || pair.avalue.result, args }, true];
-      }
-      return [pair.avalue, false];
+      ))
+        return null;
+      return { result: mresult, args: margs };
     }
     case 4096:
-      return mergeStateDecls(pair.avalue, pair.bvalue);
-    case 8192:
-      return mergeStateDecls(pair.avalue, pair.bvalue);
-    case 16384:
-      return mergeStateDecls(pair.avalue, pair.bvalue);
-    case 262144:
-      return mergeStateDecls(pair.avalue, pair.bvalue);
-    case 32768: {
-      let klass = pair.avalue.klass;
-      const [obj, objChanged] = mergeObjectValues(
-        pair.avalue.obj,
-        pair.bvalue.obj,
-        widenDepth
+    case 8192: {
+      const common = /* @__PURE__ */ new Set();
+      (0, import_chunk_X7QCZR3F.forEach)(
+        pair.avalue,
+        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => sna === snb) && common.add(sna)
       );
-      const klassChanged = tryUnion(klass, pair.bvalue.klass);
-      if (klassChanged || objChanged) {
-        klass = klassChanged || klass;
-        if (obj) {
-          return [{ klass, obj }, true];
-        }
-        return [{ klass }, true];
-      }
-      return [pair.avalue, false];
+      if (!common.size)
+        return null;
+      const arr = Array.from(common);
+      return arr.length === 1 ? arr[0] : arr;
+    }
+    case 16384: {
+      const common = /* @__PURE__ */ new Set();
+      (0, import_chunk_X7QCZR3F.forEach)(pair.avalue, (sna) => {
+        const superA = getSuperClasses(sna);
+        (0, import_chunk_X7QCZR3F.forEach)(pair.bvalue, (snb) => {
+          if (sna === snb || superA && superA.has(snb)) {
+            common.add(sna);
+          }
+          const superB = getSuperClasses(snb);
+          if (superB && superB.has(sna)) {
+            common.add(snb);
+          }
+        });
+      });
+      if (!common.size)
+        return null;
+      const arr = Array.from(common);
+      return arr.length === 1 ? arr[0] : arr;
+    }
+    case 32768: {
+      const klass = intersection(pair.avalue.klass, pair.bvalue.klass);
+      const obj = intersectObj(pair.avalue.obj, pair.bvalue.obj);
+      return klass.type !== 16384 || klass.value == null ? null : obj ? { klass, obj } : { klass };
     }
     case 65536: {
-      const toE = pair.avalue;
-      const fromE = pair.bvalue;
-      if (toE.enum !== fromE.enum) {
-        if (toE.value && fromE.value) {
-          const result = cloneType(toE.value);
-          unionHelper(result, fromE.value, widenDepth + 1);
-          const e = { value: result };
-          return [e, true];
+      let enumDecl;
+      if (Array.isArray(pair.avalue.enum)) {
+        const s = new Set(pair.avalue.enum);
+        const enums = [];
+        (0, import_chunk_X7QCZR3F.forEach)(pair.bvalue.enum, (b) => s.has(b) && enums.push(b));
+        if (enums.length) {
+          enumDecl = enums.length === 1 ? enums[0] : enums;
         }
-        return [null, true];
-      }
-      if (!toE.value) {
-        return [toE, false];
-      }
-      if (!fromE.value) {
-        delete toE.value;
-        return [toE, true];
-      }
-      const toValue = tryUnion(toE.value, fromE.value);
-      if (toValue) {
-        const e = { enum: toE.enum, value: toValue };
-        return [e, true];
+      } else {
+        (0, import_chunk_X7QCZR3F.some)(pair.bvalue.enum, (b) => b === pair.avalue.enum) && (enumDecl = pair.bvalue.enum);
       }
-      return [toE, false];
+      if (!enumDecl)
+        return null;
+      const enumValue = pair.avalue.value != null ? pair.bvalue.value != null ? intersection(pair.avalue.value, pair.bvalue.value) : pair.avalue.value : pair.bvalue.value;
+      return { enum: enumDecl, value: enumValue };
     }
     default:
       unhandledType(pair);
   }
 }
-function mergeObjectValues(to, from, widenDepth) {
-  if (!to) {
-    return [to, false];
-  }
-  if (!from) {
-    return [from, true];
-  }
-  let empty = true;
+function intersectObj(to, from) {
+  if (!to)
+    return from;
+  if (!from)
+    return to;
   let result = to;
-  Object.entries(to).forEach(([key, value2]) => {
-    if (!(0, import_chunk_JDC43A3I.hasProperty)(from, key)) {
+  Object.entries(from).forEach(([key, value2]) => {
+    if (!(0, import_chunk_JDC43A3I.hasProperty)(to, key)) {
       if (result === to)
         result = { ...result };
-      delete result[key];
+      result[key] = value2;
       return;
     }
-    const rep = cloneType(value2);
-    if (unionHelper(rep, from[key], widenDepth + 1)) {
-      if (result === to)
-        result = { ...result };
-      result[key] = rep;
-    }
-    empty = false;
+    if (result === to)
+      result = { ...result };
+    result[key] = intersection(to[key], value2);
   });
-  if (empty) {
-    return [void 0, true];
-  }
-  return [result, result !== to];
+  return result;
 }
-function mergeStateDecls(to, from) {
-  let changed = false;
-  let result = to;
-  (0, import_chunk_X7QCZR3F.forEach)(from, (v) => {
-    if ((0, import_chunk_X7QCZR3F.some)(to, (t) => t === v)) {
-      return;
-    }
-    if (Array.isArray(result)) {
-      if (result === to) {
-        result = [...result, v];
-      } else {
-        result.push(v);
-      }
-    } else {
-      result = [to, v];
+function fixupEnum(a, b_restricted, b) {
+  if (b.type & 65536) {
+    const bvalue = getUnionComponent(
+      b,
+      65536
+      /* Enum */
+    );
+    const br = restrictByEquality(a, typeFromEnumValue(bvalue));
+    if (br.type) {
+      b_restricted = cloneType(b_restricted);
+      unionInto(
+        b_restricted,
+        bvalue ? {
+          type: 65536,
+          value: { ...bvalue, value: br }
+        } : br
+      );
     }
-    changed = true;
-  });
-  return [result, changed];
-}
-function nonUnionDataMask(tag) {
-  if (tag & tag - 1) {
-    return tag & UnionDataTypeTagsConst || tag & ValueTypeTagsConst;
-  }
-  return tag;
-}
-function clearValuesUnder(v, tag, clearTag = false) {
-  const newTag = clearTag ? v.type & ~tag : v.type | tag;
-  tag &= ~SingletonTypeTagsConst;
-  if (!tag || v.value == null) {
-    v.type = newTag;
-    return;
-  }
-  if (tag & ValueTypeTagsConst) {
-    tag |= ValueTypeTagsConst;
-  }
-  if (!hasUnionData(v.type)) {
-    const dataMask = nonUnionDataMask(v.type);
-    if (dataMask & tag) {
-      v.type = newTag;
-      delete v.value;
-      return;
-    }
-    if (dataMask & ValueTypeTagsConst) {
-      delete v.value;
-      v.type = newTag;
-      return;
-    }
-    if (hasUnionData(newTag)) {
-      const mask = v.type & UnionDataTypeTagsConst;
-      v.value = {
-        [mask]: v.value,
-        mask
-      };
-    }
-    v.type = newTag;
-    return;
-  }
-  v.type = newTag;
-  const unionData = v.value;
-  let remain = unionData.mask & ~tag;
-  if (!remain) {
-    delete v.value;
-    return;
-  }
-  const newData = { mask: remain };
-  while (remain) {
-    const next = remain & remain - 1;
-    const bit = remain - next;
-    newData[bit] = unionData[bit];
-    remain = next;
-  }
-  if (!hasUnionData(newTag)) {
-    v.value = newData[newTag & UnionDataTypeTagsConst];
-  } else {
-    v.value = newData;
-  }
-}
-var MaxWidenDepth;
-var init_union_type = (0, import_chunk_ABYVSU2C.__esm)({
-  "src/type-flow/union-type.ts"() {
-    "use strict";
-    (0, import_chunk_JDC43A3I.init_ast)();
-    init_data_flow();
-    (0, import_chunk_X7QCZR3F.init_util)();
-    init_could_be();
-    init_intersection_type();
-    init_sub_type();
-    init_types();
-    MaxWidenDepth = 4;
-  }
-});
-function expandTypedef(t) {
-  const decls = getUnionComponent(
-    t,
-    262144
-    /* Typedef */
-  );
-  const tExpanded = cloneType(t);
-  clearValuesUnder(tExpanded, 262144, true);
-  (0, import_chunk_X7QCZR3F.forEach)(decls, (decl) => unionInto(tExpanded, decl.resolvedType));
-  return tExpanded;
-}
-function intersectEnum(t, e) {
-  const enumData = getUnionComponent(
-    e,
-    65536
-    /* Enum */
-  );
-  const e2 = cloneType(e);
-  const i = intersection(
-    t,
-    !enumData ? { type: EnumTagsConst } : enumData.value ? enumData.value : enumData.enum?.resolvedType || { type: EnumTagsConst }
-  );
-  if (e2.value != null) {
-    clearValuesUnder(e2, 65536, true);
-  } else {
-    e2.type &= ~65536;
-  }
-  const rest = intersection(t, e2);
-  if (i.type === 0) {
-    return rest;
-  }
-  const result = enumData ? { type: 65536, value: { ...enumData, value: i } } : cloneType(i);
-  unionInto(result, rest);
-  return result;
-}
-function intersection(a, b) {
-  if (a.type & 262144 && a.value != null) {
-    return intersection(expandTypedef(a), b);
-  }
-  if (b.type & 262144 && b.value != null) {
-    return intersection(a, expandTypedef(b));
-  }
-  let common = a.type & b.type & ~262144;
-  if (a.type & 32768 && b.type & ObjectLikeTagsConst && getObjectValue(a) == null) {
-    common |= b.type & ObjectLikeTagsConst;
-  }
-  if (b.type & 32768 && a.type & ObjectLikeTagsConst && getObjectValue(b) == null) {
-    common |= a.type & ObjectLikeTagsConst;
-  }
-  if (a.type & 65536 && b.type & EnumTagsConst && !(b.type & 65536)) {
-    return intersectEnum(b, a);
-  }
-  if (b.type & 65536 && a.type & EnumTagsConst && !(a.type & 65536)) {
-    return intersectEnum(a, b);
-  }
-  if (!common) {
-    return {
-      type: 0
-      /* Never */
-    };
-  }
-  if (a.value == null) {
-    if (b.value == null) {
-      return { type: common };
-    }
-    const result2 = cloneType(b);
-    clearValuesUnder(result2, b.type & ~common, true);
-    return result2;
-  }
-  if (b.value == null) {
-    const result2 = cloneType(a);
-    clearValuesUnder(result2, a.type & ~common, true);
-    return result2;
-  }
-  let mask = 0;
-  const result = {};
-  forEachUnionComponent(a, common, (ac) => {
-    const bvalue = getUnionComponent(b, ac.type);
-    if (ac.value == null) {
-      if (!bvalue)
-        return;
-      result[ac.type] = bvalue;
-      mask |= ac.type;
-      return;
-    }
-    if (bvalue === null || ac.value === bvalue) {
-      result[ac.type] = ac.value;
-      mask |= ac.type;
-      return;
-    }
-    const ivalue = intersectionValue({
-      type: ac.type,
-      avalue: ac.value,
-      bvalue
-    });
-    if (ivalue != null) {
-      result[ac.type] = ivalue;
-      mask |= ac.type;
-      return;
-    } else {
-      common -= ac.type;
-    }
-  });
-  if (!mask)
-    return { type: common };
-  if (hasUnionData(common)) {
-    return { type: common, value: { ...result, mask } };
-  }
-  if (mask & mask - 1) {
-    throw new Error(
-      `Mask with non-union data had more than one bit set: ${mask}`
-    );
-  }
-  return { type: common, value: result[mask] };
-}
-function intersectionValue(pair) {
-  switch (pair.type) {
-    case 1:
-    case 2:
-    case 4:
-    case 262144:
-      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
-    case 8:
-    case 16:
-    case 32:
-    case 64:
-    case 256:
-    case 128:
-    case 131072:
-      return pair.avalue === pair.bvalue ? pair.avalue : null;
-    case 512:
-      return tupleMap(
-        pair.avalue,
-        (av) => tupleMap(
-          pair.bvalue,
-          (bv) => {
-            if (av.length !== bv.length)
-              return null;
-            const isect = av.map((t, i) => intersection(t, bv[i]));
-            return isect.some(
-              (t) => t.type === 0
-              /* Never */
-            ) ? null : isect;
-          },
-          (bv) => {
-            const isect = av.map((t) => intersection(bv, t));
-            return isect.some(
-              (t) => t.type === 0
-              /* Never */
-            ) ? null : isect;
-          },
-          (bv) => bv.length === 0 ? null : bv
-        ),
-        (av) => tupleMap(
-          pair.bvalue,
-          (bv) => {
-            const isect = bv.map((t) => intersection(av, t));
-            return isect.some(
-              (t) => t.type === 0
-              /* Never */
-            ) ? null : isect;
-          },
-          (bv) => {
-            const atype = intersection(av, bv);
-            return atype.type === 0 ? null : atype;
-          },
-          (bv) => bv.length === 0 ? null : bv
-        ),
-        (av) => {
-          const result = av.flat(1);
-          return result.length === 0 ? null : tupleReduce(result);
-        }
-      );
-    case 1024: {
-      if (!pair.avalue.value) {
-        if (!pair.bvalue.value) {
-          const result = new Map(pair.avalue);
-          pair.bvalue.forEach((bv, key) => {
-            const av = result.get(key);
-            if (av) {
-              bv = intersection(bv, av);
-            }
-            result.set(key, bv);
-          });
-          return result;
-        } else {
-          return pair.bvalue;
-        }
-      } else if (!pair.bvalue.value) {
-        return pair.avalue;
-      }
-      const dkey = intersection(pair.avalue.key, pair.bvalue.key);
-      const dvalue = intersection(pair.avalue.value, pair.bvalue.value);
-      return dkey.type !== 0 && dvalue.type !== 0 ? { key: dkey, value: dvalue } : null;
-    }
-    case 2048: {
-      if (pair.avalue.args.length !== pair.bvalue.args.length)
-        return null;
-      const mresult = intersection(pair.avalue.result, pair.bvalue.result);
-      if (mresult.type === 0)
-        return null;
-      const margs = pair.avalue.args.map((aarg, i) => {
-        aarg = cloneType(aarg);
-        unionInto(aarg, pair.bvalue.args[i]);
-        return aarg;
-      });
-      if (margs.some(
-        (arg) => arg.type === 0
-        /* Never */
-      ))
-        return null;
-      return { result: mresult, args: margs };
-    }
-    case 4096:
-    case 8192: {
-      const common = /* @__PURE__ */ new Set();
-      (0, import_chunk_X7QCZR3F.forEach)(
-        pair.avalue,
-        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => sna === snb) && common.add(sna)
-      );
-      if (!common.size)
-        return null;
-      const arr = Array.from(common);
-      return arr.length === 1 ? arr[0] : arr;
-    }
-    case 16384: {
-      const common = /* @__PURE__ */ new Set();
-      (0, import_chunk_X7QCZR3F.forEach)(pair.avalue, (sna) => {
-        const superA = getSuperClasses(sna);
-        (0, import_chunk_X7QCZR3F.forEach)(pair.bvalue, (snb) => {
-          if (sna === snb || superA && superA.has(snb)) {
-            common.add(sna);
-          }
-          const superB = getSuperClasses(snb);
-          if (superB && superB.has(sna)) {
-            common.add(snb);
-          }
-        });
-      });
-      if (!common.size)
-        return null;
-      const arr = Array.from(common);
-      return arr.length === 1 ? arr[0] : arr;
-    }
-    case 32768: {
-      const klass = intersection(pair.avalue.klass, pair.bvalue.klass);
-      const obj = intersectObj(pair.avalue.obj, pair.bvalue.obj);
-      return klass.type !== 16384 || klass.value == null ? null : obj ? { klass, obj } : { klass };
-    }
-    case 65536: {
-      if (pair.avalue.enum !== pair.bvalue.enum && pair.avalue.enum && pair.bvalue.enum) {
-        return null;
-      }
-      const enumDecl = pair.avalue.enum || pair.bvalue.enum;
-      if (pair.avalue.value != null) {
-        if (pair.bvalue.value != null) {
-          const value2 = intersection(pair.avalue.value, pair.bvalue.value);
-          const e = { enum: enumDecl, value: value2 };
-          return e;
-        }
-        return pair.avalue.value;
-      }
-      return pair.bvalue;
-    }
-    default:
-      unhandledType(pair);
-  }
-}
-function intersectObj(to, from) {
-  if (!to)
-    return from;
-  if (!from)
-    return to;
-  let result = to;
-  Object.entries(from).forEach(([key, value2]) => {
-    if (!(0, import_chunk_JDC43A3I.hasProperty)(to, key)) {
-      if (result === to)
-        result = { ...result };
-      result[key] = value2;
-      return;
-    }
-    if (result === to)
-      result = { ...result };
-    result[key] = intersection(to[key], value2);
-  });
-  return result;
-}
-function fixupEnum(a, b_restricted, b) {
-  if (b.type & 65536) {
-    const bvalue = getUnionComponent(
-      b,
-      65536
-      /* Enum */
-    );
-    const br = restrictByEquality(
-      a,
-      bvalue && (bvalue.value || bvalue.enum?.resolvedType) || {
-        type: EnumTagsConst
-      }
-    );
-    if (br.type) {
-      b_restricted = cloneType(b_restricted);
-      unionInto(
-        b_restricted,
-        bvalue ? {
-          type: 65536,
-          value: { ...bvalue, value: br }
-        } : br
-      );
-    }
-  }
-  return b_restricted;
+  }
+  return b_restricted;
 }
 function restrictExactTypesByEquality(a, b) {
   switch (a.type) {
@@ -8512,12 +8080,7 @@ function restrictExactTypesByEquality(a, b) {
     case 131072:
       return intersection(a, b);
     case 65536: {
-      return restrictByEquality(
-        a.value && (a.value.value || a.value.enum?.resolvedType) || {
-          type: EnumTagsConst
-        },
-        b
-      );
+      return restrictByEquality(typeFromEnumValue(a.value), b);
     }
     case 262144:
       return restrictByEquality(
@@ -8589,182 +8152,449 @@ var init_intersection_type = (0, import_chunk_ABYVSU2C.__esm)({
     init_api();
     init_data_flow();
     (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
     init_could_be();
     init_interp();
     init_types();
     init_union_type();
   }
 });
-function subtypeOf(a, b) {
-  if (a.type & 262144 && a.value != null) {
-    return subtypeOf(expandTypedef(a), b);
+function union(to, from) {
+  const result = cloneType(to);
+  unionHelper(result, from, -Infinity);
+  return result;
+}
+function unionInto(to, from) {
+  return unionHelper(to, from, -Infinity);
+}
+function unionHelper(to, from, widenDepth) {
+  if (to == null || from == null) {
+    throw new Error("Null");
   }
-  if (b.type & 262144 && b.value != null) {
-    return subtypeOf(a, expandTypedef(b));
+  if (from.type === 0 || to === from)
+    return false;
+  if (to.type === 0) {
+    to.type = from.type;
+    to.value = from.value;
+    return true;
   }
-  if (a.type & 65536 && !(b.type & 65536) && b.type & EnumTagsConst) {
-    const value2 = getUnionComponent(
-      a,
-      65536
-      /* Enum */
-    );
-    if (!subtypeOf(
-      value2 != null && (value2.value || value2.enum?.resolvedType) || {
-        type: EnumTagsConst
-      },
-      b
-    )) {
+  const newTags = to.type | from.type;
+  if (!(from.type & ~SingletonTypeTagsConst)) {
+    if (newTags === to.type)
+      return false;
+    to.type = newTags;
+    return true;
+  }
+  if (newTags === to.type) {
+    if (to.value === from.value || to.value == null) {
       return false;
     }
-    if (a.type === 65536)
+    if (from.value == null) {
+      clearValuesUnder(to, from.type);
       return true;
-    const a2 = cloneType(a);
-    clearValuesUnder(a2, 65536, true);
-    return subtypeOf(a2, b);
-  }
-  let common = a.type & b.type;
-  if (common !== a.type) {
-    if (b.type & 32768 && getObjectValue(b) == null) {
-      common |= a.type & ObjectLikeTagsConst;
     }
-    if (common !== a.type)
-      return false;
+    return mergeMultiple(to, from, widenDepth);
   }
-  if (b.value == null)
-    return true;
-  let result = true;
-  forEachUnionComponent(b, common, (bc) => {
-    const avalue = getUnionComponent(a, bc.type);
-    if (bc.value == null || avalue === bc.value)
+  if (to.value != null) {
+    if (from.value == null) {
+      clearValuesUnder(to, from.type);
       return true;
-    if (avalue == null || !subtypeOfValue({ type: bc.type, avalue, bvalue: bc.value })) {
-      result = false;
-      return false;
     }
+    mergeMultiple(to, from, widenDepth);
+    return true;
+  }
+  if (from.value == null) {
+    to.type = newTags;
     return true;
+  }
+  const tmp = cloneType(from);
+  clearValuesUnder(tmp, to.type);
+  to.type = tmp.type;
+  to.value = tmp.value;
+  return true;
+}
+function mergeMultiple(to, from, widenDepth) {
+  const newTags = to.type | from.type;
+  let anyChanged = newTags !== to.type;
+  let mask = 0;
+  const result = {};
+  forEachUnionComponent(to, newTags, (ac) => {
+    const fromv = getUnionComponent(from, ac.type);
+    if (ac.value != null) {
+      if (fromv != null) {
+        const [value2, changed] = ac.value === fromv ? [fromv, false] : mergeSingle(
+          {
+            type: ac.type,
+            avalue: ac.value,
+            bvalue: fromv
+          },
+          widenDepth
+        );
+        if (changed)
+          anyChanged = true;
+        if (value2) {
+          mask |= ac.type;
+          result[ac.type] = value2;
+        }
+      } else if (!(from.type & ac.type)) {
+        mask |= ac.type;
+        result[ac.type] = ac.value;
+      } else {
+        anyChanged = true;
+      }
+    } else if (fromv && !(to.type & ac.type)) {
+      anyChanged = true;
+      mask |= ac.type;
+      result[ac.type] = fromv;
+    }
   });
-  return result;
+  if (!anyChanged)
+    return false;
+  to.type = newTags;
+  if (!mask) {
+    delete to.value;
+    return true;
+  }
+  if (hasUnionData(newTags)) {
+    to.value = result;
+    to.value.mask = mask;
+    return true;
+  }
+  if (mask & mask - 1) {
+    throw new Error("Union incorrectly produced a UnionData");
+  }
+  to.value = result[mask];
+  return true;
 }
-function subtypeOfValue(pair) {
+function mergeSingle(pair, widenDepth) {
+  function tryUnion(to, from) {
+    to = cloneType(to);
+    if (unionHelper(to, from, widenDepth + 1))
+      return to;
+    return null;
+  }
   switch (pair.type) {
     case 1:
     case 2:
     case 4:
-    case 262144:
-      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
+      throw new Error("Unexpected TypeTag in mergeSingle");
     case 8:
     case 16:
     case 32:
     case 64:
-    case 256:
     case 128:
+    case 256:
     case 131072:
-      return pair.avalue === pair.bvalue;
+      return [null, true];
     case 512: {
-      let result = true;
+      if (widenDepth > MaxWidenDepth) {
+        return [null, true];
+      }
+      const tupleTypes = /* @__PURE__ */ new Map();
+      const arrayTypes = [];
+      tupleForEach(
+        pair.avalue,
+        (v) => {
+          const t = tupleTypes.get(v.length);
+          if (t) {
+            t.push(v);
+          } else {
+            tupleTypes.set(v.length, [v]);
+          }
+        },
+        (v) => arrayTypes.push(v)
+      );
+      const extraTypes = [];
       tupleForEach(
-        pair.avalue,
-        (av) => {
-          let some2 = false;
-          tupleForEach(
-            pair.bvalue,
-            (bv) => {
-              some2 = av.length === bv.length && bv.every((b, i) => subtypeOf(av[i], b));
-              return some2 === false;
-            },
-            (bv) => (some2 = av.every((a) => subtypeOf(a, bv))) === false
-          );
-          return result = some2;
+        pair.bvalue,
+        (v) => {
+          const tuples = tupleTypes.get(v.length);
+          if (!tuples?.some(
+            (t) => t.every((at, i) => {
+              const bt = v[i];
+              return subtypeOf(at, bt) && subtypeOf(bt, at);
+            })
+          )) {
+            extraTypes.push(v);
+          }
         },
-        (av) => {
-          let some2 = false;
-          tupleForEach(
-            pair.bvalue,
-            () => {
-              return true;
-            },
-            (bv) => (some2 = subtypeOf(av, bv)) === false
-          );
-          return result = some2;
+        (v) => {
+          if (!arrayTypes.some((at) => subtypeOf(at, v) && subtypeOf(v, at))) {
+            extraTypes.push(v);
+          }
         }
       );
-      return result;
+      if (extraTypes.length) {
+        if (widenDepth >= 0) {
+          return [null, true];
+        }
+        const allTypes = (pair.avalue instanceof Set ? Array.from(pair.avalue) : [pair.avalue]).concat(extraTypes);
+        return [tupleReduce(allTypes), true];
+      }
+      return [pair.avalue, false];
     }
     case 1024: {
-      const adict = pair.avalue;
-      const bdict = pair.bvalue;
-      if (!adict.value) {
-        if (!bdict.value) {
-          return Array.from(adict).every(([key, av]) => {
-            const bv = bdict.get(key);
-            return !bv || subtypeOf(av, bv);
+      if (widenDepth > MaxWidenDepth) {
+        return [null, true];
+      }
+      const avalue = pair.avalue;
+      const bvalue = pair.bvalue;
+      if (!avalue.value) {
+        if (!bvalue.value) {
+          const result = new Map(avalue);
+          let merged = false;
+          result.forEach((av, key2) => {
+            const bv = bvalue.get(key2);
+            if (!bv) {
+              result.delete(key2);
+              merged = true;
+              return;
+            }
+            av = cloneType(av);
+            if (unionHelper(av, bv, widenDepth + 1))
+              merged = true;
+            result.set(key2, av);
+          });
+          return [result, merged];
+        } else {
+          const result = new Map(avalue);
+          let merged = false;
+          result.forEach((av, key2) => {
+            const keyType = typeFromObjectLiteralKey(key2);
+            if (couldBe(keyType, bvalue.key)) {
+              const bv = tryUnion(av, bvalue.value);
+              if (bv) {
+                result.set(key2, bv);
+                merged = true;
+              }
+            }
           });
+          return [result, merged];
         }
-        return false;
-      }
-      if (!bdict.value) {
-        return Array.from(bdict).every(([key, bv]) => {
-          const kt = typeFromObjectLiteralKey(key);
-          return !couldBe(kt, adict.key) || subtypeOf(adict.value, bv);
+      } else if (!bvalue.value) {
+        const result = new Map(bvalue);
+        let merged = false;
+        result.forEach((bv, key2) => {
+          const keyType = typeFromObjectLiteralKey(key2);
+          if (couldBe(keyType, avalue.key)) {
+            const av = tryUnion(bv, avalue.value);
+            if (av) {
+              result.set(key2, av);
+              merged = true;
+            }
+          }
         });
+        return [result, merged];
       }
-      return subtypeOf(adict.key, bdict.key) && subtypeOf(adict.value, bdict.value);
+      const { key, value: value2 } = avalue;
+      const keyChange = tryUnion(key, bvalue.key);
+      const valueChange = tryUnion(value2, bvalue.value);
+      if (keyChange || valueChange) {
+        return [{ key: keyChange || key, value: valueChange || value2 }, true];
+      }
+      return [pair.avalue, false];
     }
     case 2048: {
-      return pair.avalue.args.length === pair.bvalue.args.length && subtypeOf(pair.avalue.result, pair.bvalue.result) && pair.avalue.args.every((arg, i) => subtypeOf(pair.bvalue.args[i], arg));
+      if (pair.avalue.args.length !== pair.bvalue.args.length)
+        return [null, true];
+      const resultChange = tryUnion(pair.avalue.result, pair.bvalue.result);
+      const args = pair.avalue.args.map(
+        (arg, i) => intersection(arg, pair.bvalue.args[i])
+      );
+      if (args.some(
+        (arg) => arg.type === 0
+        /* Never */
+      )) {
+        return [null, true];
+      }
+      const argsChanged = args.some(
+        (arg, i) => !subtypeOf(pair.avalue.args[i], arg)
+      );
+      if (resultChange || argsChanged) {
+        return [{ result: resultChange || pair.avalue.result, args }, true];
+      }
+      return [pair.avalue, false];
     }
     case 4096:
-    case 8192: {
-      const asd = pair.avalue;
-      const bsd = pair.bvalue;
-      return (0, import_chunk_X7QCZR3F.every)(asd, (sna) => (0, import_chunk_X7QCZR3F.some)(bsd, (snb) => sna === snb));
+      return mergeStateDecls(pair.avalue, pair.bvalue);
+    case 8192:
+      return mergeStateDecls(pair.avalue, pair.bvalue);
+    case 16384:
+      return mergeStateDecls(pair.avalue, pair.bvalue);
+    case 262144:
+      return mergeStateDecls(pair.avalue, pair.bvalue);
+    case 32768: {
+      let klass = pair.avalue.klass;
+      const [obj, objChanged] = mergeObjectValues(
+        pair.avalue.obj,
+        pair.bvalue.obj,
+        widenDepth
+      );
+      const klassChanged = tryUnion(klass, pair.bvalue.klass);
+      if (klassChanged || objChanged) {
+        klass = klassChanged || klass;
+        if (obj) {
+          return [{ klass, obj }, true];
+        }
+        return [{ klass }, true];
+      }
+      return [pair.avalue, false];
     }
-    case 16384: {
-      const asd = pair.avalue;
-      const bsd = pair.bvalue;
-      return (0, import_chunk_X7QCZR3F.every)(asd, (sna) => {
-        const superA = getSuperClasses(sna);
-        return (0, import_chunk_X7QCZR3F.some)(bsd, (snb) => {
-          if (sna === snb || superA && superA.has(snb)) {
-            return true;
+    case 65536: {
+      const toE = pair.avalue;
+      const fromE = pair.bvalue;
+      let changed = false;
+      let resultEnum = toE.enum;
+      const s = new Set(
+        Array.isArray(toE.enum) ? toE.enum : [toE.enum]
+      );
+      const size = s.size;
+      (0, import_chunk_X7QCZR3F.forEach)(fromE.enum, (e) => s.add(e));
+      if (size !== s.size) {
+        resultEnum = Array.from(s);
+        changed = true;
+      }
+      let resultValue = toE.value;
+      if (resultValue) {
+        if (fromE.value) {
+          resultValue = cloneType(resultValue);
+          if (unionHelper(resultValue, fromE.value, widenDepth + 1)) {
+            changed = true;
           }
-          return false;
-        });
-      });
+        } else {
+          resultValue = void 0;
+          changed = true;
+        }
+      }
+      if (!changed) {
+        return [toE, false];
+      }
+      return resultValue ? [{ enum: resultEnum, value: resultValue }, changed] : [{ enum: resultEnum }, changed];
+    }
+    default:
+      unhandledType(pair);
+  }
+}
+function mergeObjectValues(to, from, widenDepth) {
+  if (!to) {
+    return [to, false];
+  }
+  if (!from) {
+    return [from, true];
+  }
+  let empty = true;
+  let result = to;
+  Object.entries(to).forEach(([key, value2]) => {
+    if (!(0, import_chunk_JDC43A3I.hasProperty)(from, key)) {
+      if (result === to)
+        result = { ...result };
+      delete result[key];
+      return;
+    }
+    const rep = cloneType(value2);
+    if (unionHelper(rep, from[key], widenDepth + 1)) {
+      if (result === to)
+        result = { ...result };
+      result[key] = rep;
+    }
+    empty = false;
+  });
+  if (empty) {
+    return [void 0, true];
+  }
+  return [result, result !== to];
+}
+function mergeStateDecls(to, from) {
+  let changed = false;
+  let result = to;
+  (0, import_chunk_X7QCZR3F.forEach)(from, (v) => {
+    if ((0, import_chunk_X7QCZR3F.some)(to, (t) => t === v)) {
+      return;
+    }
+    if (Array.isArray(result)) {
+      if (result === to) {
+        result = [...result, v];
+      } else {
+        result.push(v);
+      }
+    } else {
+      result = [to, v];
+    }
+    changed = true;
+  });
+  return [result, changed];
+}
+function nonUnionDataMask(tag) {
+  if (tag & tag - 1) {
+    return tag & UnionDataTypeTagsConst || tag & ValueTypeTagsConst;
+  }
+  return tag;
+}
+function clearValuesUnder(v, tag, clearTag = false) {
+  const newTag = clearTag ? v.type & ~tag : v.type | tag;
+  tag &= ~SingletonTypeTagsConst;
+  if (!tag || v.value == null) {
+    v.type = newTag;
+    return;
+  }
+  if (tag & ValueTypeTagsConst) {
+    tag |= ValueTypeTagsConst;
+  }
+  if (!hasUnionData(v.type)) {
+    const dataMask = nonUnionDataMask(v.type);
+    if (dataMask & tag) {
+      v.type = newTag;
+      delete v.value;
+      return;
     }
-    case 32768: {
-      const aobj = pair.avalue;
-      const bobj = pair.bvalue;
-      return subtypeOf(aobj.klass, bobj.klass) && subtypeOfObj(aobj.obj, bobj.obj);
+    if (dataMask & ValueTypeTagsConst) {
+      delete v.value;
+      v.type = newTag;
+      return;
     }
-    case 65536: {
-      const aenum = pair.avalue;
-      const benum = pair.bvalue;
-      return aenum.enum === benum.enum && (!aenum.value || !benum.value || subtypeOf(aenum.value, benum.value));
+    if (hasUnionData(newTag)) {
+      const mask = v.type & UnionDataTypeTagsConst;
+      v.value = {
+        [mask]: v.value,
+        mask
+      };
     }
-    default:
-      unhandledType(pair);
+    v.type = newTag;
+    return;
+  }
+  v.type = newTag;
+  const unionData = v.value;
+  let remain = unionData.mask & ~tag;
+  if (!remain) {
+    delete v.value;
+    return;
+  }
+  const newData = { mask: remain };
+  while (remain) {
+    const next = remain & remain - 1;
+    const bit = remain - next;
+    newData[bit] = unionData[bit];
+    remain = next;
+  }
+  if (!hasUnionData(newTag)) {
+    v.value = newData[newTag & UnionDataTypeTagsConst];
+  } else {
+    v.value = newData;
   }
 }
-function subtypeOfObj(a, b) {
-  if (!a || !b)
-    return true;
-  return Object.entries(b).every(([key, value2]) => {
-    if (!(0, import_chunk_JDC43A3I.hasProperty)(a, key))
-      return false;
-    return subtypeOf(a[key], value2);
-  });
-}
-var init_sub_type = (0, import_chunk_ABYVSU2C.__esm)({
-  "src/type-flow/sub-type.ts"() {
+var MaxWidenDepth;
+var init_union_type = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/union-type.ts"() {
     "use strict";
-    init_api();
+    (0, import_chunk_JDC43A3I.init_ast)();
     init_data_flow();
     (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
     init_could_be();
     init_intersection_type();
+    init_sub_type();
     init_types();
-    init_union_type();
+    MaxWidenDepth = 4;
   }
 });
 function common_types(left, right, allowed) {
@@ -9395,6 +9225,75 @@ var init_type_flow_util = (0, import_chunk_ABYVSU2C.__esm)({
     init_union_type();
   }
 });
+function getEffectiveTrackedType(constraint, tracked) {
+  if (!(constraint.type & 65536) && tracked.type & 65536) {
+    tracked = deEnumerate(tracked);
+  }
+  if (constraint.type & 262144 && constraint.value != null) {
+    return getEffectiveTrackedType(expandTypedef(constraint), tracked);
+  }
+  if (tracked.type & 262144 && tracked.value != null) {
+    return getEffectiveTrackedType(constraint, expandTypedef(tracked));
+  }
+  let common = constraint.type & tracked.type & ~262144;
+  if (tracked.type & 32768 && constraint.type & ObjectLikeTagsConst && getObjectValue(tracked) == null) {
+    common |= constraint.type & ObjectLikeTagsConst;
+  }
+  if (tracked.type & 65536 && constraint.type & EnumTagsConst && !(constraint.type & 65536)) {
+    common |= constraint.type & typeFromEnumValue(getUnionComponent(
+      tracked,
+      65536
+      /* Enum */
+    )).type;
+  }
+  if (!common) {
+    return {
+      type: 0
+      /* Never */
+    };
+  }
+  if (constraint.value == null) {
+    return { type: common };
+  }
+  if (tracked.value == null) {
+    const result2 = cloneType(constraint);
+    clearValuesUnder(result2, constraint.type & ~common, true);
+    return result2;
+  }
+  const result = {
+    type: 0
+    /* Never */
+  };
+  forEachUnionComponent(constraint, common, (ac) => {
+    common &= ~ac.type;
+    if (couldBe(ac, tracked)) {
+      if (ac.type === 512 && ac.value) {
+        const trackedData = getUnionComponent(tracked, ac.type);
+        if (trackedData) {
+          unionInto(result, {
+            type: 512,
+            value: restrictArrayData(ac.value, trackedData)
+          });
+          return;
+        }
+      }
+      unionInto(result, ac);
+    }
+  });
+  unionInto(result, { type: common });
+  return result;
+}
+var init_effective_type = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/effective-type.ts"() {
+    "use strict";
+    init_array_type();
+    init_could_be();
+    init_interp();
+    init_intersection_type();
+    init_types();
+    init_union_type();
+  }
+});
 function evaluateCall(istate, node, callee, args) {
   while (!hasValue(callee) || callee.type !== 8192) {
     const name = node.callee.type === "Identifier" ? node.callee : node.callee.type === "MemberExpression" && !node.callee.computed ? node.callee.property : null;
@@ -9455,7 +9354,7 @@ function checkCallArgs(istate, node, callees, args) {
       if (object) {
         const info = sysCallInfo(istate.state, cur);
         if (info) {
-          const result2 = info(istate, cur, object, () => args);
+          const result2 = info(istate, cur, object, () => args, node);
           if (result2.argTypes)
             argTypes = result2.argTypes;
           if (result2.returnType)
@@ -9499,59 +9398,21 @@ function checkCallArgs(istate, node, callees, args) {
             paramType = typeFromTypespec(istate.state, param.right, cur.stack);
           }
           if (checker(arg, paramType)) {
-            if (istate.state.config?.extraReferenceTypeChecks && effects && argEffects && !safeReferenceArg(node.arguments[i])) {
-              if (arg.type & 512) {
-                const atype = getUnionComponent(
-                  arg,
-                  512
-                  /* Array */
-                );
-                if (atype) {
-                  const ptype = getUnionComponent(
-                    paramType,
-                    512
-                    /* Array */
-                  );
-                  if (!ptype || !checkArrayCovariance(atype, ptype)) {
-                    curDiags.push([
-                      node.arguments[i],
-                      `Argument ${i + 1} to ${cur.fullName}: passing ${display(
-                        arg
-                      )} to parameter ${display(paramType)} is not type safe`
-                    ]);
-                  }
-                }
-              }
-              if (arg.type & 1024) {
-                const adata = getUnionComponent(
-                  arg,
-                  1024
-                  /* Dictionary */
-                );
-                if (adata && adata.value) {
-                  const pdata = getUnionComponent(
-                    paramType,
-                    1024
-                    /* Dictionary */
-                  );
-                  if (!pdata || !pdata.value || !subtypeOf(pdata.key, adata.key) || !subtypeOf(pdata.value, adata.value)) {
-                    curDiags.push([
-                      node.arguments[i],
-                      `Argument ${i + 1} to ${cur.fullName}: passing Dictionary<${display(adata.key)}, ${display(
-                        adata.value
-                      )}> to parameter ${display(
-                        pdata ? {
-                          type: 1024,
-                          value: pdata
-                        } : {
-                          type: 1024
-                          /* Dictionary */
-                        }
-                      )} is not type safe`
-                    ]);
+            if (istate.state.config?.extraReferenceTypeChecks !== false && effects && argEffects) {
+              extraReferenceTypeChecks(
+                istate,
+                (sourceType, targetType) => curDiags.push([
+                  node.arguments[i],
+                  `Argument ${i + 1} to ${cur.fullName}: passing ${sourceType} to parameter ${targetType} is not type safe`,
+                  {
+                    uri: "https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)",
+                    message: "more info"
                   }
-                }
-              }
+                ]),
+                paramType,
+                arg,
+                node.arguments[i]
+              );
             }
             return;
           }
@@ -9593,7 +9454,7 @@ function checkCallArgs(istate, node, callees, args) {
   if (istate.typeChecker) {
     if (istate.typeChecker === subtypeOf || allDiags.every((diags) => diags.length > 0)) {
       allDiags.flat().forEach(
-        (diag) => diagnostic(istate.state, diag[0], diag[1], istate.checkTypes)
+        (diag) => diagnostic(istate.state, diag[0], diag[1], istate.checkTypes, diag[2])
       );
     }
   }
@@ -9621,6 +9482,16 @@ function sysCallInfo(state, func) {
   }
   return null;
 }
+function getCallObjectConstrainedType(istate, call, trackedType) {
+  if (call.callee.type !== "MemberExpression")
+    return null;
+  const calleeObjNode = call.callee.object;
+  if (calleeObjNode.type !== "Identifier" && calleeObjNode.type !== "MemberExpression") {
+    return null;
+  }
+  const constraint = getLhsConstraint(istate, calleeObjNode);
+  return constraint && getEffectiveTrackedType(constraint, trackedType);
+}
 function getSystemCallTable(state) {
   if (systemCallInfo && systemCallVersion === state.sdk) {
     return systemCallInfo;
@@ -9694,7 +9565,7 @@ function getSystemCallTable(state) {
     }
     return ret;
   };
-  const arrayAdd = (istate, callee, calleeObj, getArgs) => {
+  const arrayAdd = (istate, callee, calleeObj, getArgs, call) => {
     const ret = {};
     if (calleeObj.type & 512) {
       const adata = getUnionComponent(
@@ -9703,8 +9574,19 @@ function getSystemCallTable(state) {
         /* Array */
       );
       if (adata) {
+        const constraint = getCallObjectConstrainedType(
+          istate,
+          call,
+          calleeObj
+        );
+        const cdata = (constraint && getUnionComponent(
+          constraint,
+          512
+          /* Array */
+        )) ?? adata;
         ret.returnType = { type: 512, value: adata };
         const args = getArgs();
+        const checker = istate.typeChecker;
         if (args.length === 1) {
           const arg = args[0];
           let hasTuple = false;
@@ -9712,33 +9594,38 @@ function getSystemCallTable(state) {
             const relaxed = relaxType(arg);
             tupleMap(
               adata,
-              (v) => {
-                hasTuple = true;
-                return [...v, relaxed];
-              },
-              (v) => {
-                if (subtypeOf(arg, v))
-                  return v;
-                const newAData = cloneType(v);
-                unionInto(newAData, arg);
-                if (!ret.argTypes) {
-                  ret.argTypes = [v];
-                } else {
-                  ret.argTypes = [intersection(ret.argTypes[0], v)];
-                }
-                return newAData;
-              },
+              (v) => [...v, relaxed],
+              (v) => subtypeOf(arg, v) ? v : union(v, arg),
               (v) => {
                 const newAData = tupleReduce(v);
                 ret.returnType.value = newAData;
                 const newObj = cloneType(calleeObj);
                 setUnionComponent(newObj, 512, newAData);
                 ret.calleeObj = newObj;
-                if (!ret.argTypes) {
-                  ret.argTypes = [relaxed];
-                }
               }
             );
+            if (checker) {
+              tupleForEach(
+                cdata,
+                () => {
+                  hasTuple = true;
+                },
+                (v) => {
+                  if (checker(arg, v))
+                    return;
+                  if (!ret.argTypes) {
+                    ret.argTypes = [v];
+                  } else {
+                    ret.argTypes = [
+                      (checker === subtypeOf ? intersection : union)(
+                        ret.argTypes[0],
+                        v
+                      )
+                    ];
+                  }
+                }
+              );
+            }
           } else {
             const argSubtypes = arg.type & 512 ? getUnionComponent(
               arg,
@@ -9753,26 +9640,13 @@ function getSystemCallTable(state) {
                   return tupleMap(
                     argSubtypes,
                     (a) => [...v, ...a],
-                    (a) => {
-                      const at = cloneType(reducedType(v));
-                      unionInto(at, a);
-                      return at;
-                    },
+                    (a) => union(reducedType(v), a),
                     (a) => a
                   );
                 },
                 (v) => {
                   const addedType = reducedArrayType(argSubtypes);
-                  if (subtypeOf(addedType, v))
-                    return [v];
-                  if (!ret.argTypes) {
-                    ret.argTypes = [v];
-                  } else {
-                    ret.argTypes = [intersection(ret.argTypes[0], v)];
-                  }
-                  v = cloneType(v);
-                  unionInto(v, addedType);
-                  return [v];
+                  return [subtypeOf(addedType, v) ? v : union(v, addedType)];
                 },
                 (va) => {
                   const newAData = tupleReduce(va.flat());
@@ -9780,18 +9654,36 @@ function getSystemCallTable(state) {
                   const newObj = cloneType(calleeObj);
                   setUnionComponent(newObj, 512, newAData);
                   ret.calleeObj = newObj;
-                  if (!ret.argTypes) {
-                    ret.argTypes = [
-                      { type: 512, value: argSubtypes }
-                    ];
-                  }
                 }
               );
-            } else {
+              if (checker) {
+                tupleForEach(
+                  adata,
+                  () => {
+                    hasTuple = true;
+                  },
+                  (v) => {
+                    const addedType = reducedArrayType(argSubtypes);
+                    if (subtypeOf(addedType, v))
+                      return;
+                    if (!ret.argTypes) {
+                      ret.argTypes = [v];
+                    } else {
+                      ret.argTypes = [
+                        (checker === subtypeOf ? intersection : union)(
+                          ret.argTypes[0],
+                          v
+                        )
+                      ];
+                    }
+                  }
+                );
+              }
+            } else if (checker) {
               tupleForEach(
-                adata,
+                cdata,
                 () => hasTuple = true,
-                () => false
+                () => true
               );
             }
           }
@@ -10104,6 +9996,7 @@ function getSystemCallTable(state) {
     }
     return results;
   };
+  const mathDefault = (istate, callee, calleeObj, getArgs) => mathHelper(istate, callee, calleeObj, getArgs);
   systemCallVersion = state.sdk;
   return systemCallInfo = expandKeys(state, {
     "$.Toybox.Lang.Array.add": arrayAdd,
@@ -10127,12 +10020,12 @@ function getSystemCallTable(state) {
     "$.Toybox.Lang.Method.invoke": methodInvoke,
     "$.Toybox.Lang.Object.method": method,
     "$.Toybox.Lang.*.toNumber": toNumber,
-    "$.Toybox.Math.acos": mathHelper,
-    "$.Toybox.Math.asin": mathHelper,
-    "$.Toybox.Math.atan": mathHelper,
-    "$.Toybox.Math.atan2": mathHelper,
+    "$.Toybox.Math.acos": mathDefault,
+    "$.Toybox.Math.asin": mathDefault,
+    "$.Toybox.Math.atan": mathDefault,
+    "$.Toybox.Math.atan2": mathDefault,
     "$.Toybox.Math.ceil": rounder,
-    "$.Toybox.Math.cos": mathHelper,
+    "$.Toybox.Math.cos": mathDefault,
     "$.Toybox.Math.floor": rounder,
     "$.Toybox.Math.ln": (state2, callee, calleeObj, getArgs) => mathHelper(state2, callee, calleeObj, getArgs, "log"),
     "$.Toybox.Math.log": (state2, callee, calleeObj, getArgs) => mathHelper(
@@ -10142,11 +10035,11 @@ function getSystemCallTable(state) {
       getArgs,
       (x, base) => Math.log(x) / Math.log(base)
     ),
-    "$.Toybox.Math.pow": mathHelper,
+    "$.Toybox.Math.pow": mathDefault,
     "$.Toybox.Math.round": rounder,
-    "$.Toybox.Math.sin": mathHelper,
-    "$.Toybox.Math.sqrt": mathHelper,
-    "$.Toybox.Math.tan": mathHelper,
+    "$.Toybox.Math.sin": mathDefault,
+    "$.Toybox.Math.sqrt": mathDefault,
+    "$.Toybox.Math.tan": mathDefault,
     "$.Toybox.Math.toDegrees": (state2, callee, calleeObj, getArgs) => mathHelper(
       state2,
       callee,
@@ -10208,6 +10101,88 @@ function expandKeys(state, table) {
   });
   return result;
 }
+function extraReferenceTypeChecks(istate, report, targetType, sourceType, sourceNode) {
+  if (safeReferenceArg(sourceNode)) {
+    return;
+  }
+  let constrainedType = null;
+  const getConstrained = () => {
+    if (!constrainedType) {
+      const constraint = (sourceNode.type === "Identifier" || sourceNode.type === "MemberExpression") && getLhsConstraint(istate, sourceNode);
+      constrainedType = constraint ? getEffectiveTrackedType(constraint, sourceType) : {
+        type: 0
+        /* Never */
+      };
+    }
+    return constrainedType;
+  };
+  const doCheck = (checker) => {
+    const result = checker(sourceType);
+    if (!result)
+      return false;
+    const ct = getConstrained();
+    if (ct.type === 0)
+      return result;
+    return checker(ct);
+  };
+  const arrayReport = doCheck((sourceType2) => {
+    if (sourceType2.type & 512) {
+      const atype = getUnionComponent(
+        sourceType2,
+        512
+        /* Array */
+      );
+      if (atype) {
+        const ptype = getUnionComponent(
+          targetType,
+          512
+          /* Array */
+        );
+        if (!ptype || !checkArrayCovariance(atype, ptype)) {
+          return [display(sourceType2), display(targetType)];
+        }
+      }
+    }
+    return false;
+  });
+  if (arrayReport) {
+    report(...arrayReport);
+  }
+  const dictReport = doCheck((sourceType2) => {
+    if (sourceType2.type & 1024) {
+      const adata = getUnionComponent(
+        sourceType2,
+        1024
+        /* Dictionary */
+      );
+      if (adata && adata.value) {
+        const pdata = getUnionComponent(
+          targetType,
+          1024
+          /* Dictionary */
+        );
+        if (!pdata || !pdata.value || !subtypeOf(pdata.key, adata.key) || !subtypeOf(pdata.value, adata.value)) {
+          return [
+            `Dictionary<${display(adata.key)}, ${display(adata.value)}>`,
+            display(
+              pdata ? {
+                type: 1024,
+                value: pdata
+              } : {
+                type: 1024
+                /* Dictionary */
+              }
+            )
+          ];
+        }
+      }
+    }
+    return false;
+  });
+  if (dictReport) {
+    report(...dictReport);
+  }
+}
 var systemCallInfo, systemCallVersion;
 var init_interp_call = (0, import_chunk_ABYVSU2C.__esm)({
   "src/type-flow/interp-call.ts"() {
@@ -10215,12 +10190,14 @@ var init_interp_call = (0, import_chunk_ABYVSU2C.__esm)({
     init_api();
     init_optimizer_types();
     (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
     init_interp();
     init_intersection_type();
     init_sub_type();
     init_type_flow_util();
     init_types();
     init_union_type();
+    init_effective_type();
     systemCallInfo = null;
   }
 });
@@ -10476,16 +10453,14 @@ function deEnumerate(t) {
     );
     t = cloneType(t);
     clearValuesUnder(t, 65536, true);
-    unionInto(
-      t,
-      data && (data.value || data.enum?.resolvedType) || {
-        type: EnumTagsConst
-      }
-    );
+    unionInto(t, typeFromEnumValue(data));
   }
   return t;
 }
 function arrayTypeAtIndex(arr, elemType, forStrictAssign, enforceTuples) {
+  if (elemType) {
+    elemType = deEnumerate(elemType);
+  }
   const reduce2 = (v) => forStrictAssign ? v.reduce(
     (t, c) => t ? intersection(t, c) : c,
     null
@@ -10507,124 +10482,140 @@ function arrayTypeAtIndex(arr, elemType, forStrictAssign, enforceTuples) {
     }
   );
 }
-function getLhsConstraint(istate, node) {
+function getLhsConstraintHelper(istate, node) {
   if (istate.localLvals?.has(node)) {
-    return null;
+    return [istate.typeMap?.get(node), false];
   }
-  let lookupDefs = null;
-  if (node.type === "MemberExpression") {
-    if (!istate.typeMap) {
-      throw new Error("Checking types without a typeMap");
-    }
-    const object = istate.typeMap.get(node.object);
-    if (object) {
-      if (node.computed) {
-        const strict = istate.typeChecker === subtypeOf;
-        if (strict && object.type & ~(512 | 1024 | 32768 | 262144)) {
-          return {
-            type: 0
-            /* Never */
-          };
-        }
-        if (object.value) {
-          let result = null;
-          if (object.type & 512) {
-            const arr = getUnionComponent(
-              object,
-              512
-              /* Array */
-            );
-            if (arr) {
-              result = arrayTypeAtIndex(
-                arr,
-                istate.typeMap.get(node.property) ?? {
-                  type: 8,
-                  value: arrayLiteralKeyFromExpr(node.property) ?? void 0
-                },
-                strict,
-                istate.state.config?.extraReferenceTypeChecks !== false
-              );
-            }
+  let lookupDefs = istate.state.lookupNonlocal(node)[1];
+  if (!lookupDefs) {
+    if (node.type === "MemberExpression") {
+      if (!istate.typeMap) {
+        throw new Error("Checking types without a typeMap");
+      }
+      const trackedObject = istate.typeMap?.get(node.object);
+      const object = (node.object.type === "Identifier" || node.object.type === "MemberExpression") && getLhsConstraintHelper(istate, node.object)[0] || trackedObject;
+      if (object) {
+        const tracked = trackedObject ?? object;
+        const objType = object.type & tracked.type;
+        if (node.computed) {
+          const strict = istate.typeChecker === subtypeOf;
+          if (strict && objType & ~(512 | 1024 | 32768 | 262144)) {
+            return [{
+              type: 0
+              /* Never */
+            }, true];
           }
-          const updateResult = (value2) => {
-            if (result) {
-              if (strict) {
-                result = intersection(result, value2);
-              } else {
-                result = cloneType(result);
-                unionInto(result, value2);
+          if (object.value) {
+            let result = null;
+            if (objType & 512) {
+              let arr = getUnionComponent(
+                object,
+                512
+                /* Array */
+              );
+              if (arr) {
+                if (trackedObject) {
+                  const current = getUnionComponent(
+                    trackedObject,
+                    512
+                    /* Array */
+                  );
+                  if (current) {
+                    arr = restrictArrayData(arr, current);
+                  }
+                }
+                result = arrayTypeAtIndex(
+                  arr,
+                  istate.typeMap.get(node.property) ?? {
+                    type: 8,
+                    value: arrayLiteralKeyFromExpr(node.property) ?? void 0
+                  },
+                  strict,
+                  istate.state.config?.extraReferenceTypeChecks !== false
+                );
               }
-            } else {
-              result = value2;
             }
-          };
-          if (object.type & 1024) {
-            const dict = getUnionComponent(
-              object,
-              1024
-              /* Dictionary */
-            );
-            if (dict) {
-              if (dict.value) {
-                updateResult(dict.value);
+            const updateResult = (value2) => {
+              if (result) {
+                if (strict) {
+                  result = intersection(result, value2);
+                } else {
+                  result = cloneType(result);
+                  unionInto(result, value2);
+                }
               } else {
-                const keyType = istate.typeMap.get(node.property);
-                const keyStr = keyType ? objectLiteralKeyFromType(keyType) : objectLiteralKeyFromExpr(node.property);
-                if (keyStr) {
-                  const value2 = dict.get(keyStr);
-                  if (value2 != null) {
-                    updateResult(value2);
+                result = value2;
+              }
+            };
+            if (object.type & 1024) {
+              const dict = getUnionComponent(
+                object,
+                1024
+                /* Dictionary */
+              );
+              if (dict) {
+                if (dict.value) {
+                  updateResult(dict.value);
+                } else {
+                  const keyType = istate.typeMap.get(node.property);
+                  const keyStr = keyType ? objectLiteralKeyFromType(keyType) : objectLiteralKeyFromExpr(node.property);
+                  if (keyStr) {
+                    const value2 = dict.get(keyStr);
+                    if (value2 != null) {
+                      updateResult(value2);
+                    }
                   }
                 }
               }
             }
-          }
-          if (object.type & 32768) {
-            const obj = getUnionComponent(
-              object,
-              32768
-              /* Object */
-            );
-            if (obj && isByteArrayData(obj)) {
-              updateResult({
-                type: 8 | 128
-                /* Char */
-              });
+            if (object.type & 32768) {
+              const obj = getUnionComponent(
+                object,
+                32768
+                /* Object */
+              );
+              if (obj && isByteArrayData(obj)) {
+                updateResult({
+                  type: 8 | 128
+                  /* Char */
+                });
+              }
+            }
+            if (result) {
+              return [result, true];
             }
           }
-          if (result) {
-            return result;
-          }
-        }
-      } else {
-        const [, trueDecls2] = findObjectDeclsByProperty(
-          istate.state,
-          object,
-          node.property
-        );
-        if (trueDecls2) {
-          lookupDefs = lookupNext(
+        } else {
+          const [, trueDecls2] = findObjectDeclsByProperty(
             istate.state,
-            [{ parent: null, results: trueDecls2 }],
-            "decls",
+            object,
             node.property
           );
+          if (trueDecls2) {
+            lookupDefs = lookupNext(
+              istate.state,
+              [{ parent: null, results: trueDecls2 }],
+              "decls",
+              node.property
+            );
+          }
         }
       }
     }
   }
   if (!lookupDefs) {
-    [, lookupDefs] = istate.state.lookup(node);
-  }
-  if (!lookupDefs) {
-    return null;
+    return [null, false];
   }
   const trueDecls = lookupDefs.flatMap(
     (lookupDef) => lookupDef.results.filter(
       (decl) => decl.type === "VariableDeclarator" && decl.node.kind === "var" && !isLocal(decl)
     )
   );
-  return trueDecls.length === 0 ? null : typeFromTypeStateNodes(istate.state, trueDecls);
+  return trueDecls.length === 0 ? [null, false] : [typeFromTypeStateNodes(istate.state, trueDecls), true];
+}
+function getLhsConstraint(istate, node) {
+  const [constraintType, constrained] = getLhsConstraintHelper(istate, node);
+  return constrained ? constraintType : null;
 }
 function pushScopedNameType(istate, node, object) {
   let embeddedEffects = object ? object.embeddedEffects : false;
@@ -11159,17 +11150,40 @@ function evaluateNode(istate, node) {
       if (istate.typeChecker) {
         const constraint = getLhsConstraint(istate, node.left);
         const actual = istate.stack[istate.stack.length - 1].value;
-        if (constraint && !istate.typeChecker(actual, constraint)) {
-          diagnostic(
-            istate.state,
-            node,
-            formatAstLongLines(node.left).then(
-              (nodeStr) => `Invalid assignment to ${nodeStr}. Expected ${display(
-                constraint
-              )} but got ${display(actual)}`
-            ),
-            istate.checkTypes
-          );
+        if (constraint) {
+          if (istate.typeChecker(actual, constraint)) {
+            if (istate.state.config?.extraReferenceTypeChecks !== false) {
+              extraReferenceTypeChecks(
+                istate,
+                (sourceType, targetType) => diagnostic(
+                  istate.state,
+                  node,
+                  formatAstLongLines(node.left).then(
+                    (nodeStr) => `Unsafe assignment to ${nodeStr}: assigning ${sourceType} to ${targetType} is not type safe`
+                  ),
+                  istate.checkTypes,
+                  {
+                    uri: "https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)",
+                    message: "more info"
+                  }
+                ),
+                constraint,
+                actual,
+                node.right
+              );
+            }
+          } else {
+            diagnostic(
+              istate.state,
+              node,
+              formatAstLongLines(node.left).then(
+                (nodeStr) => `Invalid assignment to ${nodeStr}. Expected ${display(
+                  constraint
+                )} but got ${display(actual)}`
+              ),
+              istate.checkTypes
+            );
+          }
         }
       }
       break;
@@ -11271,21 +11285,41 @@ function evaluateNode(istate, node) {
     case "ReturnStatement": {
       const value2 = node.argument && popIstate(istate, node.argument);
       if (istate.typeChecker) {
-        if (istate.root?.type !== "FunctionDeclaration") {
+        const root = istate.root;
+        if (root?.type !== "FunctionDeclaration") {
           throw new Error("ReturnStatement found outside of function");
         }
-        if (istate.root.node.returnType) {
+        if (root.node.returnType) {
           const returnType = typeFromTypespec(
             istate.state,
-            istate.root.node.returnType.argument,
-            istate.root.stack
+            root.node.returnType.argument,
+            root.stack
           );
           if (value2) {
-            if (!istate.typeChecker(value2.value, returnType)) {
+            if (istate.typeChecker(value2.value, returnType)) {
+              if (istate.state.config?.extraReferenceTypeChecks !== false) {
+                extraReferenceTypeChecks(
+                  istate,
+                  (sourceType, targetType) => diagnostic(
+                    istate.state,
+                    node,
+                    `Unsafe return from ${root.fullName}: converting ${sourceType} to ${targetType} is not type safe`,
+                    istate.checkTypes,
+                    {
+                      uri: "https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)",
+                      message: "more info"
+                    }
+                  ),
+                  returnType,
+                  value2.value,
+                  node.argument
+                );
+              }
+            } else {
               diagnostic(
                 istate.state,
                 node,
-                `Expected ${istate.root.fullName} to return ${display(
+                `Expected ${root.fullName} to return ${display(
                   returnType
                 )} but got ${display(value2.value)}`,
                 istate.checkTypes
@@ -11412,6 +11446,7 @@ var init_interp = (0, import_chunk_ABYVSU2C.__esm)({
     init_data_flow();
     init_optimizer_types();
     (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
     init_could_be();
     init_interp_binary();
     init_interp_call();
@@ -11736,10 +11771,8 @@ function arrayLiteralKeyFromType(k) {
   return null;
 }
 function arrayLiteralKeyFromExpr(key) {
-  if (key.type === "Literal") {
-    return arrayLiteralKeyFromType(typeFromLiteral(key));
-  }
-  return null;
+  const lit = key.type === "Literal" ? key : (0, import_chunk_JDC43A3I.getNodeValue)(key)[0];
+  return lit && arrayLiteralKeyFromType(typeFromLiteral(lit));
 }
 function objectLiteralKeyFromExpr(key) {
   switch (key.type) {
@@ -12024,11 +12057,8 @@ function mcExprFromType(type) {
       if (type.value.value && hasValue(type.value.value)) {
         const left = mcExprFromType(type.value.value);
         if (left) {
-          if (!type.value.enum) {
-            return left;
-          }
-          const enumStr = type.value.enum.fullName.slice(2);
-          if (enumStr === "Toybox.Graphics.ColorValue" && left.type === "Literal" && typeof left.value === "number" && left.value >= 0 && left.value <= 16777215 && /^\d+$/.test(left.raw)) {
+          const enumStrs = (0, import_chunk_X7QCZR3F.map)(type.value.enum, (e) => e.fullName.slice(2));
+          if (enumStrs.length === 1 && enumStrs[0] === "Toybox.Graphics.ColorValue" && left.type === "Literal" && typeof left.value === "number" && left.value >= 0 && left.value <= 16777215 && /^\d+$/.test(left.raw)) {
             left.raw = "0x" + `00000${left.value.toString(16)}`.slice(-6);
           }
           return {
@@ -12037,7 +12067,7 @@ function mcExprFromType(type) {
             left,
             right: {
               type: "TypeSpecList",
-              ts: [type.value.enum.fullName.slice(2)]
+              ts: enumStrs
             }
           };
         }
@@ -12118,229 +12148,620 @@ function castType(type, target) {
         result.type = Number(type.value) === 0 ? 2 : 4;
         return result;
       }
-    }
+    }
+  }
+  return result;
+}
+function reducedType(elems) {
+  if (!Array.isArray(elems)) {
+    return elems;
+  }
+  return elems.flat().reduce(
+    (p, t) => {
+      unionInto(p, t);
+      return p;
+    },
+    {
+      type: 0
+      /* Never */
+    }
+  );
+}
+function mustBeTrue(arg) {
+  return (arg.type === 8 || arg.type === 16) && arg.value != null && Number(arg.value) !== 0 || (arg.type & TruthyTypes) !== 0 && (arg.type & ~TruthyTypes) === 0;
+}
+function mustBeFalse(arg) {
+  return arg.type === 1 || arg.type === 2 || (arg.type === 8 || arg.type === 16) && arg.value != null && Number(arg.value) === 0;
+}
+function display(type) {
+  const names = (v, fn) => (0, import_chunk_X7QCZR3F.map)(v, fn).sort().filter((s, i, arr) => !i || s !== arr[i - 1]).join(" or ");
+  const parts = [];
+  const displayOne = (tv) => {
+    switch (tv.type) {
+      case 1:
+      case 2:
+      case 4:
+        throw new Error("Unexpected value for SingletonTypeTag");
+      case 8:
+      case 16:
+      case 32:
+      case 64:
+        return tv.value.toString();
+      case 128:
+        return `'${JSON.stringify(tv.value).slice(1, -1)}'`;
+      case 256:
+        return JSON.stringify(tv.value);
+      case 512:
+        return tupleMap(
+          tv.value,
+          (v) => `[${v.map((t) => display(t)).join(", ")}]`,
+          (v) => `Array<${display(v)}>`,
+          (v) => v.join(" or ")
+        );
+      case 1024:
+        return tv.value.value ? `Dictionary<${display(tv.value.key)}, ${display(tv.value.value)}>` : `{ ${Array.from(tv.value).map(
+          ([key, value2]) => `${display(typeFromObjectLiteralKey(key))} as ${display(
+            value2
+          )}`
+        ).join(", ")} }`;
+      case 2048:
+        return `Method(${tv.value.args.map((arg, i) => `a${i + 1} as ${display(arg)}`).join(", ")}) as ${display(tv.value.result)}`;
+      case 4096:
+      case 8192:
+      case 16384:
+      case 262144:
+        return names(tv.value, (v) => v.fullName.slice(2));
+      case 32768: {
+        const klass = tv.value.klass;
+        if (!klass.value)
+          return void 0;
+        const obj = tv.value.obj;
+        const ret = displayOne({ type: 16384, value: klass.value });
+        return obj ? `${ret}<{${Object.entries(obj).map(([key, value2]) => `${key}: ${display(value2)}`).join(", ")}}>` : ret;
+      }
+      case 65536: {
+        const v = tv.value;
+        const name = v.enum ? (0, import_chunk_X7QCZR3F.map)(v.enum, (e) => e.fullName.slice(2)).join(" or ") : "";
+        return v.value != null ? `${display(v.value)} as ${name}` : name;
+      }
+      case 131072:
+        return `:${tv.value}`;
+      default:
+        unhandledType(tv);
+    }
+  };
+  let bits = type.type;
+  if (!bits)
+    return "Never";
+  if (bits === 524287 && type.value == null) {
+    return "Any";
+  }
+  while (bits) {
+    const next = bits & bits - 1;
+    const bit = bits - next;
+    if (bit === 2 && next & 4) {
+      parts.push("Boolean");
+      bits = next - 4;
+      continue;
+    }
+    const name = typeTagName(bit);
+    const value2 = getUnionComponent(type, bit);
+    const valueStr = value2 != null && displayOne({ type: bit, value: value2 });
+    if (!valueStr) {
+      parts.push(name);
+    } else if (bit & (32768 | 65536 | 262144 | 131072 | 2048 | 256 | 512 | 1024)) {
+      parts.push(valueStr);
+    } else {
+      parts.push(`${name}<${valueStr}${valueStr.endsWith(">") ? " " : ""}>`);
+    }
+    bits = next;
+  }
+  return parts.join(" or ");
+}
+function hasUnionData(tag) {
+  tag &= UnionDataTypeTagsConst;
+  return (tag & tag - 1) !== 0;
+}
+function getObjectValue(t) {
+  if (!(t.type & 32768) || t.value == null)
+    return null;
+  if (hasUnionData(t.type)) {
+    return t.value[
+      32768
+      /* Object */
+    ];
+  }
+  return t.value;
+}
+function forEachUnionComponent(v, bits, fn) {
+  bits &= ~SingletonTypeTagsConst;
+  if (!bits)
+    return;
+  if ((v.type | bits) & UnionDataTypeTagsConst) {
+    bits &= ~ValueTypeTagsConst;
+  } else if (bits & bits - 1) {
+    return;
+  }
+  const hasUnion = hasUnionData(v.type);
+  const unionData = v.value;
+  do {
+    const next = bits & bits - 1;
+    const bit = bits - next;
+    const data = hasUnion ? unionData[bit] : bit & v.type ? v.value : null;
+    if (fn({ type: bit, value: data }) === false)
+      break;
+    bits = next;
+  } while (bits);
+}
+function getUnionComponent(v, tag) {
+  if (v.value == null)
+    return null;
+  let bits = v.type & ~SingletonTypeTagsConst;
+  if (!bits)
+    return null;
+  if (bits & bits - 1) {
+    bits &= UnionDataTypeTagsConst;
+    if (!bits) {
+      throw new Error(`Non-exact type had no union bits set`);
+    }
+  }
+  if (bits === tag) {
+    return v.value;
+  } else if (bits & tag) {
+    const unionData = v.value;
+    return unionData[tag] || null;
+  }
+  return null;
+}
+function setUnionComponent(v, tag, c) {
+  if (hasUnionData(v.type)) {
+    const value2 = v.value ? { ...v.value } : { mask: 0 };
+    value2[tag] = c;
+    value2.mask |= tag;
+    v.value = value2;
+  } else {
+    v.value = c;
+  }
+}
+function getStateNodeDeclsFromType(state, object) {
+  return getStateNodeDeclsWithExactFromType(state, object).map(({ sn }) => sn);
+}
+function getStateNodeDeclsWithExactFromType(state, object) {
+  const decls = [];
+  if (object.value != null && object.type & (4096 | 16384 | 32768)) {
+    forEachUnionComponent(
+      object,
+      object.type & (4096 | 16384 | 32768),
+      (type) => {
+        if (type.value == null)
+          return;
+        switch (type.type) {
+          case 32768:
+            if (type.value.klass.type === 16384 && type.value.klass.value) {
+              (0, import_chunk_X7QCZR3F.forEach)(
+                type.value.klass.value,
+                (sn) => decls.push({ sn, exact: false })
+              );
+            }
+            break;
+          case 4096:
+          case 16384:
+            (0, import_chunk_X7QCZR3F.forEach)(type.value, (sn) => decls.push({ sn, exact: true }));
+            break;
+        }
+      }
+    );
+  }
+  let bits = object.type & (ObjectLikeTagsConst | 32768);
+  if (bits & 32768 && getObjectValue(object)) {
+    bits -= 32768;
+  }
+  if (bits) {
+    do {
+      let next = bits & bits - 1;
+      let bit = bits - next;
+      if (bit & 6) {
+        bit = 6;
+        next &= ~6;
+      }
+      const name = `Toybox.Lang.${typeTagName(bit)}`;
+      const sns = lookupByFullName(state, name);
+      sns.forEach((sn) => isStateNode(sn) && decls.push({ sn, exact: true }));
+      bits = next;
+    } while (bits);
   }
-  return result;
+  return decls;
 }
-function reducedType(elems) {
-  if (!Array.isArray(elems)) {
-    return elems;
+function typeFromEnumValue(arg) {
+  return arg?.value ?? (arg && reducedType(
+    (0, import_chunk_X7QCZR3F.map)(
+      arg.enum,
+      (e) => e.resolvedType ?? {
+        type: EnumTagsConst
+      }
+    )
+  )) ?? {
+    type: EnumTagsConst
+  };
+}
+var LastTypeTag, SingletonTypeTagsConst, UnionDataTypeTagsConst, ValueTypeTagsConst, ObjectLikeTagsConst, EnumTagsConst, TruthyTypes;
+var init_types = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/types.ts"() {
+    "use strict";
+    init_api();
+    (0, import_chunk_JDC43A3I.init_ast)();
+    init_data_flow();
+    (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
+    init_interp();
+    init_intersection_type();
+    init_union_type();
+    LastTypeTag = 262144;
+    SingletonTypeTagsConst = 1 | 2 | 4;
+    UnionDataTypeTagsConst = 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768 | 65536 | 262144;
+    ValueTypeTagsConst = 8 | 16 | 32 | 64 | 128 | 256 | 131072;
+    ObjectLikeTagsConst = 6 | ValueTypeTagsConst | 512 | 1024 | 2048 | 65536;
+    EnumTagsConst = SingletonTypeTagsConst | ValueTypeTagsConst & ~131072;
+    TruthyTypes = 4 | // TypeTag.Object | // omit because of missing null on various Toybox types
+    4096 | 16384 | 8192;
   }
-  return elems.flat().reduce(
-    (p, t) => {
-      unionInto(p, t);
-      return p;
-    },
-    {
-      type: 0
-      /* Never */
+});
+function couldBeHelper(a, b, shallow) {
+  const common = a.type & b.type & ~262144;
+  if (common) {
+    if (a.value == null || b.value == null || a.value === b.value) {
+      return true;
     }
-  );
+    if (common & SingletonTypeTagsConst) {
+      return true;
+    }
+    if (common & ValueTypeTagsConst && common & UnionDataTypeTagsConst) {
+      return true;
+    }
+    let result = false;
+    forEachUnionComponent(a, common, (ac) => {
+      if (ac.value == null) {
+        result = true;
+        return false;
+      }
+      const bvalue = getUnionComponent(b, ac.type);
+      if (bvalue == null || ac.value === bvalue || couldBeValue(
+        { type: ac.type, avalue: ac.value, bvalue },
+        shallow
+      )) {
+        result = true;
+        return false;
+      }
+      return true;
+    });
+    if (result)
+      return true;
+  }
+  if (a.type & 65536 && b.type & (EnumTagsConst | 65536) || b.type & 65536 && a.type & (EnumTagsConst | 65536)) {
+    return true;
+  }
+  if (a.type & 32768 && b.type & ObjectLikeTagsConst && getObjectValue(a) == null) {
+    return true;
+  }
+  if (b.type & 32768 && a.type & ObjectLikeTagsConst && getObjectValue(b) == null) {
+    return true;
+  }
+  const checkTypedef = (t, other) => {
+    const typedef = getUnionComponent(
+      t,
+      262144
+      /* Typedef */
+    );
+    return typedef && (0, import_chunk_X7QCZR3F.some)(typedef, (td) => {
+      if (!td.resolvedType) {
+        throw new Error(`No resolved type for ${td.fullName} in 'couldBe'`);
+      }
+      return couldBe(td.resolvedType, other);
+    });
+  };
+  if (a.type & 262144 && checkTypedef(a, b)) {
+    return true;
+  }
+  if (b.type & 262144 && checkTypedef(b, a)) {
+    return true;
+  }
+  return false;
 }
-function mustBeTrue(arg) {
-  return (arg.type === 8 || arg.type === 16) && arg.value != null && Number(arg.value) !== 0 || (arg.type & TruthyTypes) !== 0 && (arg.type & ~TruthyTypes) === 0;
+function couldBe(a, b) {
+  return couldBeHelper(a, b, false);
 }
-function mustBeFalse(arg) {
-  return arg.type === 1 || arg.type === 2 || (arg.type === 8 || arg.type === 16) && arg.value != null && Number(arg.value) === 0;
+function couldBeWeak(a, b) {
+  if (a.type === 0 || b.type === 0)
+    return true;
+  return couldBe(a, b);
 }
-function display(type) {
-  const names = (v, fn) => (0, import_chunk_X7QCZR3F.map)(v, fn).sort().filter((s, i, arr) => !i || s !== arr[i - 1]).join(" or ");
-  const parts = [];
-  const displayOne = (tv) => {
-    switch (tv.type) {
-      case 1:
-      case 2:
-      case 4:
-        throw new Error("Unexpected value for SingletonTypeTag");
-      case 8:
-      case 16:
-      case 32:
-      case 64:
-        return tv.value.toString();
-      case 128:
-        return `'${JSON.stringify(tv.value).slice(1, -1)}'`;
-      case 256:
-        return JSON.stringify(tv.value);
-      case 512:
-        return tupleMap(
-          tv.value,
-          (v) => `[${v.map((t) => display(t)).join(", ")}]`,
-          (v) => `Array<${display(v)}>`,
-          (v) => v.join(" or ")
-        );
-      case 1024:
-        return tv.value.value ? `Dictionary<${display(tv.value.key)}, ${display(tv.value.value)}>` : `{ ${Array.from(tv.value).map(
-          ([key, value2]) => `${display(typeFromObjectLiteralKey(key))} as ${display(
-            value2
-          )}`
-        ).join(", ")} }`;
-      case 2048:
-        return `Method(${tv.value.args.map((arg, i) => `a${i + 1} as ${display(arg)}`).join(", ")}) as ${display(tv.value.result)}`;
-      case 4096:
-      case 8192:
-      case 16384:
-      case 262144:
-        return names(tv.value, (v) => v.fullName.slice(2));
-      case 32768: {
-        const klass = tv.value.klass;
-        if (!klass.value)
-          return void 0;
-        const obj = tv.value.obj;
-        const ret = displayOne({ type: 16384, value: klass.value });
-        return obj ? `${ret}<{${Object.entries(obj).map(([key, value2]) => `${key}: ${display(value2)}`).join(", ")}}>` : ret;
-      }
-      case 65536: {
-        const v = tv.value;
-        return v.enum != null ? v.value != null ? `${display(v.value)} as ${v.enum.fullName.slice(2)}` : v.enum.fullName.slice(2) : v.value != null ? `enum<${display(v.value)}>` : `enum`;
+function couldBeShallow(a, b) {
+  return couldBeHelper(a, b, true);
+}
+function couldBeValue(pair, shallow) {
+  switch (pair.type) {
+    case 1:
+    case 2:
+    case 4:
+    case 262144:
+      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+    case 256:
+    case 128:
+    case 131072:
+      return pair.avalue === pair.bvalue;
+    case 512: {
+      if (shallow)
+        return true;
+      let result = false;
+      tupleForEach(
+        pair.avalue,
+        (av) => {
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              result = av.length === bv.length && bv.every((b, i) => couldBe(av[i], b));
+              return result === false;
+            },
+            (bv) => {
+              result = av.every((a) => couldBe(a, bv));
+              return result === false;
+            }
+          );
+          return result === false;
+        },
+        (av) => {
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              result = bv.every((b) => couldBe(av, b));
+              return result === false;
+            },
+            (bv) => (result = couldBe(av, bv)) === false
+          );
+          return result === false;
+        }
+      );
+      return result;
+    }
+    case 1024: {
+      if (shallow)
+        return true;
+      if (!pair.avalue.value || !pair.bvalue.value) {
+        return true;
       }
-      case 131072:
-        return `:${tv.value}`;
-      default:
-        unhandledType(tv);
+      return couldBe(pair.avalue.key, pair.bvalue.key) && couldBe(pair.avalue.value, pair.bvalue.value);
     }
-  };
-  let bits = type.type;
-  if (!bits)
-    return "Never";
-  if (bits === 524287 && type.value == null) {
-    return "Any";
-  }
-  while (bits) {
-    const next = bits & bits - 1;
-    const bit = bits - next;
-    if (bit === 2 && next & 4) {
-      parts.push("Boolean");
-      bits = next - 4;
-      continue;
+    case 2048: {
+      return pair.avalue.args.length === pair.bvalue.args.length && couldBe(pair.avalue.result, pair.bvalue.result) && pair.avalue.args.every((arg, i) => couldBe(arg, pair.bvalue.args[i]));
+    }
+    case 4096:
+    case 8192: {
+      return (0, import_chunk_X7QCZR3F.some)(
+        pair.avalue,
+        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => sna === snb)
+      );
+    }
+    case 16384: {
+      return (0, import_chunk_X7QCZR3F.some)(pair.avalue, (sna) => {
+        const superA = getSuperClasses(sna);
+        return (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => {
+          if (sna === snb || superA && superA.has(snb)) {
+            return true;
+          }
+          const superB = getSuperClasses(snb);
+          return superB ? superB.has(sna) : false;
+        });
+      });
     }
-    const name = typeTagName(bit);
-    const value2 = getUnionComponent(type, bit);
-    const valueStr = value2 != null && displayOne({ type: bit, value: value2 });
-    if (!valueStr) {
-      parts.push(name);
-    } else if (bit & (32768 | 65536 | 262144 | 131072 | 2048 | 256 | 512 | 1024)) {
-      parts.push(valueStr);
-    } else {
-      parts.push(`${name}<${valueStr}${valueStr.endsWith(">") ? " " : ""}>`);
+    case 32768: {
+      return couldBe(pair.avalue.klass, pair.bvalue.klass) && (shallow || couldBeObj(pair.avalue.obj, pair.bvalue.obj));
     }
-    bits = next;
+    case 65536: {
+      return (!pair.avalue.value || !pair.bvalue.value || couldBe(pair.avalue.value, pair.bvalue.value)) && (0, import_chunk_X7QCZR3F.some)(
+        pair.avalue.enum,
+        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue.enum, (snb) => sna === snb)
+      );
+    }
+    default:
+      unhandledType(pair);
   }
-  return parts.join(" or ");
 }
-function hasUnionData(tag) {
-  tag &= UnionDataTypeTagsConst;
-  return (tag & tag - 1) !== 0;
+function couldBeObj(a, b) {
+  if (!a || !b)
+    return true;
+  return Object.entries(a).every(([key, value2]) => {
+    if (!(0, import_chunk_JDC43A3I.hasProperty)(b, key))
+      return true;
+    return couldBe(value2, b[key]);
+  });
 }
-function getObjectValue(t) {
-  if (!(t.type & 32768) || t.value == null)
-    return null;
-  if (hasUnionData(t.type)) {
-    return t.value[
-      32768
-      /* Object */
-    ];
+var init_could_be = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/could-be.ts"() {
+    "use strict";
+    init_api();
+    init_data_flow();
+    (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
+    init_types();
   }
-  return t.value;
-}
-function forEachUnionComponent(v, bits, fn) {
-  bits &= ~SingletonTypeTagsConst;
-  if (!bits)
-    return;
-  if ((v.type | bits) & UnionDataTypeTagsConst) {
-    bits &= ~ValueTypeTagsConst;
-  } else if (bits & bits - 1) {
-    return;
+});
+function subtypeOf(a, b) {
+  if (a.type & 262144 && a.value != null) {
+    return subtypeOf(expandTypedef(a), b);
   }
-  const hasUnion = hasUnionData(v.type);
-  const unionData = v.value;
-  do {
-    const next = bits & bits - 1;
-    const bit = bits - next;
-    const data = hasUnion ? unionData[bit] : bit & v.type ? v.value : null;
-    if (fn({ type: bit, value: data }) === false)
-      break;
-    bits = next;
-  } while (bits);
-}
-function getUnionComponent(v, tag) {
-  if (v.value == null)
-    return null;
-  let bits = v.type & ~SingletonTypeTagsConst;
-  if (!bits)
-    return null;
-  if (bits & bits - 1) {
-    bits &= UnionDataTypeTagsConst;
-    if (!bits) {
-      throw new Error(`Non-exact type had no union bits set`);
-    }
+  if (b.type & 262144 && b.value != null) {
+    return subtypeOf(a, expandTypedef(b));
   }
-  if (bits === tag) {
-    return v.value;
-  } else if (bits & tag) {
-    const unionData = v.value;
-    return unionData[tag] || null;
+  if (a.type & 65536 && !(b.type & 65536) && b.type & EnumTagsConst) {
+    const value2 = getUnionComponent(
+      a,
+      65536
+      /* Enum */
+    );
+    if (!subtypeOf(typeFromEnumValue(value2), b)) {
+      return false;
+    }
+    if (a.type === 65536)
+      return true;
+    const a2 = cloneType(a);
+    clearValuesUnder(a2, 65536, true);
+    return subtypeOf(a2, b);
   }
-  return null;
-}
-function setUnionComponent(v, tag, c) {
-  if (hasUnionData(v.type)) {
-    const value2 = v.value ? { ...v.value } : { mask: 0 };
-    value2[tag] = c;
-    value2.mask |= tag;
-    v.value = value2;
-  } else {
-    v.value = c;
+  let common = a.type & b.type;
+  if (common !== a.type) {
+    if (b.type & 32768 && getObjectValue(b) == null) {
+      common |= a.type & ObjectLikeTagsConst;
+    }
+    if (common !== a.type)
+      return false;
   }
+  if (b.value == null)
+    return true;
+  let result = true;
+  forEachUnionComponent(b, common, (bc) => {
+    const avalue = getUnionComponent(a, bc.type);
+    if (bc.value == null || avalue === bc.value)
+      return true;
+    if (avalue == null || !subtypeOfValue({ type: bc.type, avalue, bvalue: bc.value })) {
+      result = false;
+      return false;
+    }
+    return true;
+  });
+  return result;
 }
-function getStateNodeDeclsFromType(state, object) {
-  return getStateNodeDeclsWithExactFromType(state, object).map(({ sn }) => sn);
-}
-function getStateNodeDeclsWithExactFromType(state, object) {
-  const decls = [];
-  if (object.value != null && object.type & (4096 | 16384 | 32768)) {
-    forEachUnionComponent(
-      object,
-      object.type & (4096 | 16384 | 32768),
-      (type) => {
-        if (type.value == null)
-          return;
-        switch (type.type) {
-          case 32768:
-            if (type.value.klass.type === 16384 && type.value.klass.value) {
-              (0, import_chunk_X7QCZR3F.forEach)(
-                type.value.klass.value,
-                (sn) => decls.push({ sn, exact: false })
-              );
-            }
-            break;
-          case 4096:
-          case 16384:
-            (0, import_chunk_X7QCZR3F.forEach)(type.value, (sn) => decls.push({ sn, exact: true }));
-            break;
+function subtypeOfValue(pair) {
+  switch (pair.type) {
+    case 1:
+    case 2:
+    case 4:
+    case 262144:
+      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+    case 256:
+    case 128:
+    case 131072:
+      return pair.avalue === pair.bvalue;
+    case 512: {
+      let result = true;
+      tupleForEach(
+        pair.avalue,
+        (av) => {
+          let some2 = false;
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              some2 = av.length === bv.length && bv.every((b, i) => subtypeOf(av[i], b));
+              return some2 === false;
+            },
+            (bv) => (some2 = av.every((a) => subtypeOf(a, bv))) === false
+          );
+          return result = some2;
+        },
+        (av) => {
+          let some2 = false;
+          tupleForEach(
+            pair.bvalue,
+            () => {
+              return true;
+            },
+            (bv) => (some2 = subtypeOf(av, bv)) === false
+          );
+          return result = some2;
+        }
+      );
+      return result;
+    }
+    case 1024: {
+      const adict = pair.avalue;
+      const bdict = pair.bvalue;
+      if (!adict.value) {
+        if (!bdict.value) {
+          return Array.from(adict).every(([key, av]) => {
+            const bv = bdict.get(key);
+            return !bv || subtypeOf(av, bv);
+          });
+        }
+        return false;
+      }
+      if (!bdict.value) {
+        return Array.from(bdict).every(([key, bv]) => {
+          const kt = typeFromObjectLiteralKey(key);
+          return !couldBe(kt, adict.key) || subtypeOf(adict.value, bv);
+        });
+      }
+      return subtypeOf(adict.key, bdict.key) && subtypeOf(adict.value, bdict.value);
+    }
+    case 2048: {
+      return pair.avalue.args.length === pair.bvalue.args.length && subtypeOf(pair.avalue.result, pair.bvalue.result) && pair.avalue.args.every((arg, i) => subtypeOf(pair.bvalue.args[i], arg));
+    }
+    case 4096:
+    case 8192: {
+      const asd = pair.avalue;
+      const bsd = pair.bvalue;
+      return (0, import_chunk_X7QCZR3F.every)(asd, (sna) => (0, import_chunk_X7QCZR3F.some)(bsd, (snb) => sna === snb));
+    }
+    case 16384: {
+      const asd = pair.avalue;
+      const bsd = pair.bvalue;
+      return (0, import_chunk_X7QCZR3F.every)(asd, (sna) => {
+        const superA = getSuperClasses(sna);
+        return (0, import_chunk_X7QCZR3F.some)(bsd, (snb) => {
+          if (sna === snb || superA && superA.has(snb)) {
+            return true;
+          }
+          return false;
+        });
+      });
+    }
+    case 32768: {
+      const aobj = pair.avalue;
+      const bobj = pair.bvalue;
+      return subtypeOf(aobj.klass, bobj.klass) && subtypeOfObj(aobj.obj, bobj.obj);
+    }
+    case 65536: {
+      const aenum = pair.avalue;
+      const benum = pair.bvalue;
+      if (benum.value) {
+        if (!aenum.value || !subtypeOf(aenum.value, benum.value)) {
+          return false;
         }
       }
-    );
-  }
-  let bits = object.type & (ObjectLikeTagsConst | 32768);
-  if (bits & 32768 && getObjectValue(object)) {
-    bits -= 32768;
-  }
-  if (bits) {
-    do {
-      let next = bits & bits - 1;
-      let bit = bits - next;
-      if (bit & 6) {
-        bit = 6;
-        next &= ~6;
-      }
-      const name = `Toybox.Lang.${typeTagName(bit)}`;
-      const sns = lookupByFullName(state, name);
-      sns.forEach((sn) => isStateNode(sn) && decls.push({ sn, exact: true }));
-      bits = next;
-    } while (bits);
+      return (0, import_chunk_X7QCZR3F.every)(aenum.enum, (ea) => (0, import_chunk_X7QCZR3F.some)(benum.enum, (eb) => ea === eb));
+    }
+    default:
+      unhandledType(pair);
   }
-  return decls;
 }
+function subtypeOfObj(a, b) {
+  if (!a || !b)
+    return true;
+  return Object.entries(b).every(([key, value2]) => {
+    if (!(0, import_chunk_JDC43A3I.hasProperty)(a, key))
+      return false;
+    return subtypeOf(a[key], value2);
+  });
+}
+var init_sub_type = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/sub-type.ts"() {
+    "use strict";
+    init_api();
+    init_data_flow();
+    (0, import_chunk_X7QCZR3F.init_util)();
+    init_array_type();
+    init_could_be();
+    init_intersection_type();
+    init_types();
+    init_union_type();
+  }
+});
 function tupleForEach(t, tupleFn, arrayFn) {
   if (t instanceof Set) {
     for (const v of t) {
@@ -12369,6 +12790,11 @@ function reducedArrayType(t) {
   }
   return reducedType(t);
 }
+function restrictArrayData(constraint, tracked) {
+  const trackedType = { type: 512, value: tracked };
+  const result = (constraint instanceof Set ? Array.from(constraint) : [constraint]).filter((value2) => couldBe({ type: 512, value: value2 }, trackedType));
+  return result.length === 0 ? constraint : result.length === 1 ? result[0] : new Set(result);
+}
 function checkArrayCovariance(arg, param) {
   let ok = true;
   tupleForEach(
@@ -12414,205 +12840,12 @@ function checkArrayCovariance(arg, param) {
 function safeReferenceArg(arg) {
   return arg.type === "ArrayExpression" || arg.type === "ObjectExpression" || arg.type === "NewExpression";
 }
-var LastTypeTag, SingletonTypeTagsConst, UnionDataTypeTagsConst, ValueTypeTagsConst, ObjectLikeTagsConst, EnumTagsConst, TruthyTypes;
-var init_types = (0, import_chunk_ABYVSU2C.__esm)({
-  "src/type-flow/types.ts"() {
+var init_array_type = (0, import_chunk_ABYVSU2C.__esm)({
+  "src/type-flow/array-type.ts"() {
     "use strict";
-    init_api();
-    (0, import_chunk_JDC43A3I.init_ast)();
-    init_data_flow();
-    (0, import_chunk_X7QCZR3F.init_util)();
-    init_interp();
-    init_intersection_type();
-    init_union_type();
     init_sub_type();
-    LastTypeTag = 262144;
-    SingletonTypeTagsConst = 1 | 2 | 4;
-    UnionDataTypeTagsConst = 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768 | 65536 | 262144;
-    ValueTypeTagsConst = 8 | 16 | 32 | 64 | 128 | 256 | 131072;
-    ObjectLikeTagsConst = 6 | ValueTypeTagsConst | 512 | 1024 | 2048 | 65536;
-    EnumTagsConst = SingletonTypeTagsConst | ValueTypeTagsConst & ~131072;
-    TruthyTypes = 4 | // TypeTag.Object | // omit because of missing null on various Toybox types
-    4096 | 16384 | 8192;
-  }
-});
-function couldBeHelper(a, b, shallow) {
-  const common = a.type & b.type & ~262144;
-  if (common) {
-    if (a.value == null || b.value == null || a.value === b.value) {
-      return true;
-    }
-    if (common & SingletonTypeTagsConst) {
-      return true;
-    }
-    if (common & ValueTypeTagsConst && common & UnionDataTypeTagsConst) {
-      return true;
-    }
-    let result = false;
-    forEachUnionComponent(a, common, (ac) => {
-      if (ac.value == null) {
-        result = true;
-        return false;
-      }
-      const bvalue = getUnionComponent(b, ac.type);
-      if (bvalue == null || ac.value === bvalue || couldBeValue(
-        { type: ac.type, avalue: ac.value, bvalue },
-        shallow
-      )) {
-        result = true;
-        return false;
-      }
-      return true;
-    });
-    if (result)
-      return true;
-  }
-  if (a.type & 65536 && b.type & (EnumTagsConst | 65536) || b.type & 65536 && a.type & (EnumTagsConst | 65536)) {
-    return true;
-  }
-  if (a.type & 32768 && b.type & ObjectLikeTagsConst && getObjectValue(a) == null) {
-    return true;
-  }
-  if (b.type & 32768 && a.type & ObjectLikeTagsConst && getObjectValue(b) == null) {
-    return true;
-  }
-  const checkTypedef = (t, other) => {
-    const typedef = getUnionComponent(
-      t,
-      262144
-      /* Typedef */
-    );
-    return typedef && (0, import_chunk_X7QCZR3F.some)(typedef, (td) => {
-      if (!td.resolvedType) {
-        throw new Error(`No resolved type for ${td.fullName} in 'couldBe'`);
-      }
-      return couldBe(td.resolvedType, other);
-    });
-  };
-  if (a.type & 262144 && checkTypedef(a, b)) {
-    return true;
-  }
-  if (b.type & 262144 && checkTypedef(b, a)) {
-    return true;
-  }
-  return false;
-}
-function couldBe(a, b) {
-  return couldBeHelper(a, b, false);
-}
-function couldBeWeak(a, b) {
-  if (a.type === 0 || b.type === 0)
-    return true;
-  return couldBe(a, b);
-}
-function couldBeShallow(a, b) {
-  return couldBeHelper(a, b, true);
-}
-function couldBeValue(pair, shallow) {
-  switch (pair.type) {
-    case 1:
-    case 2:
-    case 4:
-    case 262144:
-      throw new Error(`Unexpected TypeTag '${typeTagName(pair.type)}'`);
-    case 8:
-    case 16:
-    case 32:
-    case 64:
-    case 256:
-    case 128:
-    case 131072:
-      return pair.avalue === pair.bvalue;
-    case 512: {
-      if (shallow)
-        return true;
-      let result = false;
-      tupleForEach(
-        pair.avalue,
-        (av) => {
-          tupleForEach(
-            pair.bvalue,
-            (bv) => {
-              result = av.length === bv.length && bv.every((b, i) => couldBe(av[i], b));
-              return result === false;
-            },
-            (bv) => {
-              result = av.every((a) => couldBe(a, bv));
-              return result === false;
-            }
-          );
-          return result === false;
-        },
-        (av) => {
-          tupleForEach(
-            pair.bvalue,
-            (bv) => {
-              result = bv.every((b) => couldBe(av, b));
-              return result === false;
-            },
-            (bv) => (result = couldBe(av, bv)) === false
-          );
-          return result === false;
-        }
-      );
-      return result;
-    }
-    case 1024: {
-      if (shallow)
-        return true;
-      if (!pair.avalue.value || !pair.bvalue.value) {
-        return true;
-      }
-      return couldBe(pair.avalue.key, pair.bvalue.key) && couldBe(pair.avalue.value, pair.bvalue.value);
-    }
-    case 2048: {
-      return pair.avalue.args.length === pair.bvalue.args.length && couldBe(pair.avalue.result, pair.bvalue.result) && pair.avalue.args.every((arg, i) => couldBe(arg, pair.bvalue.args[i]));
-    }
-    case 4096:
-    case 8192: {
-      return (0, import_chunk_X7QCZR3F.some)(
-        pair.avalue,
-        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => sna === snb)
-      );
-    }
-    case 16384: {
-      return (0, import_chunk_X7QCZR3F.some)(pair.avalue, (sna) => {
-        const superA = getSuperClasses(sna);
-        return (0, import_chunk_X7QCZR3F.some)(pair.bvalue, (snb) => {
-          if (sna === snb || superA && superA.has(snb)) {
-            return true;
-          }
-          const superB = getSuperClasses(snb);
-          return superB ? superB.has(sna) : false;
-        });
-      });
-    }
-    case 32768: {
-      return couldBe(pair.avalue.klass, pair.bvalue.klass) && (shallow || couldBeObj(pair.avalue.obj, pair.bvalue.obj));
-    }
-    case 65536: {
-      return pair.avalue.enum === pair.bvalue.enum && (!pair.avalue.value || !pair.bvalue.value || couldBe(pair.avalue.value, pair.bvalue.value));
-    }
-    default:
-      unhandledType(pair);
-  }
-}
-function couldBeObj(a, b) {
-  if (!a || !b)
-    return true;
-  return Object.entries(a).every(([key, value2]) => {
-    if (!(0, import_chunk_JDC43A3I.hasProperty)(b, key))
-      return true;
-    return couldBe(value2, b[key]);
-  });
-}
-var init_could_be = (0, import_chunk_ABYVSU2C.__esm)({
-  "src/type-flow/could-be.ts"() {
-    "use strict";
-    init_api();
-    init_data_flow();
-    (0, import_chunk_X7QCZR3F.init_util)();
     init_types();
+    init_could_be();
   }
 });
 function cloneAnt(antMap) {
@@ -13825,7 +14058,8 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
         istate,
         callee,
         calleeObj,
-        () => node.arguments.map((arg) => evaluateExpr(state, arg, typeMap).value)
+        () => node.arguments.map((arg) => evaluateExpr(state, arg, typeMap).value),
+        node
       );
       if (!result.effectFree) {
         effectFree = false;
@@ -14990,6 +15224,7 @@ var init_type_flow = (0, import_chunk_ABYVSU2C.__esm)({
     init_function_info();
     init_inliner();
     init_optimizer_types();
+    init_array_type();
     init_could_be();
     init_dead_store();
     init_interp();
@@ -17182,6 +17417,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config, allowParseError
     allClasses: [],
     nestedClasses: {},
     allModules: /* @__PURE__ */ new Set(),
+    allCached: /* @__PURE__ */ new Set(),
     shouldExclude(node) {
       if ("attrs" in node && node.attrs && "attributes" in node.attrs && node.attrs.attributes && node.loc?.source) {
         const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
@@ -17873,8 +18109,9 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
             if (ret === false) {
               changes |= 1;
               this.removeNodeComments(node, f.ast);
+              clearDiagnostics(this, node);
             } else if (ret) {
-              if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration" && ret.ts.argument.ts.length > 1) {
+              if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration") {
                 changes |= 2;
               } else {
                 changes |= 1;
@@ -17883,6 +18120,9 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
             return ret;
           };
           collectNamespaces(f.ast, state2);
+          if (changes & 2) {
+            state2.allCached?.forEach((t) => delete t.resolvedType);
+          }
           return changes;
         },
         0
@@ -18074,14 +18314,10 @@ function cleanup(state, node, ast, usedNodes) {
           (d) => d.type === "EnumDeclaration" && d.node === node
         );
         if (i >= 0) {
-          const old = decls[i];
-          const rep = {
-            ...old,
-            type: "TypedefDeclaration",
-            node: typedefDecl
-          };
+          const rep = decls[i];
+          rep.type = "TypedefDeclaration";
+          rep.node = typedefDecl;
           delete rep.resolvedType;
-          decls.splice(i, 1, rep);
         }
       }
       return typedefDecl;
@@ -18541,8 +18777,11 @@ function visit_resource_refs(state, doc, e, barrelNames) {
             loc.start.offset -= name.length;
           }
         } else {
-          const base = (0, import_chunk_JDC43A3I.makeScopedName)(`Rez.Styles`);
-          const idLoc = (0, import_chunk_JDC43A3I.adjustLoc)(loc, 0, 0);
+          const colonPos = name.indexOf(":");
+          const barrel = colonPos < 0 ? "" : name.slice(0, colonPos) + ".";
+          name = name.slice(colonPos + 1);
+          const base = (0, import_chunk_JDC43A3I.makeScopedName)(`${barrel}Rez.Styles`);
+          const idLoc = (0, import_chunk_JDC43A3I.adjustLoc)(loc, colonPos + 1, 0);
           idLoc.end = { ...idLoc.start };
           idLoc.end.column += name.length;
           idLoc.end.offset += name.length;
@@ -19824,6 +20063,7 @@ function stateFuncs() {
                 if (decl.type === "EnumDeclaration") {
                   currentEnum = decl;
                 }
+                this.allCached?.add(decl);
                 break;
               }
               case "VariableDeclaration": {
@@ -19842,19 +20082,21 @@ function stateFuncs() {
                     return;
                   }
                   decl.kind = node.kind;
-                  decls[name].push({
+                  const vsn = {
                     type: "VariableDeclarator",
                     node: decl,
                     name,
                     fullName: parent.fullName + "." + name,
                     stack,
                     attributes: stateNodeAttrs(node.attrs)
-                  });
+                  };
+                  decls[name].push(vsn);
                   if (node.kind === "const") {
                     if (!(0, import_chunk_JDC43A3I.hasProperty)(this.index, name)) {
                       this.index[name] = [];
                     }
                     (0, import_chunk_X7QCZR3F.pushUnique)(this.index[name], parent);
+                    this.allCached?.add(vsn);
                   }
                 });
                 break;
@@ -20384,6 +20626,20 @@ function resolveDiagnosticsMap(diagnosticsMap) {
     )
   ).then(() => diagnosticsMap);
 }
+function clearDiagnostics(state, node) {
+  const loc = node.loc;
+  if (!loc?.source)
+    return;
+  const diagnostics = state.diagnostics?.[loc.source];
+  if (!diagnostics)
+    return;
+  for (let i = diagnostics.length; i--; ) {
+    const diagnostic2 = diagnostics[i];
+    if (diagnostic2.loc.start.offset >= loc.start.offset && diagnostic2.loc.end.offset <= loc.end.offset) {
+      diagnostics.splice(i, 1);
+    }
+  }
+}
 function diagnostic(state, node, message, type = "INFO", extra) {
   if (!state.diagnostics)
     state.diagnostics = {};
@@ -30406,7 +30662,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_X7QCZR3F.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1732486572981 < opt_time) {
+      if (source_time < opt_time && 1733273606476 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -30444,7 +30700,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.82",
+            optimizerVersion: "1.1.84",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -31275,6 +31531,7 @@ var init_sdk_util = (0, import_chunk_ABYVSU2C.__esm)({
   buildConfigDescription,
   buildOptimizedProject,
   checkCompilerVersion,
+  clearDiagnostics,
   collectNamespaces,
   connectiq,
   couldBe,