@markw65/monkeyc-optimizer 1.1.33 → 1.1.34

package/build/src/src/projects.d.ts

@@ -0,0 +1,26 @@
+import { BuildConfig } from "./optimizer-types";
+export type RemoteProject = string | {
+    root: string;
+    options?: BuildConfig;
+    rename?: {
+        from: string;
+        to: string;
+    }[];
+    build?: boolean;
+    comment?: string;
+    exclude?: string;
+    include?: string;
+    sourcePath?: string;
+    jungleContent?: string[];
+    garminOptLevel?: number;
+    test?: boolean | string[];
+    branch?: string;
+};
+export declare const githubProjects: RemoteProject[];
+export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean, skipRemote: boolean): Promise<(string | {
+    jungle: string;
+    build: boolean | null;
+    options: BuildConfig | null;
+    garminOptLevel: number | null;
+    products: string[] | null;
+})[]>;

package/build/src/src/readprg/array-init.d.ts

@@ -0,0 +1,3 @@
+import { Block, Context, FuncEntry } from "./bytecode";
+import { InterpState } from "./interp";
+export declare function optimizeArrayInit(func: FuncEntry, block: Block, index: number, context: Context, interpState: InterpState | null): boolean;

package/build/src/src/readprg/bytecode.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { BuildConfig } from "../optimizer-types";
+import { xmlUtil } from "../sdk-util";
+import { ExceptionEntry, ExceptionsMap } from "./exceptions";
+import { Header } from "./header";
+import { LineNumber } from "./linenum";
+import { Bytecode, Opcodes } from "./opcodes";
+import { SymbolTable } from "./symbols";
+export declare const enum SectionKinds {
+    HEADER = -805253120,
+    TEXT = -1059145026,
+    DATA = -629491010,
+    SYMBOLS = 1461170197,
+    LINENUM = -1059161423,
+    EXCEPTIONS = 248410373,
+    SIGNATURE = -507453934,
+    STORE_SIG = 20833
+}
+export type SectionInfo = {
+    offset: number;
+    length: number;
+    view: DataView;
+};
+export type Logger = (module: string, level: number, message: string) => void;
+export type Context = {
+    config: BuildConfig;
+    filepath: string;
+    sections: Record<number, SectionInfo>;
+    header: Header;
+    symbolTable: SymbolTable;
+    lineTable: Map<number, LineNumber>;
+    exceptionsMap: ExceptionsMap;
+    bytecodes: Bytecode[];
+    key?: crypto.KeyObject;
+    debugXml: xmlUtil.Document;
+    nextOffset: number;
+    nextLocalId: number;
+};
+export type Block = {
+    offset: number;
+    bytecodes: Bytecode[];
+    try?: ExceptionEntry[];
+    next?: number;
+    taken?: number;
+    exsucc?: number;
+    preds?: Set<number>;
+};
+export type FuncEntry = {
+    name?: string;
+    offset: number;
+    argc?: number;
+    blocks: Map<number, Block>;
+};
+export declare function offsetToString(offset: number): string;
+export declare function fixSectionSize(section: SectionKinds, sections: Context["sections"], newSize: number): void;
+export declare function optimizeBytecode(context: Context): void;
+export declare function functionBanner(func: FuncEntry, context: Context | null, pass: string, extra?: (block: Block, footer: boolean) => string): () => string;
+export declare function printFunction(func: FuncEntry, context: Context | null): void;
+export declare function functionToString(func: FuncEntry, context: Context | null, extra?: (block: Block, footer: boolean) => string): string;
+export declare function blockToString(block: Block, context: Context | null): string;
+export declare function lineInfoToString(lineInfo: LineNumber, context: Context | null): string;
+export declare function bytecodeToString(bytecode: Bytecode, symbolTable: SymbolTable | null | undefined): string;
+export declare function findFunctions({ bytecodes, symbolTable, exceptionsMap, }: Context): Map<number, FuncEntry>;
+export declare function makeArgless(bc: Bytecode, op: Opcodes): void;
+export declare function equalBlocks(b1: Block, b2: Block): boolean;
+export declare function removeBlock(func: FuncEntry, offset: number): void;
+export declare function removePred(func: FuncEntry, target: number, pred: number): void;
+export declare function addPred(func: FuncEntry, target: number, pred: number): void;
+export declare function redirect(func: FuncEntry, block: Block, from: number, to: number | null | undefined): boolean;
+export declare function splitBlock(func: FuncEntry, block: Block, offset: number): void;
+export declare function countFallthroughPreds(func: FuncEntry, block: Block): number;

package/build/src/src/readprg/cflow.d.ts

@@ -0,0 +1,17 @@
+import { Block, FuncEntry } from "./bytecode";
+import { Bytecode } from "./opcodes";
+export declare function postOrderTraverse(func: FuncEntry, visitor: (block: Block) => void): void;
+export declare function intersect<T>(a: Set<T>, b: Set<T>): Set<T>;
+export type DomLike = Map<number, Set<number>>;
+export declare function computePostDominators(func: FuncEntry): DomLike;
+export declare function computeDominators(func: FuncEntry): DomLike;
+export declare function postOrderPropagate<T>(func: FuncEntry, preBlock: (block: Block) => T, processBc: (block: Block, bc: Bytecode, state: T) => void, postBlock: (block: Block, state: T) => void, merge: (state: T, predBlock: Block, isExPred: boolean) => boolean): void;
+export declare const enum RpoFlags {
+    Nothing = 0,
+    EnqueueTaken = 1,
+    EnqueueNext = 2,
+    SkipTaken = 4,
+    SkipNext = 8,
+    RestartBlock = 16
+}
+export declare function rpoPropagate<T>(func: FuncEntry, preBlock: (block: Block) => T, processBc: ((block: Block, bc: Bytecode, state: T) => RpoFlags | null | undefined | void) | null, postBlock: (block: Block, state: T) => void, merge: (from: Block, state: T, succBlock: Block, isExSucc: boolean) => boolean): void;

package/build/src/src/readprg/data.d.ts

@@ -0,0 +1,4 @@
+import { Context } from "./bytecode";
+import { SymbolTable } from "./symbols";
+export declare function parseData(view: DataView, symbols: SymbolTable): void;
+export declare function fixupData(context: Context, offsetMap: Map<number, number>): void;

package/build/src/src/readprg/dce.d.ts

@@ -0,0 +1,6 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function localDCE(func: FuncEntry, context: Context): boolean;
+export declare function computeLiveLocals(func: FuncEntry): {
+    liveInLocals: Map<number, Set<number>>;
+    liveOutLocals: Map<number, Set<number>>;
+};

package/build/src/src/readprg/emit.d.ts

@@ -0,0 +1,23 @@
+import { Context, FuncEntry } from "./bytecode";
+import { ExceptionsMap } from "./exceptions";
+import { LineNumber } from "./linenum";
+type LocalXmlInfo = {
+    name: string;
+    startPc: number;
+    endPc: number;
+    isParam: boolean;
+    slot: number;
+    id: number;
+};
+export type LocalsMap = Map<number, {
+    startPc: number;
+    endPc: number;
+}>;
+export type UpdateInfo = {
+    offsetMap: Map<number, number>;
+    localRanges: LocalXmlInfo[];
+    lineMap: LineNumber[];
+    exceptionsMap: ExceptionsMap;
+};
+export declare function emitFunc(func: FuncEntry, view: DataView, start: number, updateInfo: UpdateInfo, context: Context): number;
+export {};

package/build/src/src/readprg/exceptions.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "./bytecode";
+import { UpdateInfo } from "./emit";
+export type ExceptionEntry = {
+    tryStart: number;
+    tryEnd: number;
+    handler: number;
+};
+export type ExceptionsMap = Map<number, ExceptionEntry[]>;
+export declare function parseExceptions(view: DataView): ExceptionsMap;
+export declare function fixupExceptions(context: Context, updateInfo: UpdateInfo): void;

package/build/src/src/readprg/header.d.ts

@@ -0,0 +1,15 @@
+import { Context } from "./bytecode";
+import { UpdateInfo } from "./emit";
+export type SectionOffset = {
+    data: number;
+    code: number;
+};
+export type Header = {
+    ciqVersion: number;
+    backgroundOffsets: SectionOffset;
+    appLock: boolean;
+    glanceOffsets: SectionOffset;
+    flags: number;
+};
+export declare function parseHeader(view: DataView): Header;
+export declare function fixupHeader(context: Context, updateInfo: UpdateInfo): void;

package/build/src/src/readprg/interp.d.ts

@@ -0,0 +1,21 @@
+import { ExactOrUnion } from "../optimizer";
+import { Context, FuncEntry } from "./bytecode";
+import { Bytecode, Lputv } from "./opcodes";
+interface InterpItemInfo {
+    type: ExactOrUnion;
+    equivs?: Set<number>;
+}
+export type InterpState = {
+    stack: InterpItemInfo[];
+    locals: InterpItemInfo[];
+    loopBlock?: true;
+};
+export declare function cloneState(state: InterpState | null | undefined): InterpState;
+export declare function interpBytecode(bc: Bytecode, localState: InterpState, context: Context): void;
+export declare function interpFunc(func: FuncEntry, context: Context): {
+    liveInState: Map<number, InterpState>;
+    equivSets: Map<Lputv, Set<number>>;
+    changes: number;
+};
+export declare function instForType(type: ExactOrUnion, offset: number): Bytecode | null;
+export {};

package/build/src/src/readprg/linenum.d.ts

@@ -0,0 +1,29 @@
+import { xmlUtil } from "../sdk-util";
+import { Context } from "./bytecode";
+import { UpdateInfo } from "./emit";
+interface BaseLineNumber {
+    pc: number;
+    file?: number | undefined;
+    fileStr?: string | undefined;
+    symbol?: number | undefined;
+    symbolStr?: string | undefined;
+    line: number;
+}
+interface LineNumberSym extends BaseLineNumber {
+    file: number;
+    symbol: number;
+    fileStr?: undefined;
+    symbolStr?: undefined;
+}
+interface LineNumberStr extends BaseLineNumber {
+    file?: undefined;
+    symbol?: undefined;
+    fileStr: string;
+    symbolStr: string;
+    parent?: string | undefined;
+    id: number;
+}
+export type LineNumber = LineNumberStr | LineNumberSym;
+export declare function parseLineNum(view: DataView, debugXml: xmlUtil.Document): Map<number, LineNumber>;
+export declare function fixupLineNum(context: Context, updateInfo: UpdateInfo): void;
+export {};

package/build/src/src/readprg/locals.d.ts

@@ -0,0 +1,3 @@
+import { Context, FuncEntry } from "./bytecode";
+import { Lputv } from "./opcodes";
+export declare function minimizeLocals(func: FuncEntry, equivSets: Map<Lputv, Set<number>>, context: Context): boolean;

package/build/src/src/readprg/opcodes.d.ts

@@ -0,0 +1,279 @@
+import { LineNumber } from "./linenum";
+export declare enum Opcodes {
+    nop = 0,
+    incsp = 1,
+    popv = 2,
+    addv = 3,
+    subv = 4,
+    mulv = 5,
+    divv = 6,
+    andv = 7,
+    orv = 8,
+    modv = 9,
+    shlv = 10,
+    shrv = 11,
+    xorv = 12,
+    getv = 13,
+    putv = 14,
+    invokem = 15,
+    agetv = 16,
+    aputv = 17,
+    lgetv = 18,
+    lputv = 19,
+    newa = 20,
+    newc = 21,
+    return = 22,
+    ret = 23,
+    news = 24,
+    goto = 25,
+    eq = 26,
+    lt = 27,
+    lte = 28,
+    gt = 29,
+    gte = 30,
+    ne = 31,
+    isnull = 32,
+    isa = 33,
+    canhazplz = 34,
+    jsr = 35,
+    ts = 36,
+    ipush = 37,
+    fpush = 38,
+    spush = 39,
+    bt = 40,
+    bf = 41,
+    frpush = 42,
+    bpush = 43,
+    npush = 44,
+    invv = 45,
+    dup = 46,
+    newd = 47,
+    getm = 48,
+    lpush = 49,
+    dpush = 50,
+    throw = 51,
+    cpush = 52,
+    argc = 53,
+    newba = 54
+}
+interface BaseOpcode {
+    op: Opcodes;
+    offset: number;
+    size: number;
+    lineNum?: LineNumber;
+    arg?: unknown;
+}
+export interface Incsp extends BaseOpcode {
+    op: Opcodes.incsp;
+    arg: number;
+}
+export interface Argless extends BaseOpcode {
+    arg?: never;
+}
+export interface ByteArg extends BaseOpcode {
+    arg: number;
+}
+export interface ShortArg extends BaseOpcode {
+    arg: number;
+}
+export interface WordArg extends BaseOpcode {
+    arg: number;
+}
+export interface FloatArg extends BaseOpcode {
+    arg: number;
+}
+export interface LongArg extends BaseOpcode {
+    arg: bigint;
+}
+export interface DoubleArg extends BaseOpcode {
+    arg: number;
+}
+export interface Nop extends Argless {
+    op: Opcodes.nop;
+}
+export interface Popv extends Argless {
+    op: Opcodes.popv;
+}
+export interface Addv extends Argless {
+    op: Opcodes.addv;
+}
+export interface Subv extends Argless {
+    op: Opcodes.subv;
+}
+export interface Mulv extends Argless {
+    op: Opcodes.mulv;
+}
+export interface Divv extends Argless {
+    op: Opcodes.divv;
+}
+export interface Andv extends Argless {
+    op: Opcodes.andv;
+}
+export interface Orv extends Argless {
+    op: Opcodes.orv;
+}
+export interface Modv extends Argless {
+    op: Opcodes.modv;
+}
+export interface Shlv extends ByteArg {
+    op: Opcodes.shlv;
+}
+export interface Shrv extends ByteArg {
+    op: Opcodes.shrv;
+}
+export interface Xorv extends Argless {
+    op: Opcodes.xorv;
+}
+export interface Getv extends Argless {
+    op: Opcodes.getv;
+}
+export interface Putv extends Argless {
+    op: Opcodes.putv;
+}
+export interface Invokem extends ByteArg {
+    op: Opcodes.invokem;
+}
+export interface Agetv extends Argless {
+    op: Opcodes.agetv;
+}
+export interface Aputv extends Argless {
+    op: Opcodes.aputv;
+}
+export type LocalRange = {
+    name: string;
+    id: number;
+    isParam?: true | undefined;
+};
+export interface LocalInst extends ByteArg {
+    range?: LocalRange;
+}
+export interface Lgetv extends LocalInst {
+    op: Opcodes.lgetv;
+}
+export interface Lputv extends LocalInst {
+    op: Opcodes.lputv;
+}
+export interface Newa extends Argless {
+    op: Opcodes.newa;
+}
+export interface Newc extends Argless {
+    op: Opcodes.newc;
+}
+export interface Return extends Argless {
+    op: Opcodes.return;
+}
+export interface Ret extends Argless {
+    op: Opcodes.ret;
+}
+export interface News extends WordArg {
+    op: Opcodes.news;
+}
+export interface Goto extends ShortArg {
+    op: Opcodes.goto;
+}
+export interface Bt extends ShortArg {
+    op: Opcodes.bt;
+}
+export interface Bf extends ShortArg {
+    op: Opcodes.bf;
+}
+export interface Jsr extends ShortArg {
+    op: Opcodes.jsr;
+}
+export interface Eq extends Argless {
+    op: Opcodes.eq;
+}
+export interface Lt extends Argless {
+    op: Opcodes.lt;
+}
+export interface Lte extends Argless {
+    op: Opcodes.lte;
+}
+export interface Gt extends Argless {
+    op: Opcodes.gt;
+}
+export interface Gte extends Argless {
+    op: Opcodes.gte;
+}
+export interface Ne extends Argless {
+    op: Opcodes.ne;
+}
+export interface Isnull extends Argless {
+    op: Opcodes.isnull;
+}
+export interface Isa extends Argless {
+    op: Opcodes.isa;
+}
+export interface Canhazplz extends Argless {
+    op: Opcodes.canhazplz;
+}
+export interface Ts extends Argless {
+    op: Opcodes.ts;
+}
+export interface Ipush extends WordArg {
+    op: Opcodes.ipush;
+}
+export interface Fpush extends FloatArg {
+    op: Opcodes.fpush;
+}
+export interface Spush extends WordArg {
+    op: Opcodes.spush;
+}
+export interface Frpush extends Argless {
+    op: Opcodes.frpush;
+}
+export interface Bpush extends ByteArg {
+    op: Opcodes.bpush;
+}
+export interface Npush extends Argless {
+    op: Opcodes.npush;
+}
+export interface Invv extends Argless {
+    op: Opcodes.invv;
+}
+export interface Dup extends ByteArg {
+    op: Opcodes.dup;
+}
+export interface Newd extends Argless {
+    op: Opcodes.newd;
+}
+export interface Getm extends Argless {
+    op: Opcodes.getm;
+}
+export interface Lpush extends LongArg {
+    op: Opcodes.lpush;
+}
+export interface Dpush extends DoubleArg {
+    op: Opcodes.dpush;
+}
+export interface Throw extends Argless {
+    op: Opcodes.throw;
+}
+export interface Cpush extends WordArg {
+    op: Opcodes.cpush;
+}
+export interface Newba extends Argless {
+    op: Opcodes.newba;
+}
+export interface Argc extends ByteArg {
+    op: Opcodes.argc;
+}
+export type Bytecode = Nop | Incsp | Popv | Addv | Subv | Mulv | Divv | Andv | Orv | Modv | Shlv | Shrv | Xorv | Getv | Putv | Invokem | Agetv | Aputv | Lgetv | Lputv | Newa | Newc | Return | Ret | News | Goto | Eq | Lt | Lte | Gt | Gte | Ne | Isnull | Isa | Canhazplz | Jsr | Ts | Ipush | Fpush | Spush | Bt | Bf | Frpush | Bpush | Npush | Invv | Dup | Newd | Getm | Lpush | Dpush | Throw | Cpush | Argc | Newba;
+export declare function parseCode(view: DataView, lineTable: Map<number, LineNumber>): Bytecode[];
+export declare function opcodeSize(op: Opcodes): 1 | 2 | 3 | 5 | 9;
+export declare function emitBytecode(bytecode: Bytecode, view: DataView, offset: number, linktable: Map<number, number>): number;
+export declare function getOpInfo(bytecode: Bytecode): {
+    pop: number;
+    push: number;
+};
+export declare const enum Effects {
+    None = 0,
+    Local = 1,
+    Global = 2,
+    ArrayLike = 4,
+    Call = 8
+}
+export declare function getOpEffects(bytecode: Bytecode): number;
+export declare function isBoolOp(op: Opcodes): boolean;
+export declare function isCondBranch(op: Opcodes): boolean;
+export {};

package/build/src/src/readprg/optimize.d.ts

@@ -0,0 +1,3 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function optimizeFunc(func: FuncEntry, context: Context): void;
+export declare function cleanCfg(func: FuncEntry, context: Context): void;

package/build/src/src/readprg/pre.d.ts

@@ -0,0 +1,2 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function sizeBasedPRE(func: FuncEntry, context: Context): true | undefined;

package/build/src/src/readprg/sharing.d.ts

@@ -0,0 +1,2 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function blockSharing(func: FuncEntry, context: Context): boolean;

package/build/src/src/readprg/signer.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { Context } from "./bytecode";
+export declare function getPrgSignature(context: Context): Buffer | undefined;
+export declare function getDevKey(file: string): Promise<crypto.KeyObject>;
+export declare function signatureFromContext(context: Context): Buffer | null;
+export declare function signView(key: crypto.KeyObject, view: DataView): Buffer;

package/build/src/src/readprg/symbols.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { xmlUtil } from "../sdk-util";
+export declare class SymbolTable {
+    symbolToLabelMap: Map<number, number>;
+    symbols: Map<number, {
+        str: string;
+        label: string;
+    }>;
+    methods: Map<number, {
+        name: string;
+        id: number | null;
+        argc: number | null;
+    }>;
+    decoder: import("util").TextDecoder;
+    parseSymbolTable(view: DataView): number;
+    parse(view: DataView): void;
+    parseXml(debugXml: xmlUtil.Document): void;
+    parseSymbol(view: DataView, offset: number, current: number): number;
+}

package/build/src/src/readprg.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { BuildConfig } from "./optimizer-types";
+import { SectionInfo } from "./readprg/bytecode";
+export declare function readPrg(path: string): Promise<{
+    [k: string]: number;
+}>;
+export declare function readPrgFromFile(prg: string): Promise<{
+    view: DataView;
+    sections: Record<number, SectionInfo>;
+}>;
+export declare function readPrgWithOffsets(view: DataView): {
+    view: DataView;
+    sections: Record<number, SectionInfo>;
+};
+export declare function optimizeProgram(filepath: string, devKey?: string | undefined, output?: string, config?: BuildConfig): Promise<unknown>;
+export declare function optimizePrgAndDebug(prgName: string, prgBuffer: ArrayBuffer, prgOffset: number, prgLength: number, xmlName: string, xmlBuffer: ArrayBuffer, xmlOffset: number, xmlLength: number, key: crypto.KeyObject, config: BuildConfig | undefined): Promise<{
+    sigBuffer: ArrayBufferLike | undefined;
+    sigOffset: number | undefined;
+    sigLength: number | undefined;
+    prgBuffer: ArrayBufferLike;
+    prgOffset: number;
+    prgLength: number;
+    debugXml: string;
+}>;

package/build/src/src/resources.d.ts

@@ -0,0 +1,12 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { JungleResourceMap } from "./jungles";
+import { ProgramState } from "./optimizer-types";
+import { xmlUtil } from "./sdk-util";
+type Visit = (e: xmlUtil.Element, module: string | null, parent: xmlUtil.Element | null) => void;
+type Visitor = {
+    visit?: Visit;
+    error?: (node: xmlUtil.Element, parent: string | null) => void;
+} & xmlUtil.Visitor;
+export declare function visit_resources(elements: xmlUtil.Content[], parent: xmlUtil.Element | null, v: Visitor | Visit): void;
+export declare function add_resources_to_ast(state: ProgramState | undefined, ast: mctree.Program, resources: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): void;
+export {};

package/build/src/src/sdk-util.d.ts

@@ -0,0 +1,28 @@
+export { readPrg, optimizeProgram, readPrgWithOffsets } from "./readprg";
+export { SectionKinds } from "./readprg/bytecode";
+export * as xmlUtil from "./xml-util";
+export declare const isWin: boolean;
+export declare const appSupport: string;
+export declare const connectiq: string;
+export declare function getSdkPath(): Promise<string>;
+export type DeviceInfo = {
+    [key: string]: {
+        appTypes: {
+            memoryLimit: number;
+            type: string;
+        }[];
+        deviceFamily: string;
+        displayName: string;
+        languages: Record<string, true>;
+    };
+};
+export declare function getDeviceInfo(): Promise<DeviceInfo>;
+export declare function getLanguages(): Promise<{
+    id: string;
+    name: string;
+}[]>;
+export declare function getFunctionDocumentation(): Promise<{
+    name: string;
+    parent: string;
+    doc: string;
+}[] | null>;

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

@@ -0,0 +1,5 @@
+import { ExactOrUnion } from "./types";
+export declare function couldBeHelper(a: ExactOrUnion, b: ExactOrUnion, shallow: boolean): boolean;
+export declare function couldBe(a: ExactOrUnion, b: ExactOrUnion): boolean;
+export declare function couldBeWeak(a: ExactOrUnion, b: ExactOrUnion): boolean;
+export declare function couldBeShallow(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -0,0 +1,18 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { NodeEquivMap } from "../type-flow";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { TypeFlowBlock, TypeStateKey } from "./type-flow-util";
+export type CopyPropStores = Map<mctree.Node, {
+    ref: mctree.Node;
+    ant: boolean;
+}>;
+export declare function findDeadStores(func: FunctionStateNode, graph: TypeFlowBlock, nodeEquivs: NodeEquivMap | null, findCopyPropCandidates: boolean, logThisRun: boolean): {
+    deadStores: Set<mctree.Node>;
+    locals: Set<TypeStateKey>;
+    localConflicts: Map<TypeStateKey, Set<TypeStateKey>> | null;
+    copyPropStores: CopyPropStores;
+};
+export declare function eliminateDeadStores(state: ProgramStateAnalysis, func: FunctionStateNode, graph: TypeFlowBlock, logThisRun: boolean): {
+    changes: boolean;
+    copyPropStores: CopyPropStores;
+};

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

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ExactOrUnion } from "./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;