@vorplex/compiler 0.0.8 → 0.0.11

package/dist/compiler.util.d.ts

@@ -0,0 +1,14 @@
+import { Task } from '@vorplex/core';
+import { type DependencyTree } from './npm/npm.util';
+export interface CompilerOptions {
+    files: Record<string, {
+        content: string;
+        dependencyTree?: DependencyTree;
+    }>;
+    entryFilePath: string;
+    sourcemaps?: boolean;
+    task?: Task;
+}
+export declare class Compiler {
+    static compile(options: CompilerOptions): Promise<string>;
+}

package/dist/compiler.util.js

@@ -0,0 +1,88 @@
+import { Task } from '@vorplex/core';
+import { stringify } from 'yaml';
+import { Bundler } from './module-loader/bundler';
+import { JsDelivr } from './npm/jsdelivr/jsdelivr.util';
+import { NPM } from './npm/npm.util';
+export class Compiler {
+    static async compile(options) {
+        const task = options.task ?? new Task('Compile');
+        try {
+            task.log(`Compiling $[files] using entry file path (${options.entryFilePath})`, { attachments: { files: { type: 'yaml', value: stringify(options.files) } } });
+            return await Bundler.bundle({
+                path: options.entryFilePath,
+                script: options.files[options.entryFilePath].content,
+                sourcemaps: options.sourcemaps,
+                resolve: async ({ importerPath, importPath, importStack }) => {
+                    return await task.do(`Resolving: ${importPath}`, async (task) => {
+                        if (importPath in options.files) {
+                            task.log('Returning local file $[content]', { attachments: { content: { type: 'typescript', value: options.files[importPath].content } } });
+                            return { content: options.files[importPath].content };
+                        }
+                        if (importPath.startsWith('https://')) {
+                            if (importPath.startsWith(JsDelivr.url)) {
+                                const { name, version, path } = JsDelivr.parseUrl(importPath);
+                                try {
+                                    const file = await JsDelivr.getFile(name, version, path);
+                                    task.log('Returning file $[content] from CDN', { attachments: { content: { type: 'text', value: file.content } } });
+                                    return {
+                                        path: file.url,
+                                        content: file.content,
+                                    };
+                                }
+                                catch (error) {
+                                    task.fail(error);
+                                    throw error;
+                                }
+                            }
+                            else {
+                                task.log('Fetching external file content');
+                                const response = await fetch(importPath);
+                                if (!response.ok)
+                                    throw new Error(`Failed to resolve import (${importPath}). ${response.statusText}`);
+                                const content = await response.text();
+                                task.log('Returning external file $[content]', { attachments: { content: { type: 'text', value: content } } });
+                                return { content };
+                            }
+                        }
+                        try {
+                            const dependencyTree = options.files[importStack.find(importPath => options.files[importPath]?.dependencyTree)]?.dependencyTree ?? options.files[importPath].dependencyTree ?? {};
+                            const string = NPM.parseImportString(importPath);
+                            task.log(`Package ${string.packageName} subpath ${string.subpath} version ${string.version}`);
+                            if (!string.version) {
+                                if (importerPath in options.files) {
+                                    string.version = options.files[importerPath].dependencyTree[string.packageName]?.version;
+                                }
+                                else {
+                                    const importer = JsDelivr.parseUrl(importerPath);
+                                    string.version = importer.name !== string.packageName ? NPM.resolveDependencyVersion(dependencyTree, importer.name, importer.version, string.packageName) : importer.version;
+                                    if (!string.version) {
+                                        task.log(`Returning mock module for package (${string.packageName}) as import (${importer.name}) doesn't have it as a dependency.`, { level: 'warning' });
+                                        return;
+                                    }
+                                }
+                            }
+                            if (!string.version)
+                                throw new Error(`Unable to determine package (${string.packageName}) version.`);
+                            const filePath = await JsDelivr.resolveImportFilePath(string.packageName, string.version, string.subpath);
+                            task.log(`Import resolved to file path (${filePath})`);
+                            const file = await JsDelivr.getFile(string.packageName, string.version, filePath);
+                            task.log('Returning file $[content] from CDN', { attachments: { content: { type: 'text', value: file.content } } });
+                            return { path: file.url, content: file.content };
+                        }
+                        catch (error) {
+                            task.fail(error);
+                            throw error;
+                        }
+                    });
+                },
+            });
+        }
+        catch (error) {
+            task.fail(error);
+            throw error;
+        }
+        finally {
+            task.complete();
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './compiler.util';
+export * from './script-analyzer.util';
+export * from './module-loader/bundler';
+export * from './module-loader/module-loader.util';
+export * from './npm/npm.util';
+export * from './npm/package-json.type';
+export * from './npm/jsdelivr/jsdelivr.util';

package/dist/index.js

@@ -0,0 +1,8 @@
+// **/*.ts
+export * from './compiler.util';
+export * from './script-analyzer.util';
+export * from './module-loader/bundler';
+export * from './module-loader/module-loader.util';
+export * from './npm/npm.util';
+export * from './npm/package-json.type';
+export * from './npm/jsdelivr/jsdelivr.util';

package/dist/module-loader/bundler.d.ts

@@ -0,0 +1,20 @@
+export declare class Bundler {
+    private static initialize;
+    static bundle(options: {
+        path: string;
+        script: string;
+        sourcemaps?: boolean;
+        resolve: (event: {
+            namespace: string;
+            importerPath: string;
+            importPath: string;
+            relative: boolean;
+            importStack: string[];
+        }) => Promise<{
+            namespace: string;
+        } | {
+            path?: string;
+            content: string;
+        }>;
+    }): Promise<string>;
+}

package/dist/module-loader/bundler.js

@@ -0,0 +1,106 @@
+import { $Path, State } from '@vorplex/core';
+import { build, initialize } from 'esbuild-wasm';
+import { JsDelivr } from '../npm/jsdelivr/jsdelivr.util';
+export class Bundler {
+    static async initialize() {
+        const initialized = (Bundler.initialize[':state'] ??= new State());
+        if (initialized.value === undefined) {
+            initialized.update('initializing');
+            try {
+                await initialize({
+                    wasmURL: $Path.join(JsDelivr.url, 'esbuild-wasm@0.25.12', 'esbuild.wasm'),
+                });
+                initialized.update('initialized');
+            }
+            catch (error) {
+                initialized.update(undefined);
+                throw error;
+            }
+        }
+        await initialized.until((initialized) => initialized.value === 'initialized');
+    }
+    static async bundle(options) {
+        await Bundler.initialize();
+        const result = await build({
+            stdin: {
+                contents: options.script,
+                resolveDir: '/',
+                loader: 'ts',
+            },
+            plugins: [
+                {
+                    name: 'module-loader-resolver',
+                    setup: (build) => {
+                        const files = {};
+                        const importParent = {};
+                        const importPathAlias = {};
+                        build.onResolve({ filter: /.*/ }, async (args) => {
+                            const relative = args.path.startsWith('.') || args.path.startsWith('/');
+                            const importerPath = args.importer === '<stdin>' ? options.path : args.importer;
+                            const importPath = relative ? $Path.join(importerPath, `../${args.path}`) : args.path;
+                            importParent[importPath] = importerPath;
+                            let importStack = [];
+                            let parentPath = importerPath;
+                            while (parentPath) {
+                                importStack.push(parentPath);
+                                parentPath = importParent[importPathAlias[parentPath]] ?? importParent[parentPath];
+                            }
+                            const resolved = await options.resolve({
+                                namespace: args.path,
+                                importerPath,
+                                importPath,
+                                relative,
+                                importStack
+                            });
+                            if (!resolved)
+                                return { path: importPath, namespace: 'mock' };
+                            if ('content' in resolved) {
+                                files[resolved.path ?? importPath] = resolved.content;
+                                if (resolved.path)
+                                    importPathAlias[resolved.path] = importPath;
+                                return {
+                                    path: resolved.path ?? importPath,
+                                    namespace: 'virtual',
+                                };
+                            }
+                            else
+                                return {
+                                    path: resolved.namespace,
+                                    external: true,
+                                };
+                        });
+                        build.onLoad({ filter: /.*/, namespace: 'virtual' }, (args) => {
+                            const loaders = {
+                                '.tsx': 'tsx',
+                                '.ts': 'ts',
+                                '.js': 'js',
+                                '.jsx': 'jsx',
+                                '.css': 'css',
+                                '.json': 'json',
+                            };
+                            const extension = $Path.getExtension(args.path);
+                            const loader = loaders[extension];
+                            const file = files[args.path];
+                            delete files[args.path];
+                            return { contents: file, loader };
+                        });
+                        build.onLoad({ filter: /.*/, namespace: 'mock' }, (args) => {
+                            return { contents: 'export default {}' };
+                        });
+                    },
+                },
+            ],
+            sourcemap: options.sourcemaps ? 'inline' : false,
+            mainFields: ['module', 'main'],
+            conditions: ['import', 'module'],
+            bundle: true,
+            format: 'cjs',
+            target: 'esnext',
+            platform: 'browser',
+            minify: !options.sourcemaps,
+            treeShaking: !options.sourcemaps,
+            logLevel: 'silent',
+        });
+        return result.outputFiles[0].text;
+    }
+}

package/dist/module-loader/module-loader.util.d.ts

@@ -0,0 +1,10 @@
+export declare class ModuleLoader {
+    static resolver?: (namespace: string) => any;
+    static registry: Record<string, Record<string, any>>;
+    static evaluate(code: string, context?: Record<string, any>): Record<string, any>;
+    static evaluateAsync(code: string, context?: Record<string, any>): Promise<Record<string, any>>;
+    static import(bundle: string): Promise<Record<string, any>>;
+    static resolve(namespace: string): any;
+    static registerModule(name: string, version: string, module: any): void;
+    static registerBundle(name: string, version: string, bundle: string): void;
+}

package/dist/module-loader/module-loader.util.js

@@ -0,0 +1,60 @@
+import { $String } from '@vorplex/core';
+import { maxSatisfying } from 'semver';
+import { NPM } from '../npm/npm.util';
+export class ModuleLoader {
+    static resolver;
+    static registry = {};
+    static evaluate(code, context = {}) {
+        if (!code)
+            return null;
+        const func = new Function('context', 'module', `with (context) {${code}}`);
+        const module = { exports: {} };
+        const require = (namespace) => ModuleLoader.resolve(namespace);
+        const define = (deps, factory) => {
+            factory(require, module.exports);
+        };
+        func.call(context, { require, define, exports: module.exports, ...context }, module);
+        return module.exports;
+    }
+    static async evaluateAsync(code, context = {}) {
+        code = `return (async function() {${code}})();`;
+        return ModuleLoader.evaluate(code, context);
+    }
+    static async import(bundle) {
+        const blob = new Blob([bundle], { type: 'application/javascript' });
+        const url = URL.createObjectURL(blob);
+        try {
+            return await import(url);
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    }
+    static resolve(namespace) {
+        const string = NPM.parseImportString(namespace);
+        if (ModuleLoader.resolver) {
+            const module = ModuleLoader.resolver(namespace);
+            if (module) {
+                ModuleLoader.registerModule(string.packageName, string.version ?? '<default>', module);
+                return module;
+            }
+        }
+        const versions = ModuleLoader.registry[string.packageName];
+        if (versions) {
+            if (versions) {
+                const version = versions[string.version] ?? versions['latest'] ?? versions[maxSatisfying(Object.keys(versions), '*')] ?? versions['<default>'];
+                const subpath = string.subpath ? `${$String.toAlphanumeric(string.packageName, '_')}__${$String.toAlphanumeric(string.subpath, '_')}` : null;
+                if (version)
+                    return subpath ? version[subpath] : version;
+            }
+        }
+        throw new Error(`No package was registered for import (${namespace})`);
+    }
+    static registerModule(name, version, module) {
+        ModuleLoader.registry[name] = Object.assign({}, ModuleLoader.registry[name], { [version]: module });
+    }
+    static registerBundle(name, version, bundle) {
+        const module = ModuleLoader.evaluate(bundle);
+        ModuleLoader.registerModule(name, version, module);
+    }
+}

package/dist/npm/jsdelivr/jsdelivr.util.d.ts

@@ -0,0 +1,37 @@
+import type { PackageJson } from '../package-json.type';
+export interface JsDelivrData {
+    name: string;
+    version: string;
+    default: string;
+    files: JsDelivrFileEntry[];
+}
+export interface JsDelivrFileEntry {
+    type: 'directory' | 'file';
+    name: string;
+    files: JsDelivrFileEntry[];
+}
+export declare class JsDelivr {
+    static readonly url: "https://cdn.jsdelivr.net/npm";
+    static readonly dataUrl: "https://data.jsdelivr.com/v1/packages/npm";
+    static readonly resolveUrl: "https://data.jsdelivr.com/v1/package/resolve/npm";
+    static packageVersionCache: Record<string, Record<string, string>>;
+    static resolveVersion(name: string, semanticVersion?: string): Promise<string>;
+    static getPackageVersions(name: string): Promise<string[]>;
+    static getData(name: string, semanticVersion: string): Promise<JsDelivrData>;
+    static getFilePaths(name: string, semanticVersion: string, regex?: RegExp): Promise<string[]>;
+    static resolveFilePath(name: string, semanticVersion: string, path: string): Promise<string>;
+    static getFile(name: string, semanticVersion: string, path?: string): Promise<{
+        packageName: string;
+        packageVersion: string;
+        url: string;
+        path?: string;
+        content: string;
+    }>;
+    static getPackageJson(name: string, semanticVersion: string): Promise<PackageJson>;
+    static parseUrl(url: string): {
+        name: string;
+        version: string;
+        path?: string;
+    };
+    static resolveImportFilePath(packageName: string, semanticVersion: string, subpath?: string): Promise<string>;
+}

package/dist/npm/jsdelivr/jsdelivr.util.js

@@ -0,0 +1,156 @@
+import { $Path, $String } from '@vorplex/core';
+export class JsDelivr {
+    static url = 'https://cdn.jsdelivr.net/npm';
+    static dataUrl = 'https://data.jsdelivr.com/v1/packages/npm';
+    static resolveUrl = 'https://data.jsdelivr.com/v1/package/resolve/npm';
+    static packageVersionCache = {};
+    static async resolveVersion(name, semanticVersion) {
+        semanticVersion ??= 'latest';
+        if (this.packageVersionCache[name]?.[semanticVersion])
+            return this.packageVersionCache[name][semanticVersion];
+        const url = $Path.join(this.resolveUrl, `${name}@${semanticVersion}`);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch package (${name}) version (${semanticVersion}). ${response.statusText}`);
+        const data = (await response.json());
+        this.packageVersionCache[name] = Object.assign({}, this.packageVersionCache[name], { [semanticVersion]: data.version });
+        return data.version;
+    }
+    static async getPackageVersions(name) {
+        const url = $Path.join(this.dataUrl, name);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch package (${name}) versions. ${response.statusText}`);
+        const data = (await response.json());
+        return data.versions.map((version) => version.version);
+    }
+    static async getData(name, semanticVersion) {
+        const version = await this.resolveVersion(name, semanticVersion);
+        const url = $Path.join(this.dataUrl, `${name}@${version}`);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch package (${name}) metadata. ${response.statusText}`);
+        return await response.json();
+    }
+    static async getFilePaths(name, semanticVersion, regex) {
+        const version = await this.resolveVersion(name, semanticVersion);
+        const metadata = await this.getData(name, version);
+        function getFiles(target, path) {
+            const files = [];
+            for (const entry of target.files) {
+                const entryPath = $Path.join(path, entry.name);
+                if (entry.type === 'directory')
+                    files.push(...getFiles(entry, entryPath));
+                else if (entryPath.match(regex))
+                    files.push(entryPath);
+            }
+            return files;
+        }
+        return getFiles(metadata, '/');
+    }
+    static async resolveFilePath(name, semanticVersion, path) {
+        const paths = await this.getFilePaths(name, semanticVersion, new RegExp('^' + $String.sanitizeForRegex($Path.absolute(path)) + '(?:\\.js|/index.js)?$'));
+        function getPathPriority(filePath) {
+            if (filePath === path)
+                return 4;
+            if (filePath === path + '.js')
+                return 3;
+            if (filePath === path + '/index.js')
+                return 2;
+            return 1;
+        }
+        return paths.sort((a, b) => getPathPriority(b) - getPathPriority(a))[0];
+    }
+    static async getFile(name, semanticVersion, path) {
+        const resolvedPath = path ? await this.resolveFilePath(name, semanticVersion, path) : null;
+        if (path && !resolvedPath)
+            throw new Error(`Failed to resolve path (${path}) from package (${name}) version (${semanticVersion}). Not Found.`);
+        const url = $Path.join(this.url, `${name}@${semanticVersion ?? 'latest'}`, resolvedPath);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch package (${name}) file (${resolvedPath ?? '<default>'}). ${response.statusText}`);
+        const version = response.headers.get('x-jsd-version');
+        return {
+            packageName: name,
+            packageVersion: version,
+            url: $Path.join(this.url, `${name}@${version}`, resolvedPath),
+            path: resolvedPath,
+            content: await response.text(),
+        };
+    }
+    static async getPackageJson(name, semanticVersion) {
+        const { content } = await this.getFile(name, semanticVersion, 'package.json');
+        return JSON.parse(content);
+    }
+    static parseUrl(url) {
+        return url.match(/https:\/\/cdn\.jsdelivr\.net\/npm\/(?<name>@?[^@]+)@(?<version>[^/]+)(?:\/(?<path>.*))?/)?.groups;
+    }
+    static async resolveImportFilePath(packageName, semanticVersion, subpath) {
+        const packageJson = await this.getPackageJson(packageName, semanticVersion);
+        if (packageJson.exports) {
+            const resolveExports = async (exports) => {
+                const result = {};
+                if (typeof exports === 'string')
+                    return { '.': $Path.relative(exports) };
+                const resolveExportPath = (path) => {
+                    if (!path)
+                        return;
+                    if (typeof path === 'string')
+                        return path;
+                    if (typeof path !== 'object')
+                        return;
+                    const priorities = ['browser', 'import', 'es2015', 'module', 'default', 'node', 'require'];
+                    for (const priority of priorities) {
+                        const resolvedPath = resolveExportPath(path[priority]);
+                        if (resolvedPath)
+                            return resolvedPath;
+                    }
+                };
+                for (const [path, value] of Object.entries(exports)) {
+                    let targetPath = resolveExportPath(value);
+                    if (!targetPath || targetPath === './')
+                        continue;
+                    if (targetPath.startsWith('./'))
+                        targetPath = targetPath.slice(2);
+                    if ($Path.getExtension(targetPath) === '.cjs')
+                        continue;
+                    if (targetPath.includes('*')) {
+                        const regex = new RegExp(`^${$String.sanitizeForRegex(targetPath).replace('\\*', '(.+)')}$`);
+                        const files = await this.getFilePaths(packageName, semanticVersion, regex);
+                        for (const file of files) {
+                            const fileExtension = $Path.getExtension(file);
+                            if (!['.js', '.mjs', '.json', '.jsx'].includes(fileExtension))
+                                continue;
+                            const wildcard = file.match(regex)[1];
+                            const resolvedPath = path.replaceAll('*', wildcard);
+                            const resolvedTargetPath = targetPath.replaceAll('*', wildcard);
+                            if (Object.values(result).includes($Path.relative(resolvedTargetPath)))
+                                continue;
+                            result[resolvedPath] = $Path.relative(resolvedTargetPath);
+                        }
+                    }
+                    else {
+                        if (Object.values(result).includes($Path.relative(targetPath)))
+                            continue;
+                        result[path] = $Path.relative(targetPath);
+                    }
+                }
+                return result;
+            };
+            const exports = await resolveExports(packageJson.exports);
+            if (!subpath && exports['.'])
+                return $Path.absolute(exports['.']);
+            if (subpath && exports[$Path.relative(subpath)])
+                return $Path.absolute(exports[$Path.relative(subpath)]);
+        }
+        if (subpath) {
+            const file = await this.resolveFilePath(packageName, semanticVersion, subpath);
+            if (file)
+                return file;
+        }
+        else {
+            return $Path.absolute(packageJson.module || packageJson.main || 'index.js');
+        }
+        throw new Error(`Failed to resolve file path for import (${packageName}${subpath ? `/${subpath}` : ''}@${semanticVersion})`);
+    }
+}

package/dist/npm/npm.util.d.ts

@@ -0,0 +1,24 @@
+import { Task } from '@vorplex/core';
+import type { PackageJson } from './package-json.type';
+export type DependencyTree = Record<string, DependencyNode>;
+export interface DependencyNode {
+    version: string;
+    dependencies: Record<string, DependencyNode>;
+}
+export declare class NPM {
+    static readonly url: "https://registry.npmjs.org";
+    static getData(name: string): Promise<any>;
+    static gePackageJson(name: string, version: string): Promise<PackageJson>;
+    static resolveDependencyTree(packages: Record<string, string>, resolver: {
+        getPackageJson: (name: string, version: string) => Promise<PackageJson>;
+        getPackageVersions: (name: string) => Promise<string[]>;
+    }, task?: Task): Promise<DependencyTree>;
+    static flattenDependencyTree(tree: DependencyTree): Record<string, string[]>;
+    static resolveDependencyVersion(tree: DependencyTree, parent: string, version: string, name: string): string;
+    static getScriptImports(script: string): string[];
+    static parseImportString(string: string): {
+        packageName: string;
+        subpath?: string;
+        version?: string;
+    };
+}

package/dist/npm/npm.util.js

@@ -0,0 +1,132 @@
+import { $Path, Task } from '@vorplex/core';
+import { maxSatisfying, satisfies } from 'semver';
+import { stringify } from 'yaml';
+export class NPM {
+    static url = 'https://registry.npmjs.org';
+    static async getData(name) {
+        const response = await fetch($Path.join(NPM.url, name));
+        if (!response.ok)
+            throw new Error(`Failed to get package (${name}) data. ${response.statusText}`);
+        return await response.json();
+    }
+    static async gePackageJson(name, version) {
+        const response = await fetch($Path.join(NPM.url, name, version));
+        if (!response.ok)
+            throw new Error(`Failed to get package (${name}) data. ${response.statusText}`);
+        return await response.json();
+    }
+    static async resolveDependencyTree(packages, resolver, task = new Task('Resolve Dependency Tree')) {
+        try {
+            const seen = {};
+            async function resolvePackage(name, range, ancestors = [], task) {
+                task.log(`Resolving package (${name}@${range})`);
+                if (range === 'latest')
+                    range = '*';
+                task.log(`Searching for package in ancestors`);
+                for (const ancestor of ancestors) {
+                    const existing = ancestor.dependencies?.[name];
+                    if (existing && satisfies(existing.version, range, { includePrerelease: true })) {
+                        task.log(`Existing package found. Deduping`);
+                        return existing;
+                    }
+                }
+                task.log(`No existing package found in ancestors`);
+                task.log('Resolving package versions');
+                const available = await resolver.getPackageVersions(name);
+                const version = maxSatisfying(available, range, { includePrerelease: true });
+                if (!version) {
+                    throw new Error(`No version found for ${name}@${range}`);
+                }
+                task.log(`Version (${version}) was resolved for range (${range})`);
+                const key = `${name}@${version}`;
+                if (seen[key]) {
+                    task.log(`Reusing globally deduped package`);
+                    return seen[key];
+                }
+                task.log(`Resolving package.json`);
+                const pkg = await resolver.getPackageJson(name, version);
+                task.log(`$[package.json] resolved`, { attachments: { 'package.json': { type: 'yaml', value: stringify(pkg) } } });
+                const node = { version, dependencies: {} };
+                seen[key] = node;
+                if (pkg.dependencies) {
+                    task.log('Resolving packages dependencies.');
+                    for (const [depName, depRange] of Object.entries(pkg.dependencies)) {
+                        await task.do(`${depName}@${depRange}`, async (task) => {
+                            node.dependencies[depName] = await resolvePackage(depName, depRange, [node, ...ancestors], task);
+                        });
+                    }
+                    task.log('Done resolving packages dependencies.');
+                }
+                if (pkg.peerDependencies) {
+                    task.log('Resolving packages peer-dependencies.');
+                    for (const [peerName, peerRange] of Object.entries(pkg.peerDependencies)) {
+                        await task.do(`${peerName}@${peerRange}`, async (task) => {
+                            node.dependencies[peerName] = await resolvePackage(peerName, peerRange, ancestors, task);
+                        });
+                    }
+                    task.log('Done resolving packages peer-dependencies.');
+                }
+                return node;
+            }
+            const tree = {};
+            task.log('Resolving packages');
+            for (const [name, range] of Object.entries(packages)) {
+                await task.do(`${name}@${range}`, async (task) => {
+                    tree[name] = await resolvePackage(name, range, [], task);
+                });
+            }
+            task.log('Done resolving packages');
+            task.log('Done resolving dependency tree');
+            return tree;
+        }
+        catch (error) {
+            task.fail(error);
+            throw error;
+        }
+        finally {
+            task.complete();
+        }
+    }
+    static flattenDependencyTree(tree) {
+        function flatten(tree, visited = new Set()) {
+            const flattened = {};
+            for (const [name, data] of Object.entries(tree)) {
+                const key = `${name}@${data.version}`;
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                flattened[name] = [...(flattened[name] ?? []), data.version];
+                if (data.dependencies) {
+                    for (const [dependency, version] of Object.entries(flatten(data.dependencies, visited))) {
+                        flattened[dependency] = [...(flattened[dependency] ?? []), ...version];
+                    }
+                }
+            }
+            return flattened;
+        }
+        return flatten(tree);
+    }
+    static resolveDependencyVersion(tree, parent, version, name) {
+        const resolve = (tree) => {
+            for (const [packName, pack] of Object.entries(tree)) {
+                if (packName === parent && pack.version === version)
+                    return pack.dependencies[name]?.version;
+                const dependency = resolve(pack.dependencies);
+                if (dependency)
+                    return dependency;
+            }
+        };
+        return resolve(tree);
+    }
+    static getScriptImports(script) {
+        return Array.from(script.matchAll(/import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]|require\(['"]([^'"]+)['"]\)/g)).map((match) => match[1] ?? match[2]);
+    }
+    static parseImportString(string) {
+        if (!string)
+            throw new Error('Invalid import string');
+        const match = string.match(/^(?<packageName>(?:@[\w-]+\/[\w-]+|[\w-]+))(?:\/(?<subpath>.+?))?(?:\/?@(?<version>\d+(?:\.\d+)*(?:-[\w.]+)?(?:\+[\w.]+)?))?$/);
+        if (!match)
+            throw new Error(`Invalid import string (${string})`);
+        return match?.groups;
+    }
+}

package/dist/npm/package-json.type.d.ts

@@ -0,0 +1,19 @@
+export type PackageJsonExports = string | Record<string, {
+    import?: string;
+    browser?: string;
+    require?: string;
+    default?: string;
+} | string> | PackageJsonExports[];
+export interface PackageJson {
+    name: string;
+    version: string;
+    main?: string;
+    module?: string;
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    types?: string;
+    typings?: string;
+    typescript?: string;
+    browser?: string | Record<string, string | false>;
+    exports?: PackageJsonExports | Record<string, PackageJsonExports>;
+}

package/dist/script-analyzer.util.d.ts

@@ -0,0 +1,3 @@
+export declare class $ScriptAnalyzer {
+    static getDefaultExportPublicMethodNames(code: string): string[];
+}

package/dist/script-analyzer.util.js

@@ -0,0 +1,26 @@
+import ts from 'typescript';
+export class $ScriptAnalyzer {
+    static getDefaultExportPublicMethodNames(code) {
+        const sourceFile = ts.createSourceFile('script.ts', code, ts.ScriptTarget.Latest, true);
+        const methods = [];
+        ts.forEachChild(sourceFile, node => {
+            if (ts.isClassDeclaration(node)) {
+                const modifiers = ts.getModifiers(node);
+                const hasExport = modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                const hasDefault = modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword);
+                if (hasExport && hasDefault) {
+                    for (const member of node.members) {
+                        if (ts.isMethodDeclaration(member) && member.name) {
+                            const modifiers = member.modifiers ?? [];
+                            if (modifiers.find(modifier => modifier.kind === ts.SyntaxKind.ProtectedKeyword || modifier.kind === ts.SyntaxKind.PrivateKeyword))
+                                return;
+                            const name = ts.isIdentifier(member.name) ? member.name.text : member.name.getText(sourceFile);
+                            methods.push(name);
+                        }
+                    }
+                }
+            }
+        });
+        return methods;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/compiler",
-  "version": "0.0.8",
+  "version": "0.0.11",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -15,12 +15,12 @@
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
   "dependencies": {
-    "esbuild-wasm": "^0.25.10",
+    "esbuild-wasm": "0.25.12",
     "semver": "^7.7.3",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "yaml": "^2.8.2",
-    "@vorplex/core": "0.0.8"
+    "@vorplex/core": "0.0.11"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",