@esportsplus/typescript 0.26.4 → 0.27.1

package/build/cli/tsc.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'url';
 import path from 'path';
 import ts from 'typescript';
 import coordinator from '../compiler/coordinator.js';
+import { PACKAGE_NAME } from '../constants.js';
 const BACKSLASH_REGEX = /\\/g;
 let require = createRequire(import.meta.url), skipFlags = new Set(['--help', '--init', '--noEmit', '--showConfig', '--version', '-h', '-noEmit', '-v']);
 async function build(config, tsconfig, pluginConfigs) {
@@ -54,6 +55,9 @@ async function build(config, tsconfig, pluginConfigs) {
     }
     return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
 }
+function isPlugin(value) {
+    return typeof value === 'object' && value !== null && 'transform' in value && typeof value.transform === 'function';
+}
 async function loadPlugins(configs, root) {
     let plugins = [], promises = [];
     for (let i = 0, n = configs.length; i < n; i++) {
@@ -69,8 +73,19 @@ async function loadPlugins(configs, root) {
             if (typeof plugin === 'function') {
                 plugin = plugin();
             }
-            if (!plugin || typeof plugin.transform !== 'function') {
-                console.error(`Plugin ${config.transform}: invalid plugin format, expected { transform: Function }`);
+            if (Array.isArray(plugin)) {
+                for (let j = 0, m = plugin.length; j < m; j++) {
+                    if (isPlugin(plugin[j])) {
+                        plugins.push(plugin[j]);
+                    }
+                    else {
+                        console.error(`${PACKAGE_NAME}: plugin ${config.transform}[${j}] uses an invalid plugin format`);
+                    }
+                }
+                return;
+            }
+            if (!isPlugin(plugin)) {
+                console.error(`${PACKAGE_NAME}: plugin ${config.transform} uses an invalid plugin format, expected { transform: Function } or Plugin[]`);
                 return;
             }
             plugins.push(plugin);
@@ -92,9 +107,9 @@ function main() {
     if (pluginConfigs.length === 0) {
         return passthrough();
     }
-    console.log(`Found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
+    console.log(`${PACKAGE_NAME}: found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
     build(config, tsconfig, pluginConfigs).catch((err) => {
-        console.error(err);
+        console.error(`${PACKAGE_NAME}: ${err}`);
         process.exit(1);
     });
 }

package/build/compiler/ast.d.ts

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+type Range = {
+    end: number;
+    start: number;
+};
+declare const _default: {
+    expression: {
+        name: (node: ts.Expression) => string | null;
+    };
+    inRange: (ranges: Range[], start: number, end: number) => boolean;
+    property: {
+        path: (node: ts.Expression) => string | null;
+    };
+    test: (node: ts.Node, fn: (n: ts.Node) => boolean) => boolean;
+};
+export default _default;
+export type { Range };

package/build/compiler/ast.js

@@ -0,0 +1,42 @@
+import ts from 'typescript';
+const expression = {
+    name: (node) => {
+        if (ts.isIdentifier(node)) {
+            return node.text;
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            return property.path(node);
+        }
+        return null;
+    }
+};
+const inRange = (ranges, start, end) => {
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let r = ranges[i];
+        if (start >= r.start && end <= r.end) {
+            return true;
+        }
+    }
+    return false;
+};
+const property = {
+    path: (node) => {
+        let current = node, parts = [];
+        while (ts.isPropertyAccessExpression(current)) {
+            parts.push(current.name.text);
+            current = current.expression;
+        }
+        if (ts.isIdentifier(current)) {
+            parts.push(current.text);
+            return parts.reverse().join('.');
+        }
+        return null;
+    }
+};
+const test = (node, fn) => {
+    if (fn(node)) {
+        return true;
+    }
+    return !!ts.forEachChild(node, child => test(child, fn) || undefined);
+};
+export default { expression, inRange, property, test };

package/build/compiler/coordinator.js

@@ -55,7 +55,7 @@ function modify(code, file, pkg, options) {
     if (!options.add && !options.namespace && !options.remove) {
         return code;
     }
-    let { namespace } = options, add = options.add ? new Set(options.add) : null, found = imports.find(file, pkg);
+    let { namespace } = options, add = options.add ? new Set(options.add) : null, found = imports.all(file, pkg);
     if (found.length === 0) {
         let statements = [];
         if (namespace) {
@@ -117,39 +117,36 @@ const transform = (plugins, code, file, program, shared) => {
     if (plugins.length === 0) {
         return { changed: false, code, sourceFile: file };
     }
-    let changed = false, currentCode = code, currentSourceFile = file;
+    let currentCode = code, currentFile = file;
     for (let i = 0, n = plugins.length; i < n; i++) {
         let plugin = plugins[i];
         if (plugin.patterns && !hasPattern(currentCode, plugin.patterns)) {
             continue;
         }
-        let result = plugin.transform({
+        let { imports, prepend, replacements } = plugin.transform({
             checker: program.getTypeChecker(),
             code: currentCode,
             program,
             shared,
-            sourceFile: currentSourceFile
+            sourceFile: currentFile
         });
-        let hasChanges = (result.imports && result.imports.length > 0) ||
-            (result.prepend && result.prepend.length > 0) ||
-            (result.replacements && result.replacements.length > 0);
-        if (!hasChanges) {
-            continue;
-        }
-        changed = true;
-        if (result.replacements && result.replacements.length > 0) {
-            currentCode = applyIntents(currentCode, currentSourceFile, result.replacements);
-            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        if (replacements?.length) {
+            currentCode = applyIntents(currentCode, currentFile, replacements);
+            currentFile = ts.createSourceFile(currentFile.fileName, currentCode, currentFile.languageVersion, true);
         }
-        if (result.prepend && result.prepend.length > 0) {
-            currentCode = applyPrepend(currentCode, currentSourceFile, result.prepend);
-            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        if (prepend?.length) {
+            currentCode = applyPrepend(currentCode, currentFile, prepend);
+            currentFile = ts.createSourceFile(currentFile.fileName, currentCode, currentFile.languageVersion, true);
         }
-        if (result.imports && result.imports.length > 0) {
-            currentCode = applyImports(currentCode, currentSourceFile, result.imports);
-            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        if (imports?.length) {
+            currentCode = applyImports(currentCode, currentFile, imports);
+            currentFile = ts.createSourceFile(currentFile.fileName, currentCode, currentFile.languageVersion, true);
         }
     }
-    return { changed, code: currentCode, sourceFile: currentSourceFile };
+    return {
+        changed: currentCode !== code,
+        code: currentCode,
+        sourceFile: currentFile
+    };
 };
 export default { transform };

package/build/compiler/imports.d.ts

@@ -10,8 +10,8 @@ type ModifyOptions = {
     remove?: Iterable<string>;
 };
 declare const _default: {
-    find: (sourceFile: ts.SourceFile, packageName: string) => ImportInfo[];
-    inPackage: (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string, packageImports?: Set<string>) => boolean;
+    all: (file: ts.SourceFile, pkg: string) => ImportInfo[];
+    includes: (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string) => boolean;
 };
 export default _default;
 export type { ImportInfo, ModifyOptions };

package/build/compiler/imports.js

@@ -1,13 +1,14 @@
 import { ts } from '../index.js';
-const find = (sourceFile, packageName) => {
+let cache = new WeakMap();
+const all = (file, pkg) => {
     let imports = [];
-    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
-        let stmt = sourceFile.statements[i];
+    for (let i = 0, n = file.statements.length; i < n; i++) {
+        let stmt = file.statements[i];
         if (!ts.isImportDeclaration(stmt)) {
             continue;
         }
         let moduleSpecifier = stmt.moduleSpecifier;
-        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== packageName) {
+        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
             continue;
         }
         let bindings = stmt.importClause?.namedBindings, specifiers = new Map();
@@ -17,19 +18,32 @@ const find = (sourceFile, packageName) => {
                 specifiers.set(propertyName, name);
             }
         }
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(sourceFile) });
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file) });
     }
     return imports;
 };
-const inPackage = (checker, node, pkg, symbolName, packageImports) => {
-    if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
-        if (!symbolName || node.text === symbolName) {
-            return true;
+const includes = (checker, node, pkg, symbolName) => {
+    let file = node.getSourceFile(), imports = cache.get(file);
+    if (!imports) {
+        imports = new Map();
+        cache.set(file, imports);
+    }
+    let varnames = imports.get(pkg);
+    if (!varnames) {
+        varnames = new Set();
+        for (let info of all(file, pkg)) {
+            for (let [, varname] of info.specifiers) {
+                varnames.add(varname);
+            }
         }
+        imports.set(pkg, varnames);
+    }
+    if (ts.isIdentifier(node) && varnames.has(node.text) && (!symbolName || node.text === symbolName)) {
+        return true;
     }
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) {
-        if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+        if (ts.isIdentifier(node) && varnames.has(node.text)) {
             return true;
         }
         return false;
@@ -38,17 +52,17 @@ const inPackage = (checker, node, pkg, symbolName, packageImports) => {
         symbol = checker.getAliasedSymbol(symbol);
     }
     if (symbolName && symbol.name !== symbolName) {
-        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+        return ts.isIdentifier(node) && varnames.has(node.text);
     }
     let declarations = symbol.getDeclarations();
     if (!declarations || declarations.length === 0) {
-        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+        return ts.isIdentifier(node) && varnames.has(node.text);
     }
     for (let i = 0, n = declarations.length; i < n; i++) {
         if (declarations[i].getSourceFile().fileName.includes(pkg)) {
             return true;
         }
     }
-    return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+    return ts.isIdentifier(node) && varnames.has(node.text);
 };
-export default { find, inPackage };
+export default { all, includes };

package/build/compiler/index.d.ts

@@ -1,4 +1,4 @@
-export * as ast from './ast/index.js';
+export { default as ast } from './ast.js';
 export { default as code } from './code.js';
 export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';

package/build/compiler/index.js

@@ -1,4 +1,4 @@
-export * as ast from './ast/index.js';
+export { default as ast } from './ast.js';
 export { default as code } from './code.js';
 export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';

package/build/compiler/plugins/index.d.ts

@@ -1,7 +1,5 @@
 declare const _default: {
-    tsc: (plugins: import("../index.js").Plugin[]) => (program: import("typescript").Program, shared: import("../index.js").SharedContext) => {
-        transform: import("typescript").TransformerFactory<import("typescript").SourceFile>;
-    };
+    tsc: (plugins: import("../index.js").Plugin[]) => () => import("../index.js").Plugin[];
     vite: ({ name, onWatchChange, plugins }: {
         name: string;
         onWatchChange?: () => void;

package/build/compiler/plugins/tsc.d.ts

@@ -1,6 +1,3 @@
-import type { Plugin, SharedContext } from '../types.js';
-import type ts from 'typescript';
-declare const _default: (plugins: Plugin[]) => (program: ts.Program, shared: SharedContext) => {
-    transform: ts.TransformerFactory<ts.SourceFile>;
-};
+import type { Plugin } from '../types.js';
+declare const _default: (plugins: Plugin[]) => () => Plugin[];
 export default _default;

package/build/compiler/plugins/tsc.js

@@ -1,13 +1,3 @@
-import coordinator from '../coordinator.js';
 export default (plugins) => {
-    return (program, shared) => {
-        return {
-            transform: (() => {
-                return (sourceFile) => {
-                    let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, shared);
-                    return result.changed ? result.sourceFile : sourceFile;
-                };
-            })
-        };
-    };
+    return () => plugins;
 };

package/build/compiler/program.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import ts from 'typescript';
+import { PACKAGE_NAME } from '../constants.js';
 let cache = new Map();
 function create(root) {
     let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
@@ -8,11 +9,11 @@ function create(root) {
     }
     let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
     if (file.error) {
-        throw new Error(`Error reading tsconfig.json: ${file.error.messageText}`);
+        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
     }
     let parsed = ts.parseJsonConfigFileContent(file.config, ts.sys, path.dirname(tsconfig));
     if (parsed.errors.length > 0) {
-        throw new Error(`Error parsing tsconfig.json: ${parsed.errors[0].messageText}`);
+        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
     }
     return ts.createProgram({
         options: parsed.options,

package/build/compiler/uid.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (prefix: string) => string;
+declare const _default: (name: string) => string;
 export default _default;

package/build/compiler/uid.js

@@ -1,13 +1,5 @@
-const INVALID_CHARS = /[^A-Za-z0-9]/g;
-let counter = 0;
-function hash(str) {
-    let h = 0x811c9dc5;
-    for (let i = 0, n = str.length; i < n; i++) {
-        h ^= str.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return ((h >>> 0).toString(36) + Math.abs(h).toString(36)).replace(INVALID_CHARS, '');
-}
-export default (prefix) => {
-    return prefix + '_' + hash(prefix) + (counter++).toString(36);
+import { uuid } from '@esportsplus/utilities';
+let i = 0, namespace = uuid().replace(/[^A-Za-z0-9]/g, '');
+export default (name) => {
+    return name + '_' + namespace + (i++).toString(36);
 };

package/build/constants.d.ts

@@ -0,0 +1,2 @@
+declare const PACKAGE_NAME = "@esportsplus/typescript";
+export { PACKAGE_NAME };

package/build/constants.js

@@ -0,0 +1,2 @@
+const PACKAGE_NAME = '@esportsplus/typescript';
+export { PACKAGE_NAME };

package/package.json

@@ -37,7 +37,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.26.4",
+  "version": "0.27.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/cli/tsc.ts

@@ -5,6 +5,7 @@ import path from 'path';
 import ts from 'typescript';
 import coordinator from '~/compiler/coordinator';
 import type { Plugin, SharedContext } from '~/compiler/types';
+import { PACKAGE_NAME } from '~/constants';
 
 
 type PluginConfig = {
@@ -109,6 +110,10 @@ async function build(config: object, tsconfig: string, pluginConfigs: PluginConf
     return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
 }
 
+function isPlugin(value: unknown): value is Plugin {
+    return typeof value === 'object' && value !== null && 'transform' in value && typeof (value as Plugin).transform === 'function';
+}
+
 async function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugin[]> {
     let plugins: Plugin[] = [],
         promises: Promise<void>[] = [];
@@ -132,8 +137,21 @@ async function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugi
                     plugin = plugin();
                 }
 
-                if (!plugin || typeof plugin.transform !== 'function') {
-                    console.error(`Plugin ${config.transform}: invalid plugin format, expected { transform: Function }`);
+                if (Array.isArray(plugin)) {
+                    for (let j = 0, m = plugin.length; j < m; j++) {
+                        if (isPlugin(plugin[j])) {
+                            plugins.push(plugin[j]);
+                        }
+                        else {
+                            console.error(`${PACKAGE_NAME}: plugin ${config.transform}[${j}] uses an invalid plugin format`);
+                        }
+                    }
+
+                    return;
+                }
+
+                if (!isPlugin(plugin)) {
+                    console.error(`${PACKAGE_NAME}: plugin ${config.transform} uses an invalid plugin format, expected { transform: Function } or Plugin[]`);
                     return;
                 }
 
@@ -168,10 +186,10 @@ function main(): void {
         return passthrough();
     }
 
-    console.log(`Found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
+    console.log(`${PACKAGE_NAME}: found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
 
     build(config, tsconfig, pluginConfigs).catch((err) => {
-        console.error(err);
+        console.error(`${PACKAGE_NAME}: ${err}`);
         process.exit(1);
     });
 }

package/src/compiler/ast.ts

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+
+
+type Range = {
+    end: number;
+    start: number;
+};
+
+
+const expression = {
+    name: (node: ts.Expression): string | null => {
+        if (ts.isIdentifier(node)) {
+            return node.text;
+        }
+
+        if (ts.isPropertyAccessExpression(node)) {
+            return property.path(node);
+        }
+
+        return null;
+    }
+};
+
+const inRange = (ranges: Range[], start: number, end: number): boolean => {
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let r = ranges[i];
+
+        if (start >= r.start && end <= r.end) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const property = {
+    path: (node: ts.Expression): string | null => {
+        let current: ts.Node = node,
+            parts: string[] = [];
+
+        while (ts.isPropertyAccessExpression(current)) {
+            parts.push(current.name.text);
+            current = current.expression;
+        }
+
+        if (ts.isIdentifier(current)) {
+            parts.push(current.text);
+            return parts.reverse().join('.');
+        }
+
+        return null;
+    }
+};
+
+const test = (node: ts.Node, fn: (n: ts.Node) => boolean): boolean => {
+    if (fn(node)) {
+        return true;
+    }
+
+    return !!ts.forEachChild(node, child => test(child, fn) || undefined);
+};
+
+
+export default { expression, inRange, property, test };
+export type { Range };

package/src/compiler/coordinator.ts

@@ -90,7 +90,7 @@ function modify(code: string, file: ts.SourceFile, pkg: string, options: ModifyO
 
     let { namespace } = options,
         add = options.add ? new Set(options.add) : null,
-        found = imports.find(file, pkg);
+        found = imports.all(file, pkg);
 
     if (found.length === 0) {
         let statements: string[] = [];
@@ -187,9 +187,8 @@ const transform = (
         return { changed: false, code, sourceFile: file };
     }
 
-    let changed = false,
-        currentCode = code,
-        currentSourceFile = file;
+    let currentCode = code,
+        currentFile = file;
 
     for (let i = 0, n = plugins.length; i < n; i++) {
         let plugin = plugins[i];
@@ -198,56 +197,50 @@ const transform = (
             continue;
         }
 
-        let result = plugin.transform({
+        let { imports, prepend, replacements } = plugin.transform({
                 checker: program.getTypeChecker(),
                 code: currentCode,
                 program,
                 shared,
-                sourceFile: currentSourceFile
+                sourceFile: currentFile
             });
 
-        let hasChanges = (result.imports && result.imports.length > 0) ||
-            (result.prepend && result.prepend.length > 0) ||
-            (result.replacements && result.replacements.length > 0);
-
-        if (!hasChanges) {
-            continue;
-        }
-
-        changed = true;
-
-        if (result.replacements && result.replacements.length > 0) {
-            currentCode = applyIntents(currentCode, currentSourceFile, result.replacements);
-            currentSourceFile = ts.createSourceFile(
-                currentSourceFile.fileName,
+        if (replacements?.length) {
+            currentCode = applyIntents(currentCode, currentFile, replacements);
+            currentFile = ts.createSourceFile(
+                currentFile.fileName,
                 currentCode,
-                currentSourceFile.languageVersion,
+                currentFile.languageVersion,
                 true
             );
         }
 
-        if (result.prepend && result.prepend.length > 0) {
-            currentCode = applyPrepend(currentCode, currentSourceFile, result.prepend);
-            currentSourceFile = ts.createSourceFile(
-                currentSourceFile.fileName,
+        if (prepend?.length) {
+            currentCode = applyPrepend(currentCode, currentFile, prepend);
+            currentFile = ts.createSourceFile(
+                currentFile.fileName,
                 currentCode,
-                currentSourceFile.languageVersion,
+                currentFile.languageVersion,
                 true
             );
         }
 
-        if (result.imports && result.imports.length > 0) {
-            currentCode = applyImports(currentCode, currentSourceFile, result.imports);
-            currentSourceFile = ts.createSourceFile(
-                currentSourceFile.fileName,
+        if (imports?.length) {
+            currentCode = applyImports(currentCode, currentFile, imports);
+            currentFile = ts.createSourceFile(
+                currentFile.fileName,
                 currentCode,
-                currentSourceFile.languageVersion,
+                currentFile.languageVersion,
                 true
             );
         }
     }
 
-    return { changed, code: currentCode, sourceFile: currentSourceFile };
+    return {
+        changed: currentCode !== code,
+        code: currentCode,
+        sourceFile: currentFile
+    };
 };
 
 

package/src/compiler/imports.ts

@@ -14,12 +14,15 @@ type ModifyOptions = {
 };
 
 
+let cache = new WeakMap<ts.SourceFile, Map<string, Set<string>>>();
+
+
 // Find all named imports from a specific package
-const find = (sourceFile: ts.SourceFile, packageName: string): ImportInfo[] => {
+const all = (file: ts.SourceFile, pkg: string): ImportInfo[] => {
     let imports: ImportInfo[] = [];
 
-    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
-        let stmt = sourceFile.statements[i];
+    for (let i = 0, n = file.statements.length; i < n; i++) {
+        let stmt = file.statements[i];
 
         if (!ts.isImportDeclaration(stmt)) {
             continue;
@@ -27,7 +30,7 @@ const find = (sourceFile: ts.SourceFile, packageName: string): ImportInfo[] => {
 
         let moduleSpecifier = stmt.moduleSpecifier;
 
-        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== packageName) {
+        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
             continue;
         }
 
@@ -44,32 +47,46 @@ const find = (sourceFile: ts.SourceFile, packageName: string): ImportInfo[] => {
             }
         }
 
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(sourceFile) });
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file) });
     }
 
     return imports;
 };
 
 // Check if node's symbol originates from a specific package (with optional symbol name validation)
-const inPackage = (
-    checker: ts.TypeChecker,
-    node: ts.Node,
-    pkg: string,
-    symbolName?: string,
-    packageImports?: Set<string>
-): boolean => {
-    // Fast path: identifier matches known import and expected name
-    if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
-        if (!symbolName || node.text === symbolName) {
-            return true;
+const includes = (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string): boolean => {
+    let file = node.getSourceFile(),
+        imports = cache.get(file);
+
+    if (!imports) {
+        imports = new Map();
+        cache.set(file, imports);
+    }
+
+    let varnames = imports.get(pkg);
+
+    if (!varnames) {
+        varnames = new Set();
+
+        for (let info of all(file, pkg)) {
+            for (let [, varname] of info.specifiers) {
+                varnames.add(varname);
+            }
         }
+
+        imports.set(pkg, varnames);
+    }
+
+    // Fast path: identifier matches known import and expected name
+    if (ts.isIdentifier(node) && varnames.has(node.text) && (!symbolName || node.text === symbolName)) {
+        return true;
     }
 
     let symbol = checker.getSymbolAtLocation(node);
 
     if (!symbol) {
         // Fallback: aliased import - check if local name is in imports
-        if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+        if (ts.isIdentifier(node) && varnames.has(node.text)) {
             return true;
         }
 
@@ -83,13 +100,13 @@ const inPackage = (
 
     // Check symbol name if specified
     if (symbolName && symbol.name !== symbolName) {
-        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+        return ts.isIdentifier(node) && varnames.has(node.text);
     }
 
     let declarations = symbol.getDeclarations();
 
     if (!declarations || declarations.length === 0) {
-        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+        return ts.isIdentifier(node) && varnames.has(node.text);
     }
 
     // Check if any declaration is from the expected package
@@ -99,9 +116,9 @@ const inPackage = (
         }
     }
 
-    return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
+    return ts.isIdentifier(node) && varnames.has(node.text);
 };
 
 
-export default { find, inPackage };
+export default { all, includes };
 export type { ImportInfo, ModifyOptions };

package/src/compiler/index.ts

@@ -1,7 +1,7 @@
-export * as ast from './ast/index';
+export { default as ast } from './ast';
 export { default as code } from './code';
 export { default as coordinator } from './coordinator';
 export { default as imports } from './imports';
-export { default as plugin } from './plugins/index';
+export { default as plugin } from './plugins';
 export { default as uid } from './uid';
 export type * from './types';

package/src/compiler/plugins/tsc.ts

@@ -1,24 +1,6 @@
-import type { Plugin, SharedContext } from '../types';
-import type ts from 'typescript';
-import coordinator from '../coordinator';
+import type { Plugin } from '../types';
 
 
 export default (plugins: Plugin[]) => {
-    return (program: ts.Program, shared: SharedContext) => {
-        return {
-            transform: (() => {
-                return (sourceFile: ts.SourceFile) => {
-                    let result = coordinator.transform(
-                            plugins,
-                            sourceFile.getFullText(),
-                            sourceFile,
-                            program,
-                            shared
-                        );
-
-                    return result.changed ? result.sourceFile : sourceFile;
-                };
-            }) as ts.TransformerFactory<ts.SourceFile>
-        };
-    };
+    return () => plugins;
 };

package/src/compiler/program.ts

@@ -1,5 +1,6 @@
 import path from 'path';
 import ts from 'typescript';
+import { PACKAGE_NAME } from '~/constants';
 
 
 let cache = new Map<string, ts.Program>();
@@ -15,7 +16,7 @@ function create(root: string): ts.Program {
     let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
 
     if (file.error) {
-        throw new Error(`Error reading tsconfig.json: ${file.error.messageText}`);
+        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
     }
 
     let parsed = ts.parseJsonConfigFileContent(
@@ -25,7 +26,7 @@ function create(root: string): ts.Program {
         );
 
     if (parsed.errors.length > 0) {
-        throw new Error(`Error parsing tsconfig.json: ${parsed.errors[0].messageText}`);
+        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
     }
 
     return ts.createProgram({

package/src/compiler/uid.ts

@@ -1,21 +1,10 @@
-const INVALID_CHARS = /[^A-Za-z0-9]/g;
+import { uuid } from '@esportsplus/utilities';
 
 
-let counter = 0;
+let i = 0,
+    namespace = uuid().replace(/[^A-Za-z0-9]/g, '');
 
 
-function hash(str: string): string {
-    let h = 0x811c9dc5;
-
-    for (let i = 0, n = str.length; i < n; i++) {
-        h ^= str.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-
-    return ((h >>> 0).toString(36) + Math.abs(h).toString(36)).replace(INVALID_CHARS, '');
-}
-
-
-export default (prefix: string): string => {
-    return prefix + '_' + hash(prefix) + (counter++).toString(36);
+export default (name: string): string => {
+    return name + '_' + namespace + (i++).toString(36);
 };

package/src/constants.ts

@@ -0,0 +1,4 @@
+const PACKAGE_NAME = '@esportsplus/typescript';
+
+
+export { PACKAGE_NAME };

package/build/compiler/ast/expression.d.ts

@@ -1,4 +0,0 @@
-import ts from 'typescript';
-declare const getExpressionName: (node: ts.Expression) => string | null;
-declare const getPropertyPath: (node: ts.Expression) => string | null;
-export { getExpressionName, getPropertyPath };

package/build/compiler/ast/expression.js

@@ -1,23 +0,0 @@
-import ts from 'typescript';
-const getExpressionName = (node) => {
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPath(node);
-    }
-    return null;
-};
-const getPropertyPath = (node) => {
-    let current = node, parts = [];
-    while (ts.isPropertyAccessExpression(current)) {
-        parts.push(current.name.text);
-        current = current.expression;
-    }
-    if (ts.isIdentifier(current)) {
-        parts.push(current.text);
-        return parts.reverse().join('.');
-    }
-    return null;
-};
-export { getExpressionName, getPropertyPath };

package/build/compiler/ast/index.d.ts

@@ -1,3 +0,0 @@
-export * from './expression.js';
-export * from './range.js';
-export * from './visitor.js';

package/build/compiler/ast/index.js

@@ -1,3 +0,0 @@
-export * from './expression.js';
-export * from './range.js';
-export * from './visitor.js';

package/build/compiler/ast/range.d.ts

@@ -1,7 +0,0 @@
-type Range = {
-    end: number;
-    start: number;
-};
-declare const inRange: (ranges: Range[], start: number, end: number) => boolean;
-export { inRange };
-export type { Range };

package/build/compiler/ast/range.js

@@ -1,10 +0,0 @@
-const inRange = (ranges, start, end) => {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let r = ranges[i];
-        if (start >= r.start && end <= r.end) {
-            return true;
-        }
-    }
-    return false;
-};
-export { inRange };

package/build/compiler/ast/visitor.d.ts

@@ -1,3 +0,0 @@
-import ts from 'typescript';
-declare const hasMatch: (node: ts.Node, predicate: (n: ts.Node) => boolean) => boolean;
-export { hasMatch };

package/build/compiler/ast/visitor.js

@@ -1,8 +0,0 @@
-import ts from 'typescript';
-const hasMatch = (node, predicate) => {
-    if (predicate(node)) {
-        return true;
-    }
-    return !!ts.forEachChild(node, child => hasMatch(child, predicate) || undefined);
-};
-export { hasMatch };

package/src/compiler/ast/expression.ts

@@ -1,34 +0,0 @@
-import ts from 'typescript';
-
-
-const getExpressionName = (node: ts.Expression): string | null => {
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-
-    if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPath(node);
-    }
-
-    return null;
-};
-
-const getPropertyPath = (node: ts.Expression): string | null => {
-    let current: ts.Node = node,
-        parts: string[] = [];
-
-    while (ts.isPropertyAccessExpression(current)) {
-        parts.push(current.name.text);
-        current = current.expression;
-    }
-
-    if (ts.isIdentifier(current)) {
-        parts.push(current.text);
-        return parts.reverse().join('.');
-    }
-
-    return null;
-};
-
-
-export { getExpressionName, getPropertyPath };

package/src/compiler/ast/index.ts

@@ -1,3 +0,0 @@
-export * from './expression';
-export * from './range';
-export * from './visitor';

package/src/compiler/ast/range.ts

@@ -1,21 +0,0 @@
-type Range = {
-    end: number;
-    start: number;
-};
-
-
-const inRange = (ranges: Range[], start: number, end: number): boolean => {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let r = ranges[i];
-
-        if (start >= r.start && end <= r.end) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
-
-export { inRange };
-export type { Range };

package/src/compiler/ast/visitor.ts

@@ -1,13 +0,0 @@
-import ts from 'typescript';
-
-
-const hasMatch = (node: ts.Node, predicate: (n: ts.Node) => boolean): boolean => {
-    if (predicate(node)) {
-        return true;
-    }
-
-    return !!ts.forEachChild(node, child => hasMatch(child, predicate) || undefined);
-};
-
-
-export { hasMatch };