@markw65/monkeyc-optimizer 1.0.8 → 1.0.11

package/build/src/api.d.ts

@@ -0,0 +1,8 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function getApiMapping(state?: ProgramState): Promise<ProgramStateNode | null>;
+export declare function hasProperty(obj: unknown, prop: string): any;
+export declare function isStateNode(node: StateNodeDecl): node is StateNode;
+export declare function variableDeclarationName(node: mctree.TypedIdentifier): string;
+export declare function collectNamespaces(ast: mctree.Program, state: ProgramState): ProgramStateNode;
+export declare function traverseAst(node: mctree.Node, pre?: (node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[], post?: (node: mctree.Node) => void | null | false | mctree.Node): false | void | null | mctree.Node;
+export declare function formatAst(node: mctree.Node, monkeyCSource?: string): string;

package/build/src/build.d.ts

@@ -0,0 +1,6 @@
+export declare function build_project(product: string, options: BuildConfig, lineCallback?: (line: string) => void): Promise<{
+    exe: string;
+    args: string[];
+    program: string;
+    product: string;
+}>;

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

@@ -0,0 +1,324 @@
+declare type InclusiveUnionKeys<U> = U extends unknown ? keyof U : never;
+declare type InclusiveUnion<U> = {
+    [K in InclusiveUnionKeys<U>]: U extends any ? K extends keyof U ? U[K] : never : never;
+};
+declare type SubfieldsOfType<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+export declare type NodeAll = InclusiveUnion<Node>;
+export declare type NodeSubFields = SubfieldsOfType<NodeAll, Node>;
+export declare type NodeSubArrays = SubfieldsOfType<NodeAll, Node[]>;
+interface BaseNode {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    start?: number;
+    end?: number;
+    range?: [number, number] | undefined;
+}
+export declare type Node = Identifier | Literal | Program | SwitchCase | CatchClause | VariableDeclarator | EnumStringBody | EnumStringMember | Statement | Expression | Property | Declaration | ImportStatement | AsTypeSpec | TypeSpecList | ClassElement | ClassBody | Comment;
+export interface Comment extends BaseNode {
+    type: "Line" | "Block";
+    value: string;
+}
+interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+export interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+export interface Program extends BaseNode {
+    type: "Program";
+    body: Array<Declaration | ImportStatement>;
+    comments?: Array<Comment> | undefined;
+}
+export interface ModuleDeclaration extends BaseDeclaration {
+    type: "ModuleDeclaration";
+    body: Array<Declaration | ImportStatement>;
+    id: Identifier;
+}
+interface BaseFunction extends BaseNode {
+    params: Array<Identifier | AsExpression>;
+    body: BlockStatement;
+}
+export declare type Statement = ExpressionStatement | BlockStatement | ReturnStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | Declaration;
+interface BaseStatement extends BaseNode {
+}
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Array<Statement>;
+    innerComments?: Array<Comment> | undefined;
+}
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+}
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+}
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: Array<SwitchCase>;
+}
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | CatchClauses | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+export declare type Declaration = ClassDeclaration | EnumDeclaration | FunctionDeclaration | ModuleDeclaration | TypedefDeclaration | VariableDeclaration;
+interface BaseDeclaration extends BaseStatement {
+    attrs?: AttributeList;
+}
+export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    id: Identifier;
+    body: BlockStatement;
+    optimizable?: boolean;
+    hasOverride?: boolean;
+}
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: Array<VariableDeclarator>;
+    kind: "var" | "const";
+}
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Identifier | AsExpression;
+    init?: Expression | null | undefined;
+    kind: "var" | "const";
+}
+declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | Literal | UnaryExpression | UpdateExpression | BinaryExpression | AsExpression | AssignmentExpression | LogicalExpression | MemberExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier;
+export interface BaseExpression extends BaseNode {
+    enumType?: string | Node;
+}
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+    text: string;
+}
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression>;
+}
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property>;
+}
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression;
+    value: Expression;
+    kind: "init";
+}
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Array<Expression>;
+}
+interface BaseUnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    prefix: true;
+}
+interface TrueUnaryExpression extends BaseUnaryExpression {
+    operator: UnaryOperator;
+    argument: Expression;
+}
+interface SymbolExpression extends BaseUnaryExpression {
+    operator: ":";
+    argument: Identifier;
+}
+export declare type UnaryExpression = TrueUnaryExpression | SymbolExpression;
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+export interface AsExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: "as";
+    left: Expression;
+    right: TypeSpecList;
+}
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Identifier | MemberExpression;
+    right: Expression;
+}
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression;
+    arguments: Array<Expression>;
+}
+export declare type CallExpression = SimpleCallExpression | NewExpression;
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+}
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+export interface MemberExpression extends BaseExpression {
+    type: "MemberExpression";
+    object: Expression;
+    property: Expression;
+    computed: boolean;
+}
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Array<Statement>;
+}
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Identifier | null;
+    body: BlockStatement;
+}
+export interface CatchClauses extends BaseNode {
+    type: "CatchClauses";
+    catches: CatchClause[];
+}
+export interface Identifier extends BaseNode, BaseExpression {
+    type: "Identifier";
+    name: string;
+}
+export interface Literal extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+export declare type UnaryOperator = "-" | "+" | "!" | "~" | " as";
+export declare type BinaryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "has" | "instanceof";
+export declare type LogicalOperator = "||" | "&&";
+export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | "|=" | "^=" | "&=";
+export declare type UpdateOperator = "++" | "--";
+export interface ClassDeclaration extends BaseDeclaration {
+    type: "ClassDeclaration";
+    id: Identifier;
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+export interface ClassBody extends BaseStatement {
+    type: "ClassBody";
+    body: Array<ClassElement>;
+}
+export interface ClassElement extends BaseStatement {
+    type: "ClassElement";
+    item: Omit<Declaration, "ModuleDeclaration">;
+}
+export interface EnumDeclaration extends BaseDeclaration {
+    type: "EnumDeclaration";
+    id?: Identifier | null;
+    body: EnumStringBody;
+}
+export interface EnumStringBody extends BaseNode {
+    type: "EnumStringBody";
+    members: Array<EnumStringMember | Identifier>;
+    enumType?: string | Node;
+}
+export interface EnumStringMember extends BaseNode {
+    type: "EnumStringMember";
+    id: Identifier;
+    init: Expression;
+    enumType?: string | Node;
+}
+export interface TypedefDeclaration extends BaseDeclaration {
+    type: "TypedefDeclaration";
+    id: Identifier;
+    ts: AsTypeSpec;
+}
+export interface AsTypeSpec extends Omit<UnaryExpression, "operator" | "argument"> {
+    operator: " as";
+    argument: TypeSpecList;
+}
+export interface TypeSpecList extends BaseNode {
+    type: "TypeSpecList";
+    ts: Array<TypeSpecPart>;
+}
+export interface TypeSpecPart extends BaseNode {
+    type: "TypeSpecPart";
+    name: Identifier | MemberExpression;
+    body?: BlockStatement;
+    callspec?: MethodDefinition;
+    generics?: Array<TypeSpecList>;
+}
+export interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    kind: "method";
+    key: "";
+    params: Array<Identifier | AsExpression>;
+    returnType: AsTypeSpec;
+}
+export declare type AccessSpecifier = "static" | "private" | "protected" | "hidden" | "public";
+export interface AttributeList extends BaseNode {
+    type: "AttributeList";
+    attrs?: Attribute[];
+    access?: AccessSpecifier[];
+}
+declare type Attribute = SymbolExpression | CallExpression;
+export declare type ImportStatement = ImportModule | Using;
+export interface ImportModule extends BaseNode {
+    type: "ImportModule";
+    id: MemberExpression;
+}
+export interface Using extends BaseNode {
+    type: "Using";
+    id: MemberExpression;
+    as: Identifier;
+}
+export {};

package/build/src/jungles.d.ts

@@ -0,0 +1,51 @@
+import { ManifestXML } from "./manifest";
+export declare type Target = {
+    product: string;
+    qualifier: JungleQualifier;
+    shape?: string;
+    group?: {
+        optimizerConfig: JungleQualifier;
+        dir?: string;
+        key?: string;
+    };
+};
+declare type LangResourcePaths = {
+    [key: string]: string[];
+};
+declare type BarrelAnnotations = {
+    [key: string]: string[];
+};
+declare type BarrelMap = {
+    [key: string]: ResolvedBarrel;
+};
+declare type OptBarrelMap = Record<string, {
+    rawBarrelDir: string;
+    manifest: string;
+    jungleFiles: string[];
+    optBarrelDir: string;
+}>;
+export declare type JungleQualifier = {
+    sourcePath?: string[];
+    sourceExcludes?: string[];
+    excludeAnnotations?: string[];
+    resourcePath?: string[];
+    lang?: LangResourcePaths;
+    barrelPath?: (string | string[])[];
+    annotations?: BarrelAnnotations;
+    barrelMap?: BarrelMap;
+    optBarrels?: OptBarrelMap;
+};
+declare type JungleInfoBase = {
+    jungles: string[];
+    manifest: string;
+    xml: ManifestXML;
+    annotations?: string[];
+};
+export declare type ResolvedJungle = JungleInfoBase & {
+    targets: Target[];
+};
+export declare type ResolvedBarrel = JungleInfoBase & {
+    qualifier: JungleQualifier;
+};
+export declare function get_jungle(jungles: string, options: BuildConfig): Promise<ResolvedJungle>;
+export {};

package/build/src/launch.d.ts

@@ -0,0 +1,2 @@
+export declare function launchSimulator(): Promise<void>;
+export declare function simulateProgram(prg: string, device: string, test?: boolean): Promise<void>;

package/build/src/manifest.d.ts

@@ -0,0 +1,71 @@
+declare type iqApplication = {
+    $: {
+        id: string;
+        entry: string;
+        launcherIcon: string;
+        minSdkVersion: string;
+        name: string;
+        type: string;
+        version: string;
+    };
+    "iq:products"?: Array<{
+        "iq:product"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:barrels"?: Array<{
+        "iq:depends"?: Array<{
+            $: {
+                name: string;
+                version: string;
+            };
+        }>;
+    }>;
+    "iq:permissions"?: Array<{
+        "iq:uses-permission"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:languages"?: Array<{
+        "iq:language"?: Array<string>;
+    }>;
+};
+declare type iqBarrel = {
+    $: {
+        id: string;
+        module: string;
+        version: string;
+    };
+    "iq:products"?: Array<{
+        "iq:product"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:annotations"?: Array<{
+        "iq:annotation"?: Array<string>;
+    }>;
+};
+export declare type ManifestXML = {
+    "iq:manifest": {
+        $: {
+            "xmlns:iq": string;
+        };
+        "iq:application": Array<iqApplication>;
+        "iq:barrel": Array<iqBarrel>;
+    };
+};
+export declare function readManifest(manifest: string): Promise<ManifestXML>;
+export declare function writeManifest(filename: string, xml: ManifestXML): Promise<void>;
+export declare function manifestProducts(manifest: ManifestXML): string[];
+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[];
+export declare function checkManifest(manifest: ManifestXML, products: string[]): Promise<boolean>;
+export {};

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

@@ -0,0 +1,7 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
+export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
+export declare function analyze(fnMap: FilesToOptimizeMap): Promise<ProgramState>;
+export declare function getLiteralFromDecls(decls: StateNodeDecl[]): mctree.Literal | mctree.AsExpression;
+export declare function getLiteralNode(node: mctree.Node): null | mctree.Literal | mctree.AsExpression;
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap): Promise<void>;

package/build/src/negative-fixups.d.ts

@@ -0,0 +1 @@
+export declare const negativeFixups: string[];

package/build/src/optimizer.d.ts

@@ -0,0 +1,177 @@
+import { get_jungle, Target, ResolvedJungle } from "./jungles";
+import { launchSimulator, simulateProgram } from "./launch";
+import { copyRecursiveAsNeeded } from "./util";
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export { copyRecursiveAsNeeded, launchSimulator, simulateProgram, get_jungle, ResolvedJungle, mctree, };
+export declare const defaultConfig: {
+    outputPath: string;
+    workspace: string;
+};
+declare global {
+    type BuildConfig = {
+        workspace?: string;
+        jungleFiles?: string;
+        developerKeyPath?: string;
+        typeCheckLevel?: 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;
+        _cache?: {
+            barrels?: Record<string, ResolvedJungle>;
+            barrelMap?: Record<string, Record<string, ResolvedJungle>>;
+        };
+    };
+    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration | mctree.TypedefDeclaration | mctree.VariableDeclarator;
+    type StateNodeDecls = {
+        [key: string]: StateNodeDecl[];
+    };
+    type ProgramStateNode = {
+        type: "Program";
+        node: null | undefined;
+        name: "$";
+        fullName: "$";
+        decls?: StateNodeDecls;
+        stack?: null | undefined;
+    };
+    type ModuleStateNode = {
+        type: "ModuleDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.ModuleDeclaration;
+        stack?: ProgramStateStack;
+        decls?: StateNodeDecls;
+    };
+    type ClassStateNode = {
+        type: "ClassDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.ClassDeclaration;
+        decls?: StateNodeDecls;
+        stack?: ProgramStateStack;
+        superClass: ClassStateNode[] | true;
+    };
+    type FunctionStateNode = {
+        type: "FunctionDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.FunctionDeclaration;
+        stack?: ProgramStateStack;
+        decls?: undefined;
+    };
+    type BlockStateNode = {
+        type: "BlockStatement";
+        name?: null | undefined;
+        fullName?: null | undefined;
+        node: mctree.BlockStatement;
+        decls?: StateNodeDecls;
+        stack?: null | undefined;
+    };
+    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode;
+    type ProgramStateStack = StateNode[];
+    export type ProgramState = {
+        allFunctions?: FunctionStateNode[];
+        allClasses?: ClassStateNode[];
+        stack?: ProgramStateStack;
+        shouldExclude?: (node: any) => any;
+        pre?: (node: mctree.Node) => null | false | (keyof mctree.NodeAll)[];
+        post?: (node: mctree.Node) => null | false | mctree.Node;
+        lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack];
+        traverse?: (node: mctree.Node) => void | boolean | mctree.Node;
+        exposed?: {
+            [key: string]: true;
+        };
+        calledFunctions?: {
+            [key: string]: unknown[];
+        };
+        localsStack?: {
+            node?: mctree.Node;
+            map?: {
+                [key: string]: true | string;
+            };
+            inners?: {
+                [key: string]: true;
+            };
+        }[];
+        index?: {
+            [key: string]: unknown[];
+        };
+        constants?: {
+            [key: string]: mctree.Literal;
+        };
+    };
+    type ExcludeAnnotationsMap = {
+        [key: string]: boolean;
+    };
+    type FilesToOptimizeMap = {
+        [key: string]: {
+            output: string;
+            excludeAnnotations: ExcludeAnnotationsMap;
+            monkeyCSource?: string;
+            ast?: mctree.Program;
+            parserError?: Error;
+            hasTests?: boolean;
+        };
+    };
+    var lastModifiedSource: number;
+}
+/**
+ *
+ * @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;
+    hasTests: boolean;
+}>;
+/**
+ *
+ * @param {BuildConfig} options
+ * @returns
+ */
+export declare function generateOptimizedProject(options: BuildConfig): Promise<{
+    jungleFiles: string;
+    program: string;
+    hasTests?: undefined;
+} | {
+    jungleFiles: string;
+    program: string;
+    hasTests: boolean;
+}>;
+export declare type PreAnalysis = {
+    fnMap: FilesToOptimizeMap;
+    paths: string[];
+};
+declare type RequiredNonNull<T> = {
+    [K1 in keyof T]-?: {
+        [K2 in keyof T[K1]]-?: NonNullable<T[K1][K2]>;
+    };
+};
+export declare type Analysis = {
+    fnMap: RequiredNonNull<FilesToOptimizeMap>;
+    paths: string[];
+    state: ProgramState;
+};
+export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, options: BuildConfig): Promise<Analysis | PreAnalysis>;
+/**
+ *
+ * @param {BuildConfig} options
+ * @returns
+ */
+export declare function generateApiMirTests(options: BuildConfig): Promise<void>;

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

@@ -0,0 +1,14 @@
+export declare const isWin: boolean;
+export declare const appSupport: string;
+export declare const connectiq: string;
+export declare function getSdkPath(): Promise<string>;
+export declare function getDeviceInfo(): Promise<{
+    [key: string]: {
+        appTypes: {
+            memoryLimit: number;
+            type: string;
+        }[];
+        deviceFamily: string;
+    };
+}>;
+export declare function getLanguages(): Promise<any>;

package/build/src/util.d.ts

@@ -0,0 +1,14 @@
+export declare function globa(pattern: string, options?: {
+    [key: string]: unknown;
+}): Promise<Array<string>>;
+export declare function last_modified(inputs: string[]): Promise<number>;
+export declare function first_modified(inputs: string[]): Promise<number>;
+export declare function pushUnique<T>(arr: T[], value: T): void;
+declare 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>, parallelism: number): Promise<T[]>;
+export declare function copyRecursiveAsNeeded(source: string, target: string, filter?: (src: string, tgt: string) => boolean): Promise<void>;
+export {};