@markw65/monkeyc-optimizer 1.1.34 → 1.1.35

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

@@ -1,249 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { EnumStringMember } from "@markw65/prettier-plugin-monkeyc/build/estree-types";
-import { xmlUtil } from "./sdk-util";
-import { ExactOrUnion } from "./type-flow/types";
-export type DiagnosticType = "ERROR" | "WARNING" | "INFO";
-export type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
-export type EnforceStatic = "YES" | "NO";
-export type BuildConfig = {
-    workspace?: string;
-    jungleFiles?: string;
-    developerKeyPath?: string;
-    typeCheckLevel?: string;
-    optimizationLevel?: string;
-    compilerOptions?: string;
-    compilerWarnings?: boolean;
-    simulatorBuild?: boolean;
-    releaseBuild?: boolean;
-    testBuild?: boolean;
-    products?: string[];
-    buildDir?: string;
-    outputPath?: string;
-    program?: string;
-    skipOptimization?: boolean;
-    checkManifest?: boolean;
-    device?: string;
-    ignoredExcludeAnnotations?: string;
-    ignoredAnnotations?: string;
-    ignoredSourcePaths?: string;
-    returnCommand?: boolean;
-    checkBuildPragmas?: boolean;
-    checkInvalidSymbols?: DiagnosticType | "OFF";
-    checkCompilerLookupRules?: DiagnosticType | "OFF";
-    compilerLookupRules?: LookupRules;
-    enforceStatic?: EnforceStatic;
-    sizeBasedPRE?: boolean | string;
-    prettier?: Record<string, unknown>;
-    extensionVersion?: string;
-    useLocalOptimizer?: boolean;
-    propagateTypes?: boolean;
-    trustDeclaredTypes?: boolean;
-    minimizeLocals?: boolean;
-    minimizeModules?: boolean;
-    postBuildOptimizer?: boolean;
-    singleUseCopyProp?: boolean;
-    iterateOptimizer?: boolean;
-    covarianceWarnings?: boolean;
-    checkTypes?: DiagnosticType | "OFF";
-    removeArgc?: boolean;
-    postBuildPRE?: boolean;
-};
-export type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
-export type StateNodeDecls = {
-    [key: string]: StateNodeDecl[];
-};
-export type ImportUsing = {
-    node: mctree.Using | mctree.ImportModule;
-    module?: ModuleStateNode | null | undefined;
-};
-export declare const enum StateNodeAttributes {
-    NONE = 0,
-    PUBLIC = 1,
-    PROTECTED = 2,
-    PRIVATE = 4,
-    STATIC = 8
-}
-interface BaseStateNode {
-    type: string;
-    node: mctree.Node | null | undefined;
-    name: string | null | undefined;
-    fullName: string | null | undefined;
-    decls?: StateNodeDecls | undefined;
-    type_decls?: StateNodeDecls | undefined;
-    stack?: ProgramStateStack | undefined;
-    attributes: StateNodeAttributes;
-}
-export interface ProgramStateNode extends BaseStateNode {
-    type: "Program";
-    node: mctree.Program | undefined;
-    name: "$";
-    fullName: "$";
-    stack?: undefined;
-}
-export interface ModuleStateNode extends BaseStateNode {
-    type: "ModuleDeclaration";
-    node: mctree.ModuleDeclaration;
-    name: string;
-    fullName: string;
-}
-export interface ClassStateNode extends BaseStateNode {
-    type: "ClassDeclaration";
-    node: mctree.ClassDeclaration;
-    name: string;
-    fullName: string;
-    superClass?: ClassStateNode[] | true;
-    hasInvoke?: boolean;
-    superClasses?: Set<StateNode>;
-}
-export type FunctionInfo = {
-    modifiedDecls: Set<VariableStateNode>;
-    calledFuncs: Set<FunctionStateNode>;
-    resolvedDecls?: Set<VariableStateNode>;
-    callsExposed?: boolean;
-    modifiedUnknown?: boolean;
-    modifiedNames?: Set<string>;
-};
-export interface FunctionStateNode extends BaseStateNode {
-    type: "FunctionDeclaration";
-    node: mctree.FunctionDeclaration;
-    name: string;
-    fullName: string;
-    stack?: ProgramStateStack;
-    decls?: undefined;
-    info?: FunctionInfo | false;
-    next_info?: FunctionInfo;
-}
-export interface BlockStateNode extends BaseStateNode {
-    type: "BlockStatement";
-    name: undefined;
-    fullName: string;
-    node: mctree.BlockStatement | mctree.ForStatement;
-    stack?: undefined;
-}
-export interface TypedefStateNode extends BaseStateNode {
-    type: "TypedefDeclaration";
-    node: mctree.TypedefDeclaration;
-    name: string;
-    fullName: string;
-    isExpanding?: true;
-    isRecursive?: true;
-    resolvedType?: ExactOrUnion;
-}
-export interface VariableStateNode extends BaseStateNode {
-    type: "VariableDeclarator";
-    node: mctree.VariableDeclarator;
-    name: string;
-    fullName: string;
-    stack: ProgramStateStack;
-    used?: true;
-    resolvedType?: ExactOrUnion | undefined;
-}
-export interface EnumStateNode extends BaseStateNode {
-    type: "EnumDeclaration";
-    node: mctree.EnumDeclaration;
-    name: string;
-    fullName: string;
-    stack: ProgramStateStack;
-    resolvedType?: ExactOrUnion;
-}
-interface DiagnosticBase {
-    loc: mctree.SourceLocation;
-    message: string;
-}
-export interface DiagnosticInfo extends DiagnosticBase {
-    loc: Finalized<mctree.SourceLocation, "source">;
-}
-export interface Diagnostic extends DiagnosticBase {
-    type: DiagnosticType;
-    related?: DiagnosticInfo[];
-    extra?: {
-        uri: string;
-        message: string;
-    };
-}
-type ProgramStateStackElem = {
-    sn: StateNode;
-    usings?: Record<string, ImportUsing>;
-    imports?: ImportUsing[];
-};
-export type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
-export type ProgramStateStack = ProgramStateStackElem[];
-export type LookupDefinition = {
-    parent: StateNode | null;
-    results: StateNodeDecl[];
-};
-export type LookupResult = [string, LookupDefinition[]] | [null, null] | [false, false];
-export type ByNameStateNodeDecls = ModuleStateNode | ClassStateNode | FunctionStateNode | ProgramStateNode;
-export type ProgramState = {
-    allFunctions?: Record<string, FunctionStateNode[]>;
-    allClasses?: ClassStateNode[];
-    invokeInfo?: FunctionInfo;
-    allDeclarations?: Record<string, ByNameStateNodeDecls[]>;
-    fnMap?: FilesToOptimizeMap;
-    rezAst?: mctree.Program;
-    manifestXML?: xmlUtil.Document;
-    stack?: ProgramStateStack;
-    top?: () => ProgramStateStackElem;
-    currentFunction?: FunctionStateNode;
-    removeNodeComments?: (node: mctree.Node, ast: mctree.Program) => void;
-    shouldExclude?: (node: mctree.Node) => boolean;
-    pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
-    post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node | mctree.Node[];
-    lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
-    lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
-    lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
-    lookupNonlocal?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
-    stackClone?: () => ProgramStateStack;
-    traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
-    inType?: number;
-    inlining?: true;
-    config?: BuildConfig;
-    sdk?: string;
-    sdkVersion?: number;
-    lookupRules?: LookupRules;
-    nextExposed?: Record<string, true>;
-    exposed?: Record<string, true>;
-    usedByName?: Record<string, true>;
-    calledFunctions?: {
-        [key: string]: mctree.FunctionDeclaration[];
-    };
-    localsStack?: {
-        node?: mctree.Node;
-        map?: {
-            [key: string]: boolean | string;
-        };
-        inners?: {
-            [key: string]: true;
-        };
-    }[];
-    index?: {
-        [key: string]: unknown[];
-    };
-    constants?: {
-        [key: string]: mctree.Literal;
-    };
-    diagnostics?: Record<string, Diagnostic[]>;
-    inlineDiagnostics?: Record<string, Diagnostic[]>;
-    enumMap?: Map<EnumStringMember, EnumStateNode>;
-};
-export type Finalized<T, Keys extends keyof T> = T & {
-    [key in Keys]-?: NonNullable<T[key]>;
-};
-export type ProgramStateLive = Finalized<ProgramState, "stack" | "top" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
-export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
-export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
-export type ExcludeAnnotationsMap = {
-    [key: string]: boolean;
-};
-export type FilesToOptimizeMap = {
-    [key: string]: {
-        output: string;
-        barrel: string;
-        excludeAnnotations: ExcludeAnnotationsMap;
-        monkeyCSource?: string;
-        ast?: mctree.Program;
-        parserError?: Error;
-        hasTests?: boolean;
-    };
-};
-export {};

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

@@ -1,100 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { get_jungle, JungleBuildDependencies, JungleError, JungleQualifier, JungleResourceMap, ResolvedJungle, Target } from "./jungles";
-import { launchSimulator, simulateProgram } from "./launch";
-import { manifestProducts } from "./manifest";
-import { BuildConfig, FilesToOptimizeMap, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
-import { xmlUtil } from "./sdk-util";
-import { TypeMap } from "./type-flow/interp";
-import { copyRecursiveAsNeeded } from "./util";
-export * from "./optimizer-types";
-export { display, ExactOrUnion } from "./type-flow/types";
-export { copyRecursiveAsNeeded, get_jungle, JungleBuildDependencies, JungleError, JungleResourceMap, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, TypeMap, };
-export declare const defaultConfig: {
-    outputPath: string;
-    workspace: string;
-};
-export interface ErrorWithLocation extends Error {
-    location?: NonNullable<mctree.Node["loc"]>;
-}
-export declare function isErrorWithLocation(e: Error): e is ErrorWithLocation;
-declare global {
-    var lastModifiedSource: number;
-}
-/**
- * @param {BuildConfig} options
- * @returns {Promise<BuildConfig>}
- */
-export declare function getConfig(options: BuildConfig): Promise<BuildConfig>;
-/**
- *
- * WARNING WARNING WARNING WARNING WARNING WARNING
- *
- * prettier-extension-monkeyc can dynamically import this
- * function from a local copy of @markw65/monkeyc-optimizer,
- * rather than using the version that ships with the
- * extension.
- *
- * For this to work, buildOptimizedProject's signature cannot
- * change (or at least, can only change in a backward compatible
- * way).
- *
- * DON'T CHANGE THIS FUNCTION's SIGNATURE
- *
- * @param {string | null} product
- * @param {BuildConfig} options
- * @returns
- */
-export declare function buildOptimizedProject(product: string | null, options: BuildConfig): Promise<{
-    exe: string;
-    args: string[];
-    program: string;
-    product: string | null;
-    hasTests: boolean;
-    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
-}>;
-export declare function generateOptimizedProject(options: BuildConfig): 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[]>;
-}>;
-export type PreAnalysis = {
-    fnMap: FilesToOptimizeMap;
-    paths: string[];
-};
-declare type RequiredNonNull<T> = {
-    [K1 in keyof T]-?: {
-        [K2 in keyof T[K1]]-?: NonNullable<T[K1][K2]>;
-    };
-};
-export type Analysis = {
-    fnMap: RequiredNonNull<FilesToOptimizeMap>;
-    paths: string[];
-    state: ProgramStateAnalysis;
-    typeMap?: TypeMap | null | undefined;
-};
-/**
- * @param {BuildConfig} config
- * @param {*} buildConfig
- * @param {string[]} dependencyFiles
- * @returns
- */
-export declare function generateOneConfig(buildConfig: JungleQualifier, manifestXML: xmlUtil.Document, dependencyFiles: string[], config: BuildConfig): Promise<{
-    hasTests: boolean;
-    diagnostics: ProgramState["diagnostics"];
-    sdkVersion: number | undefined;
-}>;
-export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, manifestXML: xmlUtil.Document, options: BuildConfig): Promise<Analysis | PreAnalysis>;
-/**
- *
- * @param {BuildConfig} options
- * @returns
- */
-export declare function generateApiMirTests(options: BuildConfig): Promise<void>;

package/build/src/src/pragma-checker.d.ts

@@ -1,3 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ProgramState, ProgramStateOptimizer } from "./optimizer-types";
-export declare function pragmaChecker(state: ProgramStateOptimizer, ast: mctree.Program, diagnostics: NonNullable<ProgramState["diagnostics"]>[string] | null | undefined): void;

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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,72 +0,0 @@
-/// <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

@@ -1,17 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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