@atlaspack/transformer-typescript-types 2.14.5-canary.35 → 2.14.5-canary.350

package/dist/TSTypesTransformer.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = require("@atlaspack/plugin");
+const path_1 = __importDefault(require("path"));
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const typescript_1 = __importDefault(require("typescript"));
+const ts_utils_1 = require("@atlaspack/ts-utils");
+const utils_1 = require("@atlaspack/utils");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const TSModuleGraph_1 = require("./TSModuleGraph");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const collect_1 = require("./collect");
+const shake_1 = require("./shake");
+exports.default = new plugin_1.Transformer({
+    loadConfig({ config, options }) {
+        return (0, ts_utils_1.loadTSConfig)(config, options);
+    },
+    transform({ asset, config, options, logger }) {
+        let opts = {
+            // React is the default. Users can override this by supplying their own tsconfig,
+            // which many TypeScript users will already have for typechecking, etc.
+            jsx: typescript_1.default.JsxEmit.React,
+            moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+            ...config,
+            // Always emit output
+            noEmit: false,
+            noEmitOnError: false,
+            declaration: true,
+            declarationMap: true,
+            isolatedModules: false,
+            emitDeclarationOnly: true,
+            outFile: 'index.d.ts',
+            // createProgram doesn't support incremental mode
+            composite: false,
+            incremental: false,
+        };
+        let host = new ts_utils_1.CompilerHost(options.inputFS, typescript_1.default, logger);
+        // @ts-expect-error TS2345
+        let program = typescript_1.default.createProgram([asset.filePath], opts, host);
+        for (let file of program.getSourceFiles()) {
+            if (path_1.default.normalize(file.fileName) !== asset.filePath) {
+                asset.invalidateOnFileChange(host.redirectTypes.get(file.fileName) ?? file.fileName);
+            }
+        }
+        let mainModuleName = (0, utils_1.normalizeSeparators)(path_1.default
+            // @ts-expect-error TS2339
+            .relative(program.getCommonSourceDirectory(), asset.filePath)
+            .slice(0, -path_1.default.extname(asset.filePath).length));
+        let moduleGraph = new TSModuleGraph_1.TSModuleGraph(mainModuleName);
+        let emitResult = program.emit(undefined, undefined, undefined, true, {
+            afterDeclarations: [
+                // 1. Build module graph
+                (context) => (sourceFile) => {
+                    return (0, collect_1.collect)(moduleGraph, context, sourceFile);
+                },
+                // 2. Tree shake and rename types
+                (context) => (sourceFile) => {
+                    return (0, shake_1.shake)(moduleGraph, context, sourceFile);
+                },
+            ],
+        });
+        let diagnostics = typescript_1.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) {
+                let id = `${d.start}:${d.length}:${typescript_1.default.flattenDiagnosticMessageText(d.messageText, '\n')}`;
+                if (!diagnosticIds.has(id)) {
+                    deduplicatedDiagnostics.push(d);
+                }
+                diagnosticIds.add(id);
+            }
+            else {
+                deduplicatedDiagnostics.push(d);
+            }
+        }
+        let parcelDiagnostics = deduplicatedDiagnostics.map((diagnostic) => {
+            let filename = asset.filePath;
+            let { file } = diagnostic;
+            let diagnosticMessage = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            let codeframe;
+            if (file != null && diagnostic.start != null) {
+                let source = file.text || diagnostic.source;
+                if (file.fileName) {
+                    filename = file.fileName;
+                }
+                if (source) {
+                    let lineChar = file.getLineAndCharacterOfPosition(diagnostic.start);
+                    let start = {
+                        line: lineChar.line + 1,
+                        column: lineChar.character + 1,
+                    };
+                    let end = {
+                        line: start.line,
+                        column: start.column + 1,
+                    };
+                    if (typeof diagnostic.start === 'number' &&
+                        typeof diagnostic.length === 'number') {
+                        let endCharPosition = file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+                        end = {
+                            line: endCharPosition.line + 1,
+                            column: endCharPosition.character,
+                        };
+                    }
+                    codeframe = {
+                        filePath: filename,
+                        code: source,
+                        codeHighlights: [
+                            {
+                                start,
+                                end,
+                                message: (0, diagnostic_1.escapeMarkdown)(diagnosticMessage),
+                            },
+                        ],
+                    };
+                }
+            }
+            return {
+                message: (0, diagnostic_1.escapeMarkdown)(diagnosticMessage),
+                codeFrames: codeframe ? [codeframe] : undefined,
+            };
+        });
+        if (host.outputCode == null) {
+            throw new diagnostic_1.default({ diagnostic: parcelDiagnostics });
+        }
+        else {
+            for (let d of parcelDiagnostics) {
+                logger.warn(d);
+            }
+        }
+        let code = (0, nullthrows_1.default)(host.outputCode);
+        code = code.substring(0, code.lastIndexOf('//# sourceMappingURL'));
+        let map = JSON.parse((0, nullthrows_1.default)(host.outputMap));
+        // @ts-expect-error TS7006
+        map.sources = map.sources.map((source) => path_1.default.join(path_1.default.dirname(asset.filePath), source));
+        let sourceMap = null;
+        if (map.mappings) {
+            sourceMap = new source_map_1.default(options.projectRoot);
+            sourceMap.addVLQMap(map);
+        }
+        asset.type = 'ts';
+        asset.setCode(code);
+        asset.setMap(sourceMap);
+        return [asset];
+    },
+});

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);
+    }
+})();