@markw65/monkeyc-optimizer 1.0.43 → 1.0.45

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;
@@ -17,13 +18,41 @@ interface LongLiteral extends mctree.Literal {
 interface StringLiteral extends mctree.Literal {
     value: string;
 }
+interface CharLiteral extends mctree.Literal {
+    value: string;
+}
 interface BooleanLiteral extends mctree.Literal {
     value: boolean;
 }
 interface NullLiteral extends mctree.Literal {
     value: null;
 }
-declare type LiteralValues = [NumberLiteral, "Number" | "Float" | "Double"] | [LongLiteral, "Long"] | [StringLiteral, "String"] | [BooleanLiteral, "Boolean"] | [NullLiteral, "Null"];
+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/inliner.d.ts

@@ -1,11 +1,11 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./optimizer-types";
+import { FunctionStateNode, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
 export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
 export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
 declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
-export declare function diagnostic(state: ProgramStateLive, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
+export declare function diagnostic(state: ProgramState, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
 export declare type InlineContext = mctree.ReturnStatement | mctree.IfStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
 export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): InlineBody | null;
 export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

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/resources.d.ts

@@ -1,13 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { JungleResourceMap } from "./jungles";
+import { ProgramState } from "./optimizer-types";
 import { xmlUtil } from "./sdk-util";
 declare type Visit = (e: xmlUtil.Element, module: string | null, parent: xmlUtil.Element | null) => void;
 declare type Visitor = {
     visit?: Visit;
     error?: (node: xmlUtil.Element, parent: string | null) => void;
-    pre?: (node: xmlUtil.Content) => boolean | null | undefined | void;
-    post?: (node: xmlUtil.Content) => 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(ast: mctree.Program, resources: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): 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/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/src/worker-pool.d.ts

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

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

@@ -0,0 +1,29 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+interface BaseNode {
+    type: string;
+    data: unknown;
+}
+interface ParserData extends BaseNode {
+    data: {
+        source: string;
+        options?: Record<string, unknown>;
+    };
+}
+interface JungleParserTask extends ParserData {
+    type: "parseJungle";
+}
+interface MonkeyCParserTask extends ParserData {
+    type: "parseMonkeyC";
+}
+interface XmlParserTask extends ParserData {
+    type: "parseXml";
+}
+export declare type WorkerTask = JungleParserTask | MonkeyCParserTask | XmlParserTask;
+export declare const workerTaskHandlers: {
+    readonly parseJungle: (data: JungleParserTask["data"]) => Assignment[];
+    readonly parseMonkeyC: (data: MonkeyCParserTask["data"]) => mctree.Program;
+    readonly parseXml: (data: XmlParserTask["data"]) => ParserResult;
+};
+export declare type WorkerTaskResult<T> = T extends WorkerTask ? ReturnType<typeof workerTaskHandlers[T["type"]]> : never;
+export declare function performTask<T extends WorkerTask>(task: T): WorkerTaskResult<T>;
+export {};

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

@@ -1,4 +1,3 @@
-import { xmlUtil } from "./sdk-util.js";
 export declare class PeggyError extends Error {
     location: SourceLocation | null | undefined;
     constructor(message: string, location: SourceLocation | null | undefined);
@@ -134,9 +133,17 @@ export declare class Document {
     misc: Array<Misc>;
     source?: string | undefined;
     data?: Record<string, unknown>;
+    private entities;
+    private pentities;
     constructor(prolog: Prolog | null, body: Nodes | Error, misc: Array<Misc>, source?: string | undefined);
-}
-export declare function elementKids(e: Element): xmlUtil.Element[];
+    /**
+     * If all the children are chardata, charref or entityref,
+     * return the resulting string. Otherwise null.
+     */
+    textContent(element: Element): string | null;
+    processRefs(text: string): string;
+}
+export declare function elementKids(e: Element): Element[];
 declare type ElementMatcher = string | ((c: Element) => boolean);
 export declare class Nodes {
     elements: Array<Element>;
@@ -144,11 +151,11 @@ export declare class Nodes {
     length(): number;
     deleteChildren(arg: ElementMatcher): void;
     addChildren(elements: Element[]): void;
-    filter(arg: ElementMatcher): xmlUtil.Nodes;
-    skip(name: string): xmlUtil.Nodes;
-    children(name?: string): xmlUtil.Nodes;
+    filter(arg: ElementMatcher): Nodes;
+    skip(name: string): Nodes;
+    children(name?: string): Nodes;
     text(): string[];
-    attrs(): Record<string, xmlUtil.Attribute | undefined>[];
+    attrs(): Record<string, Attribute | undefined>[];
 }
 export declare function attrString(value: string | AttrStr): AttrStr | {
     readonly type: "attrstr";
@@ -157,4 +164,9 @@ export declare function attrString(value: string | AttrStr): AttrStr | {
 export declare function makeAttribute(name: string | AttrStr, value: string | AttrStr): Attribute;
 export declare function parseXml(content: string, fileName?: string | null): Document;
 export declare function writeXml(doc: Document): string;
+export declare type Visitor = {
+    pre?: (node: Content) => boolean | null | undefined | void;
+    post?: (node: Content) => void;
+};
+export declare function visit_xml(contents: Content[], visitor: Visitor): void;
 export {};

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]));