@markw65/monkeyc-optimizer 1.1.32 → 1.1.34

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;

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

@@ -0,0 +1,16 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { InterpStackElem, InterpState } from "./interp";
+import { ExactOrUnion } from "./types";
+export declare function evaluateCall(istate: InterpState, node: mctree.CallExpression, callee: ExactOrUnion, args: ExactOrUnion[]): InterpStackElem;
+export declare function checkCallArgs(istate: InterpState, node: mctree.CallExpression, callees: FunctionStateNode | FunctionStateNode[], args: ExactOrUnion[]): InterpStackElem;
+type SysCallHelperResult = {
+    calleeObj?: ExactOrUnion;
+    returnType?: ExactOrUnion;
+    argTypes?: ExactOrUnion[];
+    effectFree?: true;
+    argEffects?: true;
+};
+type SysCallHelper = (state: ProgramStateAnalysis, func: FunctionStateNode, calleeObj: ExactOrUnion, getArgs: () => Array<ExactOrUnion>) => SysCallHelperResult;
+export declare function sysCallInfo(state: ProgramStateAnalysis, func: FunctionStateNode): SysCallHelper | null;
+export {};

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

@@ -0,0 +1,33 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { DiagnosticType, FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion, ObjectType } from "./types";
+export type TypeMap = Map<mctree.Node, ExactOrUnion>;
+export type InterpStackElem = {
+    value: ExactOrUnion;
+    embeddedEffects: boolean;
+    node: mctree.Expression | mctree.TypeSpecList | mctree.InstanceOfCase;
+};
+export type InterpState = {
+    state: ProgramStateAnalysis;
+    stack: InterpStackElem[];
+    typeMap?: TypeMap;
+    localLvals?: Set<mctree.Node>;
+    func?: FunctionStateNode;
+    pre?: (node: mctree.Node) => mctree.Node | false | null | void;
+    post?: (node: mctree.Node) => mctree.Node | false | null | void;
+    typeChecker?: (a: ExactOrUnion, b: ExactOrUnion) => boolean;
+    checkTypes?: DiagnosticType;
+};
+export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
+export declare function tryPop(istate: InterpState, node: InterpStackElem["node"]): InterpStackElem;
+export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
+export declare function preEvaluate(istate: InterpState, node: mctree.Node): null | (keyof mctree.NodeAll)[];
+export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
+export declare function evaluateUnaryTypes(op: mctree.UnaryOperator, argument: ExactOrUnion): ExactOrUnion;
+export declare function deEnumerate(t: ExactOrUnion): ExactOrUnion;
+export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
+export declare function roundToFloat(value: number): number;
+export declare function mustBeIdentical(a: ExactOrUnion, b: ExactOrUnion): boolean;
+export declare function isByteArray(object: ExactOrUnion): boolean | undefined;
+export declare function isByteArrayData(objectData: NonNullable<ObjectType["value"]>): boolean | undefined;

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

@@ -0,0 +1,4 @@
+import { ExactOrUnion } from "./types";
+export declare function expandTypedef(t: ExactOrUnion): ExactOrUnion;
+export declare function intersection(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;
+export declare function restrictByEquality(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;

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

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+export declare function minimizeLocals(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function variableCleanup(node: mctree.Node): false | mctree.BlockStatement | mctree.Statement[] | null;

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

@@ -0,0 +1,3 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateAnalysis } from "../optimizer-types";
+export declare function minimizeModules(ast: mctree.Program, state: ProgramStateAnalysis): void;

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

@@ -0,0 +1,7 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { InterpState } from "./interp";
+export declare function optimizeFunction(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function beforeEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;
+export declare function afterEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;
+export declare function tryDeEnumerate(istate: InterpState, node: mctree.Expression, elem: number): mctree.Expression | null;

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

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function subtypeOf(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -0,0 +1,27 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { DataFlowBlock as TypeFlowBlock, Event, EventDecl } from "../data-flow";
+import { ProgramStateAnalysis, StateNode, VariableStateNode } from "../optimizer-types";
+import { InterpState } from "./interp";
+import { ExactOrUnion } from "./types";
+export { TypeFlowBlock };
+export declare function isTypeStateKey(decl: EventDecl): decl is TypeStateKey;
+export declare function declIsLocal(decl: EventDecl): decl is VariableStateNode | VariableStateNode[] | mctree.TypedIdentifier;
+export declare function declIsNonLocal(decl: EventDecl): decl is VariableStateNode | VariableStateNode[];
+export declare function localDeclName(decl: EventDecl): string;
+export type TypeStateKey = Exclude<EventDecl, {
+    type: "MemberDecl" | "Unknown";
+}>;
+export declare function tsKey(key: TypeStateKey): string;
+export declare function sourceLocation(loc: mctree.SourceLocation | null | undefined): string;
+export declare function printBlockHeader(block: TypeFlowBlock): void;
+export declare function describeEvent(event: Event): string;
+export declare function printBlockEvents(block: TypeFlowBlock, extra?: (event: Event) => string): void;
+export declare function printBlockTrailer(block: TypeFlowBlock): void;
+export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): readonly [null, null] | [StateNode[], StateNode[]];
+export declare function refineObjectTypeByDecls(istate: InterpState, object: ExactOrUnion, trueDecls: StateNode[]): ExactOrUnion;
+export declare function findNextObjectType(istate: InterpState, trueDecls: StateNode[], next: mctree.DottedMemberExpression): import("./types").UnionType | import("./types").NumberType | import("./types").LongType | import("./types").FloatType | import("./types").DoubleType | import("./types").CharType | import("./types").StringType | import("./types").ArrayType | import("./types").DictionaryType | import("./types").MethodType | import("./types").ModuleType | import("./types").FunctionType | import("./types").ClassType | import("./types").ObjectType | import("./types").EnumType | import("./types").SymbolType | import("./types").TypedefType | null;
+export declare function resolveDottedMember(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): {
+    mayThrow: boolean;
+    object: ExactOrUnion;
+    property: import("./types").UnionType | import("./types").NumberType | import("./types").LongType | import("./types").FloatType | import("./types").DoubleType | import("./types").CharType | import("./types").StringType | import("./types").ArrayType | import("./types").DictionaryType | import("./types").MethodType | import("./types").ModuleType | import("./types").FunctionType | import("./types").ClassType | import("./types").ObjectType | import("./types").EnumType | import("./types").SymbolType | import("./types").TypedefType;
+} | null;

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

@@ -0,0 +1,204 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
+export declare const enum TypeTag {
+    Never = 0,
+    Null = 1,
+    False = 2,
+    True = 4,
+    Boolean = 6,
+    Number = 8,
+    Long = 16,
+    Float = 32,
+    Double = 64,
+    Decimal = 96,
+    Numeric = 120,
+    Char = 128,
+    String = 256,
+    Array = 512,
+    Dictionary = 1024,
+    Method = 2048,
+    Module = 4096,
+    Function = 8192,
+    Class = 16384,
+    Object = 32768,
+    Enum = 65536,
+    Symbol = 131072,
+    Typedef = 262144,
+    Any = 524287
+}
+export declare function typeTagName(tag: TypeTag): "Never" | "Null" | "False" | "True" | "Boolean" | "Number" | "Long" | "Float" | "Double" | "Decimal" | "Numeric" | "Char" | "String" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Object" | "Enum" | "Symbol" | "Typedef" | "Any";
+export declare const LastTypeTag = TypeTag.Typedef;
+export declare const SingletonTypeTagsConst: number;
+export declare const UnionDataTypeTagsConst: number;
+export declare const ValueTypeTagsConst: number;
+export declare const ObjectLikeTagsConst: number;
+export declare const EnumTagsConst: number;
+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.Method | TypeTag.Module | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Symbol | TypeTag.Typedef;
+export type EnumeratedTypeTags = ExactTypeTags | TypeTag.Never | TypeTag.Any;
+export type UnionTypeTags = number;
+interface AbstractValue {
+    type: UnionTypeTags;
+    value?: unknown;
+}
+export type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | MethodType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
+type ExactPairHelper<T> = T extends ExactTypes ? {
+    type: T["type"];
+    avalue: T["value"];
+    bvalue: T["value"];
+} : never;
+export type ExactPairs = ExactPairHelper<ExactTypes>;
+export type ValuePairs = ExactPairHelper<ValueTypes>;
+type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : {
+    type: T["type"];
+    value: NonNullable<T["value"]>;
+} : never;
+export type ExactData<T extends ExactTypeTags> = T extends SingletonType ? undefined : NonNullable<Extract<ExactTypes, {
+    type: T;
+}>["value"]>;
+export type ValueTypes = WithValue<ExactTypes>;
+export 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 MethodType extends AbstractValue {
+    type: TypeTag.Method;
+    value?: {
+        args: ExactOrUnion[];
+        result: 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 TypedefType extends AbstractValue {
+    type: TypeTag.Typedef;
+    value?: TypedefStateNode | TypedefStateNode[] | 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;
+    } | {
+        enum?: undefined;
+        value: ExactOrUnion;
+    } | undefined;
+}
+export interface SymbolType extends AbstractValue {
+    type: TypeTag.Symbol;
+    value?: string | undefined;
+}
+export interface AnyType extends AbstractValue {
+    type: TypeTag.Any;
+    value?: undefined;
+}
+export type SingletonType = NullType | FalseType | TrueType;
+export type UnionData = {
+    mask: TypeTag;
+    [TypeTag.Array]?: NonNullable<ArrayType["value"]>;
+    [TypeTag.Dictionary]?: NonNullable<DictionaryType["value"]>;
+    [TypeTag.Method]?: NonNullable<MethodType["value"]>;
+    [TypeTag.Module]?: NonNullable<ModuleType["value"]>;
+    [TypeTag.Function]?: NonNullable<FunctionType["value"]>;
+    [TypeTag.Class]?: NonNullable<ClassType["value"]>;
+    [TypeTag.Object]?: NonNullable<ObjectType["value"]>;
+    [TypeTag.Enum]?: NonNullable<EnumType["value"]>;
+};
+export type UnionDataKey = Exclude<keyof UnionData, "mask">;
+export interface UnionType extends AbstractValue {
+    value?: UnionData | undefined;
+}
+export type ExactOrUnion = UnionType | ExactTypes;
+export type SingleValue = NonNullable<ValueTypes["value"]>;
+type TagValue<TAG> = Extract<ValueTypes, {
+    type: TAG;
+}>["value"];
+export type EnumValueType = TagValue<TypeTag.Enum>;
+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 hasNoData(v: AbstractValue, t: TypeTag): 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 typeFromTypeStateNodes(state: ProgramStateAnalysis, sns: StateNodeDecl[], classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromSingleTypeSpec(state: ProgramStateAnalysis, type: mctree.TypeSpecPart | mctree.ObjectExpression, stack?: ProgramStateStack | undefined): 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 declare function hasUnionData(tag: TypeTag): boolean;
+export declare function getObjectValue(t: ExactOrUnion): ObjectType["value"] | null;
+export declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn: (type: ExactTypes) => boolean | void): void;
+export declare function getUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T): ExactData<T> | null;
+export declare function setUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T, c: ExactData<T>): void;
+export declare function getStateNodeDeclsFromType(state: ProgramStateAnalysis, object: ExactOrUnion): StateNode[];
+export {};

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

@@ -0,0 +1,4 @@
+import { ExactOrUnion, TypeTag } from "./types";
+export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
+export declare function clearValuesUnder(v: ExactOrUnion, tag: TypeTag, clearTag?: boolean): void;
+export declare function widenType(t: ExactOrUnion): null;

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

@@ -0,0 +1,18 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { Event, EventDecl } from "./data-flow";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+import { InterpState } from "./type-flow/interp";
+import { TypeStateKey } from "./type-flow/type-flow-util";
+export declare const missingNullWorkaround = true;
+export type NodeEquivMap = Map<mctree.Node, {
+    decl: EventDecl;
+    equiv: Array<EventDecl>;
+}>;
+export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode, optimizeEquivalencies: boolean): InterpState | undefined;
+export declare function buildConflictGraph(state: ProgramStateAnalysis, func: FunctionStateNode): {
+    graph: import("./control-flow").Block<Event>;
+    localConflicts: Map<TypeStateKey, Set<TypeStateKey>> | null;
+    locals: Set<TypeStateKey>;
+    identifiers: Set<string>;
+    logThisRun: boolean;
+} | undefined;

package/build/src/src/unused-exprs.d.ts

@@ -0,0 +1,3 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateOptimizer } from "./optimizer-types";
+export declare function cleanupUnusedVars(state: ProgramStateOptimizer, node: mctree.BlockStatement | mctree.ForStatement): boolean;

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

@@ -0,0 +1,33 @@
+import glob from "fast-glob";
+export { logger, log, wouldLog, setBanner, bumpLogging } from "./logger";
+export declare function globa(pattern: string, options?: glob.Options & {
+    mark?: boolean;
+}): Promise<Array<string>>;
+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) => boolean): boolean;
+export declare function some<T>(val: T | T[] | null | undefined, fn: (v: T) => boolean): boolean;
+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): boolean;
+export declare function sameArrays<T>(a1: T[], a2: T[], check: (a: T, b: T) => boolean): boolean;
+export type LineHandler = (line: string) => void;
+export declare function spawnByLine(command: string, args: string[], lineHandlers: LineHandler | LineHandler[], options?: {
+    [key: string]: unknown;
+}): Promise<void>;
+export declare function readByLine(file: string, lineHandler: LineHandler): Promise<unknown>;
+export declare function promiseAll<T>(promiseFn: (i: number) => Promise<T> | null, parallelism: number): Promise<T[]>;
+export declare function copyRecursiveAsNeeded(source: string, target: string, filter?: (src: string, tgt: string) => boolean): Promise<void>;
+export declare function popcount(x: number): number;
+export declare class GenericQueue<Block> {
+    private enqueued;
+    private queue;
+    constructor(sort: (a: Block, b: Block) => number);
+    enqueue(block: Block): void;
+    dequeue(): Block;
+    empty(): boolean;
+}

package/build/src/src/variable-renamer.d.ts

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateAnalysis } from "./optimizer-types";
+export declare function renameIdentifier(ident: mctree.Identifier, newName: string): void;
+export declare function renameVariable(state: ProgramStateAnalysis, locals: NonNullable<ProgramStateAnalysis["localsStack"]>[number], declName: string | null): string | null;

package/build/src/src/visitor.d.ts

@@ -0,0 +1,5 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
+import { TypeMap } from "./type-flow/interp";
+export declare function visitorNode(node: mctree.Node): mctree.Node;
+export declare function visitReferences(state: ProgramStateAnalysis, ast: mctree.Program, name: string | null, defn: LookupDefinition[] | null | false, callback: (node: mctree.Node, results: LookupDefinition[], error: boolean) => undefined | false, includeDefs?: boolean, filter?: ((node: mctree.Node) => boolean) | null, typeMap?: TypeMap | null, findSingleDefinition?: boolean): void;

package/build/src/src/worker-pool.d.ts

@@ -0,0 +1,4 @@
+import type { WorkerTask, WorkerTaskResult } from "./worker-task";
+export declare function startPool(parallelism?: number): boolean;
+export declare function stopPool(): void;
+export declare function runTaskInPool<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;

package/build/src/src/worker-task.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { JungleQualifier } from "./jungles";
+import { BuildConfig } from "./optimizer";
+import { xmlUtil } from "./sdk-util";
+interface BaseNode {
+    type: string;
+    data: unknown;
+}
+interface BuildOptimizedProject extends BaseNode {
+    type: "buildOptimizedProject";
+    data: {
+        product: string | null;
+        options: BuildConfig;
+    };
+}
+interface GenerateOneConfig extends BaseNode {
+    type: "generateOneConfig";
+    data: {
+        buildConfig: JungleQualifier;
+        manifestXML: xmlUtil.Document;
+        dependencyFiles: string[];
+        config: BuildConfig;
+    };
+}
+interface GenerateOptimizedProject extends BaseNode {
+    type: "generateOptimizedProject";
+    data: {
+        options: BuildConfig;
+    };
+}
+interface OptimizePrgAndDebug extends BaseNode {
+    type: "optimizePrgAndDebug";
+    data: {
+        prgName: string;
+        prgBuffer: ArrayBuffer;
+        prgOffset: number;
+        prgLength: number;
+        xmlName: string;
+        xmlBuffer: ArrayBuffer;
+        xmlOffset: number;
+        xmlLength: number;
+        key: crypto.KeyObject;
+        config: BuildConfig | undefined;
+    };
+}
+export type WorkerTask = BuildOptimizedProject | GenerateOptimizedProject | GenerateOneConfig | OptimizePrgAndDebug;
+export declare const workerTaskHandlers: {
+    readonly buildOptimizedProject: (data: BuildOptimizedProject["data"]) => Promise<{
+        exe: string;
+        args: string[];
+        program: string;
+        product: string | null;
+        hasTests: boolean;
+        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+    }>;
+    readonly generateOptimizedProject: (data: GenerateOptimizedProject["data"]) => Promise<{
+        jungleFiles: string | undefined;
+        xml: xmlUtil.Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics?: undefined;
+    } | {
+        jungleFiles: string;
+        xml: xmlUtil.Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]>;
+    }>;
+    readonly generateOneConfig: (data: GenerateOneConfig["data"]) => Promise<{
+        hasTests: boolean;
+        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+        sdkVersion: number | undefined;
+    }>;
+    readonly optimizePrgAndDebug: (data: OptimizePrgAndDebug["data"]) => Promise<{
+        sigBuffer: ArrayBufferLike | undefined;
+        sigOffset: number | undefined;
+        sigLength: number | undefined;
+        prgBuffer: ArrayBufferLike;
+        prgOffset: number;
+        prgLength: number;
+        debugXml: string;
+    }>;
+};
+type RemovePromise<T> = T extends Promise<infer U> ? U : T;
+export type WorkerTaskResult<T> = T extends WorkerTask ? RemovePromise<ReturnType<(typeof workerTaskHandlers)[T["type"]]>> : never;
+export declare function performTask<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;
+export {};

package/build/src/src/worker-thread.d.ts

@@ -0,0 +1 @@
+export {};