@atlaspack/transformer-typescript-types 2.14.5-canary.24 → 2.14.5-canary.241

package/dist/collect.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = collect;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const typescript_1 = __importDefault(require("typescript"));
+const TSModule_1 = require("./TSModule");
+const utils_1 = require("./utils");
+function collect(moduleGraph, context, sourceFile) {
+    // Factory only exists on TS >= 4.0
+    const { factory = typescript_1.default } = context;
+    // When module definitions are nested inside each other (e.g with module augmentation),
+    // we want to keep track of the hierarchy so we can associated nodes with the right module.
+    const moduleStack = [];
+    let _currentModule;
+    let visit = (node) => {
+        if (typescript_1.default.isBundle(node)) {
+            // @ts-expect-error TS2345
+            return factory.updateBundle(node, typescript_1.default.visitNodes(node.sourceFiles, visit));
+        }
+        if (typescript_1.default.isModuleDeclaration(node)) {
+            moduleStack.push(_currentModule);
+            _currentModule = new TSModule_1.TSModule();
+            moduleGraph.addModule(node.name.text, _currentModule);
+        }
+        if (!_currentModule) {
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        let currentModule = (0, nullthrows_1.default)(_currentModule);
+        if (typescript_1.default.isImportDeclaration(node) && node.importClause) {
+            if (node.importClause.namedBindings) {
+                // @ts-expect-error TS2339
+                if (node.importClause.namedBindings.elements) {
+                    // @ts-expect-error TS2339
+                    for (let element of node.importClause.namedBindings.elements) {
+                        currentModule.addImport(element.name.text, 
+                        // @ts-expect-error TS2339
+                        node.moduleSpecifier.text, (element.propertyName ?? element.name).text);
+                    }
+                    // @ts-expect-error TS2339
+                }
+                else if (node.importClause.namedBindings.name) {
+                    currentModule.addImport(
+                    // @ts-expect-error TS2339
+                    node.importClause.namedBindings.name.text, 
+                    // @ts-expect-error TS2339
+                    node.moduleSpecifier.text, '*');
+                }
+            }
+            if (node.importClause.name) {
+                currentModule.addImport(node.importClause.name.text, 
+                // @ts-expect-error TS2339
+                node.moduleSpecifier.text, 'default');
+            }
+        }
+        if (typescript_1.default.isExportDeclaration(node)) {
+            if (node.exportClause) {
+                // @ts-expect-error TS2339
+                for (let element of node.exportClause.elements) {
+                    if (node.moduleSpecifier) {
+                        currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text, 
+                        // @ts-expect-error TS2339
+                        node.moduleSpecifier.text);
+                    }
+                    else {
+                        currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text);
+                    }
+                }
+            }
+            else {
+                // @ts-expect-error TS18048
+                currentModule.addWildcardExport(node.moduleSpecifier.text);
+            }
+        }
+        node = typescript_1.default.visitEachChild(node, visit, context);
+        if (typescript_1.default.isImportTypeNode(node) &&
+            typescript_1.default.isLiteralTypeNode(node.argument) &&
+            typescript_1.default.isStringLiteral(node.argument.literal)) {
+            let local = `$$parcel$import$${moduleGraph.syntheticImportCount++}`;
+            let [specifier, entity] = getImportName(node.qualifier, local, factory);
+            currentModule.addImport(local, node.argument.literal.text, specifier);
+            return factory.createTypeReferenceNode(entity, node.typeArguments);
+        }
+        // Handle `export default name;`
+        if (typescript_1.default.isExportAssignment(node) && typescript_1.default.isIdentifier(node.expression)) {
+            currentModule.addExport('default', node.expression.text);
+        }
+        if ((0, utils_1.isDeclaration)(node)) {
+            if (node.name) {
+                currentModule.addLocal(node.name.text, node);
+            }
+            let name = (0, utils_1.getExportedName)(node);
+            if (name) {
+                currentModule.addLocal(name, node);
+                currentModule.addExport(name, name);
+            }
+        }
+        if (typescript_1.default.isVariableStatement(node) && node.modifiers) {
+            let isExported = node.modifiers.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+            for (let v of node.declarationList.declarations) {
+                // @ts-expect-error TS2339
+                currentModule.addLocal(v.name.text, v);
+                if (isExported) {
+                    // @ts-expect-error TS2339
+                    currentModule.addExport(v.name.text, v.name.text);
+                }
+            }
+        }
+        // After we finish traversing the children of a module definition,
+        // we need to make sure that subsequent nodes get associated with the next-highest level module.
+        if (typescript_1.default.isModuleDeclaration(node)) {
+            _currentModule = moduleStack.pop();
+        }
+        return node;
+    };
+    return typescript_1.default.visitNode(sourceFile, visit);
+}
+// Traverse down an EntityName to the root identifier. Return that to use as the named import specifier,
+// and collect the remaining parts into a new QualifiedName with the local replacement at the root.
+// import('react').JSX.Element => import {JSX} from 'react'; JSX.Element
+// @ts-expect-error TS7023
+function getImportName(qualifier, local, factory) {
+    if (!qualifier) {
+        // @ts-expect-error TS2339
+        return ['*', factory.createIdentifier(local)];
+    }
+    if (qualifier.kind === typescript_1.default.SyntaxKind.Identifier) {
+        // @ts-expect-error TS2339
+        return [qualifier.text, factory.createIdentifier(local)];
+    }
+    // @ts-expect-error TS7022
+    let [name, entity] = getImportName(qualifier.left, local, factory);
+    // @ts-expect-error TS2339
+    return [name, factory.createQualifiedName(entity, qualifier.right)];
+}

package/dist/shake.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shake = shake;
+const typescript_1 = __importDefault(require("typescript"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("./utils");
+const wrappers_1 = require("./wrappers");
+function shake(moduleGraph, context, sourceFile) {
+    // Factory only exists on TS >= 4.0
+    const { factory = typescript_1.default } = context;
+    // We traverse things out of order which messes with typescript's internal state.
+    // We don't rely on the lexical environment, so just overwrite with noops to avoid errors.
+    context.suspendLexicalEnvironment = () => { };
+    context.resumeLexicalEnvironment = () => { };
+    // Propagate exports from the main module to determine what types should be included
+    let exportedNames = moduleGraph.propagate(context);
+    // When module definitions are nested inside each other (e.g with module augmentation),
+    // we want to keep track of the hierarchy so we can associated nodes with the right module.
+    const moduleStack = [];
+    let addedGeneratedImports = false;
+    let _currentModule;
+    let visit = (node) => {
+        if (typescript_1.default.isBundle(node)) {
+            // @ts-expect-error TS2345
+            return factory.updateBundle(node, typescript_1.default.visitNodes(node.sourceFiles, visit));
+        }
+        // Flatten all module declarations into the top-level scope
+        if (typescript_1.default.isModuleDeclaration(node)) {
+            // Deeply nested module declarations are assumed to be module augmentations and left alone.
+            if (moduleStack.length >= 1) {
+                // Since we are hoisting them to the top-level scope, we need to add a "declare" keyword to make them ambient.
+                // we also want the declare keyword to come after the export keyword to guarantee a valid typings file.
+                // @ts-expect-error TS2540
+                node.modifiers ?? (node.modifiers = []);
+                const index = 
+                // @ts-expect-error TS18048
+                node.modifiers[0]?.kind === typescript_1.default.SyntaxKind.ExportKeyword ? 1 : 0;
+                // @ts-expect-error TS18048
+                node.modifiers.splice(index, 0, factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword));
+                return node;
+            }
+            moduleStack.push(_currentModule);
+            let isFirstModule = !_currentModule;
+            _currentModule = moduleGraph.getModule(node.name.text);
+            // @ts-expect-error TS2532
+            let statements = typescript_1.default.visitEachChild(node, visit, context).body.statements;
+            _currentModule = moduleStack.pop();
+            if (isFirstModule && !addedGeneratedImports) {
+                statements.unshift(...generateImports(factory, moduleGraph));
+                addedGeneratedImports = true;
+            }
+            return statements;
+        }
+        if (!_currentModule) {
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        // Remove inline imports. They are hoisted to the top of the output.
+        if (typescript_1.default.isImportDeclaration(node)) {
+            return null;
+        }
+        let currentModule = (0, nullthrows_1.default)(_currentModule);
+        // Remove exports from flattened modules
+        if (typescript_1.default.isExportDeclaration(node)) {
+            if (!node.moduleSpecifier ||
+                // @ts-expect-error TS2339
+                moduleGraph.getModule(node.moduleSpecifier.text)) {
+                if (!node.moduleSpecifier && node.exportClause) {
+                    // Filter exported elements to only external re-exports
+                    let exported = [];
+                    // @ts-expect-error TS2339
+                    for (let element of node.exportClause.elements) {
+                        let name = (element.propertyName ?? element.name).text;
+                        if (exportedNames.get(name) === currentModule &&
+                            !currentModule.hasBinding(name)) {
+                            exported.push(element);
+                        }
+                    }
+                    if (exported.length > 0) {
+                        return (0, wrappers_1.updateExportDeclaration)(factory, node, undefined, // modifiers
+                        false, // isTypeOnly
+                        factory.updateNamedExports(node.exportClause, exported), undefined, // moduleSpecifier
+                        undefined);
+                    }
+                }
+                return null;
+            }
+        }
+        // Remove export assignment if unused.
+        if (typescript_1.default.isExportAssignment(node)) {
+            let name = currentModule.getName('default');
+            if (exportedNames.get(name) !== currentModule) {
+                return null;
+            }
+        }
+        if ((0, utils_1.isDeclaration)(node)) {
+            let name = (0, utils_1.getExportedName)(node) || node.name.text;
+            // Remove unused declarations
+            if (!currentModule.used.has(name)) {
+                return null;
+            }
+            // Remove original export modifiers
+            node.modifiers = (node.modifiers || []).filter(
+            // @ts-expect-error TS7006
+            (m) => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword &&
+                m.kind !== typescript_1.default.SyntaxKind.DefaultKeyword);
+            // Rename declarations
+            let newName = currentModule.getName(name);
+            if (newName !== name && newName !== 'default') {
+                node.name = factory.createIdentifier(newName);
+            }
+            // Export declarations that should be exported
+            if (exportedNames.get(newName) === currentModule) {
+                if (newName === 'default') {
+                    node.modifiers.unshift(factory.createModifier(typescript_1.default.SyntaxKind.DefaultKeyword));
+                }
+                node.modifiers.unshift(factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword));
+            }
+            else if (typescript_1.default.isFunctionDeclaration(node) ||
+                typescript_1.default.isClassDeclaration(node)) {
+                // @ts-expect-error TS18048
+                node.modifiers.unshift(factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword));
+            }
+        }
+        if (typescript_1.default.isVariableStatement(node)) {
+            node = typescript_1.default.visitEachChild(node, visit, context);
+            // Remove empty variable statements
+            if (node.declarationList.declarations.length === 0) {
+                return null;
+            }
+            // Remove original export modifiers
+            node.modifiers = (node.modifiers || []).filter(
+            // @ts-expect-error TS7006
+            (m) => m.kind !== typescript_1.default.SyntaxKind.ExportKeyword &&
+                m.kind !== typescript_1.default.SyntaxKind.DeclareKeyword);
+            // Add export modifier if all declarations are exported.
+            let isExported = node.declarationList.declarations.every(
+            // @ts-expect-error TS7006
+            (d) => exportedNames.get(d.name.text) === currentModule);
+            if (isExported) {
+                node.modifiers.unshift(factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword));
+            }
+            else {
+                // Otherwise, add `declare` modifier (required for top-level declarations in d.ts files).
+                node.modifiers.unshift(factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword));
+            }
+            return node;
+        }
+        if (typescript_1.default.isVariableDeclaration(node)) {
+            // Remove unused variables
+            // @ts-expect-error TS2339
+            if (!currentModule.used.has(node.name.text)) {
+                return null;
+            }
+        }
+        // Rename references
+        if (typescript_1.default.isIdentifier(node) && currentModule.names.has(node.text)) {
+            let newName = (0, nullthrows_1.default)(currentModule.getName(node.text));
+            if (newName !== 'default') {
+                return factory.createIdentifier(newName);
+            }
+        }
+        // Replace namespace references with final names
+        if (typescript_1.default.isQualifiedName(node) && typescript_1.default.isIdentifier(node.left)) {
+            let resolved = moduleGraph.resolveImport(currentModule, node.left.text, node.right.text);
+            if (resolved && resolved.module.hasBinding(resolved.name)) {
+                return factory.createIdentifier(resolved.name);
+            }
+            else {
+                return factory.updateQualifiedName(node, factory.createIdentifier(currentModule.getName(node.left.text)), node.right);
+            }
+        }
+        // Remove private properties
+        if (typescript_1.default.isPropertyDeclaration(node)) {
+            let isPrivate = node.modifiers &&
+                node.modifiers.some((m) => m.kind === typescript_1.default.SyntaxKind.PrivateKeyword);
+            if (isPrivate) {
+                return null;
+            }
+        }
+        return typescript_1.default.visitEachChild(node, visit, context);
+    };
+    return typescript_1.default.visitNode(sourceFile, visit);
+}
+function generateImports(factory, moduleGraph) {
+    // @ts-expect-error TS2304
+    let importStatements = [];
+    for (let [specifier, names] of moduleGraph.getAllImports()) {
+        let defaultSpecifier;
+        let namespaceSpecifier;
+        // @ts-expect-error TS2304
+        let namedSpecifiers = [];
+        for (let [name, imported] of names) {
+            if (imported === 'default') {
+                defaultSpecifier = factory.createIdentifier(name);
+            }
+            else if (imported === '*') {
+                namespaceSpecifier = factory.createNamespaceImport(factory.createIdentifier(name));
+            }
+            else {
+                namedSpecifiers.push((0, wrappers_1.createImportSpecifier)(factory, false, name === imported ? undefined : factory.createIdentifier(imported), factory.createIdentifier(name)));
+            }
+        }
+        if (namespaceSpecifier) {
+            let importClause = (0, wrappers_1.createImportClause)(factory, false, defaultSpecifier, namespaceSpecifier);
+            importStatements.push((0, wrappers_1.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+            defaultSpecifier = undefined;
+        }
+        if (defaultSpecifier || namedSpecifiers.length > 0) {
+            let importClause = (0, wrappers_1.createImportClause)(factory, false, defaultSpecifier, namedSpecifiers.length > 0
+                ? factory.createNamedImports(namedSpecifiers)
+                : undefined);
+            importStatements.push((0, wrappers_1.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+        }
+    }
+    return importStatements;
+}

package/dist/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExportedName = getExportedName;
+exports.isDeclaration = isDeclaration;
+const typescript_1 = __importDefault(require("typescript"));
+function getExportedName(node) {
+    if (!node.modifiers) {
+        return null;
+    }
+    // @ts-expect-error TS7006
+    if (!node.modifiers.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword)) {
+        return null;
+    }
+    // @ts-expect-error TS7006
+    if (node.modifiers.some((m) => m.kind === typescript_1.default.SyntaxKind.DefaultKeyword)) {
+        return 'default';
+    }
+    return node.name.text;
+}
+function isDeclaration(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isClassDeclaration(node) ||
+        typescript_1.default.isInterfaceDeclaration(node) ||
+        typescript_1.default.isEnumDeclaration(node) ||
+        typescript_1.default.isTypeAliasDeclaration(node));
+}

package/dist/wrappers.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateExportDeclaration = exports.createImportSpecifier = exports.createImportDeclaration = exports.createImportClause = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const assert_1 = __importDefault(require("assert"));
+const [majorVersion, minorVersion] = typescript_1.default.versionMajorMinor
+    .split('.')
+    .map((num) => parseInt(num, 10));
+// Everything below was generated using https://github.com/mischnic/tsc-version-wrapper
+exports.createImportClause = (() => {
+    if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 0)) {
+        return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(isTypeOnly, name, namedBindings);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 8)) {
+        return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(name, namedBindings, isTypeOnly);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 0)) {
+        return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(name, namedBindings);
+    }
+    else {
+        (0, assert_1.default)(false);
+    }
+})();
+exports.createImportDeclaration = (() => {
+    if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 8)) {
+        return (factory, modifiers, importClause, moduleSpecifier, assertClause) => factory.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause);
+    }
+    else if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 5)) {
+        return (factory, modifiers, importClause, moduleSpecifier, assertClause) => factory.createImportDeclaration(undefined /* decorators */, modifiers, importClause, moduleSpecifier, assertClause);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 0)) {
+        return (factory, modifiers, importClause, moduleSpecifier, assertClause) => factory.createImportDeclaration(undefined /* decorators */, modifiers, importClause, moduleSpecifier);
+    }
+    else {
+        (0, assert_1.default)(false);
+    }
+})();
+exports.createImportSpecifier = (() => {
+    if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 5)) {
+        return (factory, isTypeOnly, propertyName, name) => factory.createImportSpecifier(isTypeOnly, propertyName, name);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 0)) {
+        return (factory, isTypeOnly, propertyName, name) => factory.createImportSpecifier(propertyName, name);
+    }
+    else {
+        (0, assert_1.default)(false);
+    }
+})();
+exports.updateExportDeclaration = (() => {
+    if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 8)) {
+        return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
+    }
+    else if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 5)) {
+        return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
+    }
+    else if (majorVersion > 4 || (majorVersion === 4 && minorVersion >= 0)) {
+        return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, isTypeOnly, exportClause, moduleSpecifier);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 8)) {
+        return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier, isTypeOnly);
+    }
+    else if (majorVersion > 3 || (majorVersion === 3 && minorVersion >= 0)) {
+        return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier);
+    }
+    else {
+        (0, assert_1.default)(false);
+    }
+})();

package/lib/TSModuleGraph.js

@@ -78,15 +78,20 @@ class TSModuleGraph {
     }
   }
   getExport(m, e) {
+    // @ts-expect-error TS2339
     (0, _assert().default)(e.name != null);
+    // @ts-expect-error TS2339
     let exportName = e.name;
 
     // Re-export
+    // @ts-expect-error TS2339
     if (e.specifier && e.imported) {
       let m = this.getModule(e.specifier);
       if (!m) {
         return null;
       }
+
+      // @ts-expect-error TS2339
       let exp = this.resolveExport(m, e.imported);
       if (!exp) {
         return null;
@@ -115,6 +120,7 @@ class TSModuleGraph {
     return {
       module: m,
       name: exportName,
+      // @ts-expect-error TS2339
       imported: e.imported != null ? m.getName(e.imported) : exportName
     };
   }
@@ -136,6 +142,7 @@ class TSModuleGraph {
   }
   resolveExport(module, name) {
     for (let e of module.exports) {
+      // @ts-expect-error TS2339
       if (e.name === name) {
         return this.getExport(module, e);
       } else if (e.specifier) {
@@ -149,6 +156,7 @@ class TSModuleGraph {
   getAllExports(module = (0, _nullthrows().default)(this.mainModule), excludeDefault = false) {
     let res = [];
     for (let e of module.exports) {
+      // @ts-expect-error TS2339
       if (e.name && (!excludeDefault || e.name !== 'default')) {
         let exp = this.getExport(module, e);
         if (exp) {
@@ -218,11 +226,14 @@ class TSModuleGraph {
     // Map of imported specifiers -> map of imported names to local names
     let imports = new Map();
     for (let [m, orig] of importedSymbolsToUpdate) {
+      // @ts-expect-error TS2339
       let imp = (0, _nullthrows().default)(m.imports.get(orig));
+      // @ts-expect-error TS2345
       let imported = (0, _nullthrows().default)(this.resolveImport(m, orig));
 
       // If the module is bundled, map the local name to the original exported name.
       if (this.modules.has(imp.specifier)) {
+        // @ts-expect-error TS2339
         m.names.set(orig, imported.imported);
         continue;
       }
@@ -244,6 +255,8 @@ class TSModuleGraph {
         }
         importedNames.set(imported.imported, name);
       }
+
+      // @ts-expect-error TS2339
       m.names.set(orig, name);
     }
     return exportedNames;

package/lib/TSTypesTransformer.js

@@ -98,14 +98,16 @@ var _default = exports.default = new (_plugin().Transformer)({
       incremental: false
     };
     let host = new (_tsUtils().CompilerHost)(options.inputFS, _typescript().default, logger);
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     let program = _typescript().default.createProgram([asset.filePath], opts, host);
     for (let file of program.getSourceFiles()) {
       if (_path().default.normalize(file.fileName) !== asset.filePath) {
         asset.invalidateOnFileChange(host.redirectTypes.get(file.fileName) ?? file.fileName);
       }
     }
-    let mainModuleName = (0, _utils().normalizeSeparators)(_path().default.relative(program.getCommonSourceDirectory(), asset.filePath).slice(0, -_path().default.extname(asset.filePath).length));
+    let mainModuleName = (0, _utils().normalizeSeparators)(_path().default
+    // @ts-expect-error TS2339
+    .relative(program.getCommonSourceDirectory(), asset.filePath).slice(0, -_path().default.extname(asset.filePath).length));
     let moduleGraph = new _TSModuleGraph.TSModuleGraph(mainModuleName);
     let emitResult = program.emit(undefined, undefined, undefined, true, {
       afterDeclarations: [
@@ -120,6 +122,7 @@ var _default = exports.default = new (_plugin().Transformer)({
     });
     let diagnostics = _typescript().default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
     let diagnosticIds = new Set();
+    // @ts-expect-error TS2304
     let deduplicatedDiagnostics = [];
     for (let d of diagnostics) {
       if (d.start != null && d.length != null && d.messageText != null) {
@@ -144,8 +147,6 @@ var _default = exports.default = new (_plugin().Transformer)({
         if (file.fileName) {
           filename = file.fileName;
         }
-
-        // $FlowFixMe
         if (source) {
           let lineChar = file.getLineAndCharacterOfPosition(diagnostic.start);
           let start = {
@@ -191,6 +192,7 @@ var _default = exports.default = new (_plugin().Transformer)({
     let code = (0, _nullthrows().default)(host.outputCode);
     code = code.substring(0, code.lastIndexOf('//# sourceMappingURL'));
     let map = JSON.parse((0, _nullthrows().default)(host.outputMap));
+    // @ts-expect-error TS7006
     map.sources = map.sources.map(source => _path().default.join(_path().default.dirname(asset.filePath), source));
     let sourceMap = null;
     if (map.mappings) {

package/lib/collect.js

@@ -33,6 +33,7 @@ function collect(moduleGraph, context, sourceFile) {
   let _currentModule;
   let visit = node => {
     if (_typescript().default.isBundle(node)) {
+      // @ts-expect-error TS2345
       return factory.updateBundle(node, _typescript().default.visitNodes(node.sourceFiles, visit));
     }
     if (_typescript().default.isModuleDeclaration(node)) {
@@ -46,28 +47,43 @@ function collect(moduleGraph, context, sourceFile) {
     let currentModule = (0, _nullthrows().default)(_currentModule);
     if (_typescript().default.isImportDeclaration(node) && node.importClause) {
       if (node.importClause.namedBindings) {
+        // @ts-expect-error TS2339
         if (node.importClause.namedBindings.elements) {
+          // @ts-expect-error TS2339
           for (let element of node.importClause.namedBindings.elements) {
-            currentModule.addImport(element.name.text, node.moduleSpecifier.text, (element.propertyName ?? element.name).text);
+            currentModule.addImport(element.name.text,
+            // @ts-expect-error TS2339
+            node.moduleSpecifier.text, (element.propertyName ?? element.name).text);
           }
+          // @ts-expect-error TS2339
         } else if (node.importClause.namedBindings.name) {
-          currentModule.addImport(node.importClause.namedBindings.name.text, node.moduleSpecifier.text, '*');
+          currentModule.addImport(
+          // @ts-expect-error TS2339
+          node.importClause.namedBindings.name.text,
+          // @ts-expect-error TS2339
+          node.moduleSpecifier.text, '*');
         }
       }
       if (node.importClause.name) {
-        currentModule.addImport(node.importClause.name.text, node.moduleSpecifier.text, 'default');
+        currentModule.addImport(node.importClause.name.text,
+        // @ts-expect-error TS2339
+        node.moduleSpecifier.text, 'default');
       }
     }
     if (_typescript().default.isExportDeclaration(node)) {
       if (node.exportClause) {
+        // @ts-expect-error TS2339
         for (let element of node.exportClause.elements) {
           if (node.moduleSpecifier) {
-            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text, node.moduleSpecifier.text);
+            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text,
+            // @ts-expect-error TS2339
+            node.moduleSpecifier.text);
           } else {
             currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text);
           }
         }
       } else {
+        // @ts-expect-error TS18048
         currentModule.addWildcardExport(node.moduleSpecifier.text);
       }
     }
@@ -96,8 +112,10 @@ function collect(moduleGraph, context, sourceFile) {
     if (_typescript().default.isVariableStatement(node) && node.modifiers) {
       let isExported = node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.ExportKeyword);
       for (let v of node.declarationList.declarations) {
+        // @ts-expect-error TS2339
         currentModule.addLocal(v.name.text, v);
         if (isExported) {
+          // @ts-expect-error TS2339
           currentModule.addExport(v.name.text, v.name.text);
         }
       }
@@ -116,13 +134,19 @@ function collect(moduleGraph, context, sourceFile) {
 // Traverse down an EntityName to the root identifier. Return that to use as the named import specifier,
 // and collect the remaining parts into a new QualifiedName with the local replacement at the root.
 // import('react').JSX.Element => import {JSX} from 'react'; JSX.Element
+// @ts-expect-error TS7023
 function getImportName(qualifier, local, factory) {
   if (!qualifier) {
+    // @ts-expect-error TS2339
     return ['*', factory.createIdentifier(local)];
   }
   if (qualifier.kind === _typescript().default.SyntaxKind.Identifier) {
+    // @ts-expect-error TS2339
     return [qualifier.text, factory.createIdentifier(local)];
   }
+
+  // @ts-expect-error TS7022
   let [name, entity] = getImportName(qualifier.left, local, factory);
+  // @ts-expect-error TS2339
   return [name, factory.createQualifiedName(entity, qualifier.right)];
 }