@markw65/monkeyc-optimizer 1.0.44 → 1.0.45

package/build/sdk-util.cjs

@@ -325,6 +325,64 @@ function getNodeValue(node) {
     }
     throw new Error(`Literal has unknown type '${type}'`);
 }
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    const result = dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
+        }
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+    if (!result)
+        throw new Error("Failed to make a ScopedName");
+    return result;
+}
 
 ;// CONCATENATED MODULE: ./src/xml-util.ts
 

package/build/src/api.d.ts

@@ -1,7 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl } from "./optimizer-types";
+import { FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
 import { visit_resources } from "./resources";
 import { xmlUtil } from "./sdk-util";
 export { visitorNode, visitReferences } from "./visitor";
@@ -22,5 +22,6 @@ export declare function findUsingForNode(state: ProgramStateLive, stack: Program
         results: StateNodeDecl[];
     };
 }[] | null;
-export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo;
+export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo | false;
 export declare function markInvokeClassMethod(func: FunctionStateNode): void;
+export declare function isLocal(v: VariableStateNode): boolean;

package/build/src/ast.d.ts

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

package/build/src/data-flow.d.ts

@@ -0,0 +1,45 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BaseEvent, Block } from "./control-flow";
+import { FunctionStateNode, ProgramStateAnalysis, StateNodeDecl } from "./optimizer-types";
+export declare type RefNode = mctree.Identifier | mctree.MemberExpression | mctree.Literal;
+export declare type EventDecl = StateNodeDecl | StateNodeDecl[] | mctree.Literal;
+export interface RefEvent extends BaseEvent {
+    type: "ref";
+    node: RefNode;
+    decl: EventDecl;
+}
+export interface DefEvent extends BaseEvent {
+    type: "def";
+    node: mctree.AssignmentExpression | mctree.UpdateExpression | mctree.VariableDeclarator;
+    decl: EventDecl;
+}
+export interface ModEvent extends BaseEvent {
+    type: "mod";
+    node: mctree.Node;
+    decl?: EventDecl | undefined | null;
+    before?: boolean;
+    id?: RefNode;
+    callees?: FunctionStateNode[] | null;
+}
+export interface ExnEvent extends BaseEvent {
+    type: "exn";
+    node: mctree.Node;
+}
+export declare type Event = RefEvent | DefEvent | ModEvent | ExnEvent;
+export interface DataFlowBlock extends Block<Event> {
+    order?: number;
+}
+export declare function declFullName(decl: EventDecl): string | undefined;
+export declare function declName(decl: EventDecl): string | undefined;
+export declare function unhandledExpression(node: never): void;
+export declare function buildDataFlowGraph(state: ProgramStateAnalysis, func: FunctionStateNode, wantsLiteral: (literal: mctree.Literal) => boolean, trackInsertionPoints: boolean, wantsAllRefs: boolean): {
+    identifiers: Set<string>;
+    graph: Block<RefEvent | DefEvent | ModEvent | ExnEvent>;
+};
+export declare class DataflowQueue {
+    private enqueued;
+    private queue;
+    enqueue(block: DataFlowBlock): void;
+    dequeue(): DataFlowBlock;
+    empty(): boolean;
+}

package/build/src/function-info.d.ts

@@ -1,3 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { VariableStateNode, FunctionStateNode, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 export declare function cloneSet<T>(ae: Set<T>): Set<T>;
 export declare function mergeSet<T>(a: Set<T>, b: Set<T>): void;
@@ -10,3 +11,4 @@ export declare function recordCalledFuncs(func: FunctionStateNode, callees: Func
 export declare function functionMayModify(state: ProgramStateAnalysis, func: FunctionStateNode, decl: VariableStateNode): boolean;
 export declare function findCallees(lookupDefs: LookupDefinition[]): FunctionStateNode[] | null;
 export declare function findCalleesForNew(lookupDefs: LookupDefinition[]): FunctionStateNode[];
+export declare function findCalleesByNode(state: ProgramStateAnalysis, callee: mctree.Expression): FunctionStateNode[] | null;

package/build/src/interp-binary.d.ts

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ExactOrUnion } from "./mc-types";
+export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
+export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;

package/build/src/interp-call.d.ts

@@ -0,0 +1,3 @@
+import { ExactOrUnion } from "./mc-types";
+import { ProgramStateAnalysis } from "./optimizer-types";
+export declare function evaluateCall(state: ProgramStateAnalysis, callee: ExactOrUnion, _args: ExactOrUnion[]): ExactOrUnion;

package/build/src/interp.d.ts

@@ -0,0 +1,23 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ExactOrUnion } from "./type-flow/types";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
+export declare type InterpStackElem = {
+    value: ExactOrUnion;
+    embeddedEffects: boolean;
+    node: mctree.Expression | mctree.TypeSpecList | mctree.InstanceOfCase;
+};
+export declare type InterpState = {
+    state: ProgramStateAnalysis;
+    stack: InterpStackElem[];
+    typeMap?: TypeMap;
+    func?: FunctionStateNode;
+    pre?: (node: mctree.Node) => mctree.Node | null | void;
+    post?: (node: mctree.Node) => mctree.Node | null | void;
+};
+export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
+export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
+export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
+export declare function roundToFloat(value: number): number;

package/build/src/jungles.d.ts

@@ -1,6 +1,6 @@
 import { ManifestXML } from "./manifest";
 import { BuildConfig } from "./optimizer-types.js";
-import { xmlUtil } from "./sdk-util";
+import { DeviceInfo, xmlUtil } from "./sdk-util";
 export declare type JungleBuildDependencies = Record<string, xmlUtil.Document | true>;
 export declare type JungleError = Error & {
     buildDependencies?: JungleBuildDependencies;
@@ -49,6 +49,7 @@ declare type JungleInfoBase = {
     annotations?: string[];
     resources: JungleResourceMap;
     buildDependencies: JungleBuildDependencies;
+    devices: DeviceInfo;
 };
 export declare type JungleResourceMap = Record<string, xmlUtil.Document>;
 export declare type ResolvedJungle = JungleInfoBase & {

package/build/src/manifest.d.ts

@@ -7,4 +7,5 @@ export declare function manifestBarrels(manifest: ManifestXML): string[];
 export declare function manifestDropBarrels(manifest: ManifestXML): void;
 export declare function manifestBarrelName(manifestName: string, manifest: ManifestXML): string;
 export declare function manifestAnnotations(manifest: ManifestXML): string[] | undefined;
+export declare function manifestLanguages(manifest: ManifestXML): string[] | undefined;
 export declare function checkManifest(manifest: ManifestXML, products: string[]): Promise<boolean>;

package/build/src/mc-types.d.ts

@@ -0,0 +1,166 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl } from "./optimizer-types";
+/**
+ * TypeBit gives the position of the 1 bit in TypeTag
+ */
+export declare enum TypeBit {
+    Null = 0,
+    False = 1,
+    True = 2,
+    Number = 3,
+    Long = 4,
+    Float = 5,
+    Double = 6,
+    Char = 7,
+    String = 8,
+    Array = 9,
+    Dictionary = 10,
+    Module = 11,
+    Function = 12,
+    Class = 13,
+    Object = 14,
+    Enum = 15,
+    Symbol = 16
+}
+export declare enum TypeTag {
+    Never = 0,
+    Null = 1,
+    False = 2,
+    True = 4,
+    Boolean = 6,
+    Number = 8,
+    Long = 16,
+    Float = 32,
+    Double = 64,
+    Numeric = 120,
+    Char = 128,
+    String = 256,
+    Array = 512,
+    Dictionary = 1024,
+    Module = 2048,
+    Function = 4096,
+    Class = 8192,
+    Object = 16384,
+    Enum = 32768,
+    Symbol = 65536,
+    Any = 131071
+}
+declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Function | TypeTag.Symbol;
+export declare type EnumeratedTypeTags = ExactTypeTags | TypeTag.Never | TypeTag.Any;
+export declare type UnionTypeTags = number;
+interface AbstractValue {
+    type: UnionTypeTags;
+    value?: unknown;
+}
+export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType;
+declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
+    value: NonNullable<T["value"]>;
+} : never;
+export declare type ValueTypes = WithValue<ExactTypes>;
+export declare type ExtendedTypes = ExactTypes | NeverType | AnyType;
+export interface NeverType extends AbstractValue {
+    type: 0;
+    value?: undefined;
+}
+export interface NullType extends AbstractValue {
+    type: TypeTag.Null;
+    value?: undefined;
+}
+export interface FalseType extends AbstractValue {
+    type: TypeTag.False;
+    value?: undefined;
+}
+export interface TrueType extends AbstractValue {
+    type: TypeTag.True;
+    value?: undefined;
+}
+export interface NumberType extends AbstractValue {
+    type: TypeTag.Number;
+    value?: number | undefined;
+}
+export interface LongType extends AbstractValue {
+    type: TypeTag.Long;
+    value?: bigint | undefined;
+}
+export interface FloatType extends AbstractValue {
+    type: TypeTag.Float;
+    value?: number | undefined;
+}
+export interface DoubleType extends AbstractValue {
+    type: TypeTag.Double;
+    value?: number | undefined;
+}
+export interface CharType extends AbstractValue {
+    type: TypeTag.Char;
+    value?: string | undefined;
+}
+export interface StringType extends AbstractValue {
+    type: TypeTag.String;
+    value?: string | undefined;
+}
+export interface ArrayType extends AbstractValue {
+    type: TypeTag.Array;
+    value?: ExactOrUnion | undefined;
+}
+export interface DictionaryType extends AbstractValue {
+    type: TypeTag.Dictionary;
+    value?: {
+        key: ExactOrUnion;
+        value: ExactOrUnion;
+    } | undefined;
+}
+export interface ModuleType extends AbstractValue {
+    type: TypeTag.Module;
+    value?: ModuleStateNode | ModuleStateNode[] | undefined;
+}
+export interface FunctionType extends AbstractValue {
+    type: TypeTag.Function;
+    value?: FunctionStateNode | FunctionStateNode[] | undefined;
+}
+export interface ClassType extends AbstractValue {
+    type: TypeTag.Class;
+    value?: ClassStateNode | ClassStateNode[] | undefined;
+}
+export interface ObjectType extends AbstractValue {
+    type: TypeTag.Object;
+    value?: {
+        klass: ClassType;
+        obj?: Record<string, ExactOrUnion>;
+    } | undefined;
+}
+export interface EnumType extends AbstractValue {
+    type: TypeTag.Enum;
+    value?: {
+        enum: EnumStateNode;
+        value?: ExactOrUnion | undefined;
+    } | undefined;
+}
+export interface SymbolType extends AbstractValue {
+    type: TypeTag.Symbol;
+    value?: string | undefined;
+}
+export interface AnyType extends AbstractValue {
+    type: -1;
+    value?: undefined;
+}
+export declare type SingletonType = NullType | FalseType | TrueType;
+export interface UnionType extends AbstractValue {
+    value?: undefined;
+}
+export declare type ExactOrUnion = UnionType | ExactTypes;
+export declare function isExact(v: AbstractValue): v is ExactTypes;
+export declare function isUnion(v: AbstractValue): v is UnionType;
+export declare function isSingleton(v: AbstractValue): v is SingletonType;
+export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
+export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
+export declare function cloneType<T extends ExactOrUnion>(t: T): T;
+export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
+export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;
+export declare function mcExprFromType(type: ValueTypes): mctree.Expression | null;
+export declare function castType(type: ExactOrUnion, target: UnionTypeTags): ExactOrUnion;
+export declare const TruthyTypes: number;
+export declare function mustBeTrue(arg: ExactOrUnion): boolean;
+export declare function mustBeFalse(arg: ExactOrUnion): boolean;
+export declare function display(type: ExactOrUnion): string;
+export {};

package/build/src/optimizer-types.d.ts

@@ -1,4 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { EnumStringMember } from "@markw65/prettier-plugin-monkeyc/build/estree-types";
 import { xmlUtil } from "./sdk-util";
 export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
 export declare type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
@@ -34,7 +35,7 @@ export declare type BuildConfig = {
     extensionVersion?: string;
     useLocalOptimizer?: boolean;
 };
-export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
+export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
 export declare type StateNodeDecls = {
     [key: string]: StateNodeDecl[];
 };
@@ -96,7 +97,7 @@ export interface FunctionStateNode extends BaseStateNode {
     fullName: string;
     stack?: ProgramStateStack;
     decls?: undefined;
-    info?: FunctionInfo;
+    info?: FunctionInfo | false;
     next_info?: FunctionInfo;
 }
 export interface BlockStateNode extends BaseStateNode {
@@ -120,7 +121,14 @@ export interface VariableStateNode extends BaseStateNode {
     stack: ProgramStateStack;
     used?: true;
 }
-export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode;
+export interface EnumStateNode extends BaseStateNode {
+    type: "EnumDeclaration";
+    node: mctree.EnumDeclaration;
+    name: string;
+    fullName: string;
+    stack: ProgramStateStack;
+}
+export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
 export declare type ProgramStateStack = StateNode[];
 export declare type LookupDefinition = {
     parent: StateNode | null;
@@ -180,6 +188,7 @@ export declare type ProgramState = {
         };
         message: string;
     }[]>;
+    enumMap?: Map<EnumStringMember, EnumStateNode>;
 };
 declare type Finalized<T, Keys extends keyof T> = T & {
     [key in Keys]-?: NonNullable<T[key]>;

package/build/src/pre.d.ts

@@ -1,2 +1,2 @@
-import { ProgramStateAnalysis, FunctionStateNode } from "./optimizer-types";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
 export declare function sizeBasedPRE(state: ProgramStateAnalysis, func: FunctionStateNode): void;

package/build/src/projects.d.ts

@@ -13,9 +13,10 @@ export declare type RemoteProject = string | {
     sourcePath?: string;
     jungleContent?: string[];
     garminOptLevel?: number;
+    test?: boolean;
 };
 export declare const githubProjects: RemoteProject[];
-export declare function fetchGitProjects(projects: RemoteProject[]): Promise<(string | {
+export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean): Promise<(string | {
     jungle: string;
     build: boolean | null;
     options: BuildConfig | null;

package/build/src/type-flow.d.ts

@@ -0,0 +1,4 @@
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+import { InterpState } from "./type-flow/interp";
+export declare const missingNullWorkaround = true;
+export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode): InterpState | undefined;

package/build/src/util.d.ts

@@ -5,9 +5,14 @@ export declare function globa(pattern: string, options?: glob.Options & {
 export declare function globSome(pattern: string, predicate: (path: string) => boolean, options?: glob.Options & {
     mark?: boolean;
 }): Promise<boolean>;
+export declare function forEach<T>(val: T | T[] | null | undefined, fn: (v: T) => void): void;
+export declare function map<T, U>(val: T | T[] | null | undefined, fn: (v: T) => U): U[];
+export declare function every<T>(val: T | T[] | null | undefined, fn: (v: T) => void): boolean | void;
+export declare function some<T>(val: T | T[] | null | undefined, fn: (v: T) => void): boolean | void;
+export declare function reduce<T, U>(val: T | T[] | null | undefined, fn: (p: U, v: T) => U, init: U): U;
 export declare function last_modified(inputs: string[]): Promise<number>;
 export declare function first_modified(inputs: string[]): Promise<number>;
-export declare function pushUnique<T, U extends T>(arr: T[], value: U): void;
+export declare function pushUnique<T, U extends T>(arr: T[], value: U): boolean;
 export declare function sameArrays<T>(a1: T[], a2: T[], check: (a: T, b: T) => boolean): boolean;
 export declare type LineHandler = (line: string) => void;
 export declare function spawnByLine(command: string, args: string[], lineHandlers: LineHandler | LineHandler[], options?: {

package/build/util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,first_modified,globSome,globa,last_modified,promiseAll,pushUnique,readByLine,sameArrays,spawnByLine});
+0 && (module.exports = {copyRecursiveAsNeeded,every,first_modified,forEach,globSome,globa,last_modified,map,promiseAll,pushUnique,readByLine,reduce,sameArrays,some,spawnByLine});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -7713,14 +7713,19 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   "copyRecursiveAsNeeded": () => (/* binding */ copyRecursiveAsNeeded),
+  "every": () => (/* binding */ every),
   "first_modified": () => (/* binding */ first_modified),
+  "forEach": () => (/* binding */ forEach),
   "globSome": () => (/* binding */ globSome),
   "globa": () => (/* binding */ globa),
   "last_modified": () => (/* binding */ last_modified),
+  "map": () => (/* binding */ map),
   "promiseAll": () => (/* binding */ promiseAll),
   "pushUnique": () => (/* binding */ pushUnique),
   "readByLine": () => (/* binding */ readByLine),
+  "reduce": () => (/* binding */ reduce),
   "sameArrays": () => (/* binding */ sameArrays),
+  "some": () => (/* binding */ some),
   "spawnByLine": () => (/* binding */ spawnByLine)
 });
 
@@ -7770,6 +7775,56 @@ function globSome(pattern, predicate, options) {
         });
     });
 }
+function forEach(val, fn) {
+    if (!val)
+        return;
+    if (Array.isArray(val)) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+}
+function map(val, fn) {
+    if (!val)
+        return [];
+    if (Array.isArray(val)) {
+        return val.map(fn);
+    }
+    else {
+        return [fn(val)];
+    }
+}
+function every(val, fn) {
+    if (!val)
+        return true;
+    if (Array.isArray(val)) {
+        return val.every(fn);
+    }
+    else {
+        return fn(val);
+    }
+}
+function some(val, fn) {
+    if (!val)
+        return false;
+    if (Array.isArray(val)) {
+        return val.some(fn);
+    }
+    else {
+        return fn(val);
+    }
+}
+function reduce(val, fn, init) {
+    if (!val)
+        return init;
+    if (Array.isArray(val)) {
+        return val.reduce(fn, init);
+    }
+    else {
+        return fn(init, val);
+    }
+}
 async function modified_times(inputs, missing) {
     return Promise.all(inputs.map(async (path) => {
         try {
@@ -7789,8 +7844,9 @@ async function first_modified(inputs) {
 }
 function pushUnique(arr, value) {
     if (arr.find((v) => v === value) != null)
-        return;
+        return false;
     arr.push(value);
+    return true;
 }
 function sameArrays(a1, a2, check) {
     return a1.length === a2.length && a1.every((e, i) => check(e, a2[i]));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.44",
+  "version": "1.0.45",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -21,8 +21,9 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-optimized && npm run test-unopt && npm run test-remote",
+    "test": "npm run test-optimized && npm run test-unopt && npm run test-remote && npm run test-remote-tests",
     "test-remote": "node ./test/test.js --product=pick-one --github",
+    "test-remote-tests": "node ./test/test.js --product=pick-one --run-tests --github",
     "test-optimized": "node test/test.js --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-unopt": "node test/test.js --typeCheckLevel Strict --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-garmin-opt": "node test/test.js --typeCheckLevel Strict --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
@@ -38,7 +39,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.40"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.41"
   },
   "devDependencies": {
     "@types/glob": "^8.0.0",