@atlaspack/transformer-typescript-types 2.12.1-canary.3354

package/lib/TSTypesTransformer.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _plugin() {
+  const data = require("@atlaspack/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _tsUtils() {
+  const data = require("@atlaspack/ts-utils");
+  _tsUtils = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _TSModuleGraph = require("./TSModuleGraph");
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _collect = require("./collect");
+var _shake = require("./shake");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = new (_plugin().Transformer)({
+  loadConfig({
+    config,
+    options
+  }) {
+    return (0, _tsUtils().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().default.JsxEmit.React,
+      moduleResolution: _typescript().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 (_tsUtils().CompilerHost)(options.inputFS, _typescript().default, logger);
+    // $FlowFixMe
+    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 moduleGraph = new _TSModuleGraph.TSModuleGraph(mainModuleName);
+    let emitResult = program.emit(undefined, undefined, undefined, true, {
+      afterDeclarations: [
+      // 1. Build module graph
+      context => sourceFile => {
+        return (0, _collect.collect)(moduleGraph, context, sourceFile);
+      },
+      // 2. Tree shake and rename types
+      context => sourceFile => {
+        return (0, _shake.shake)(moduleGraph, context, sourceFile);
+      }]
+    });
+    let diagnostics = _typescript().default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+    let diagnosticIds = new Set();
+    let deduplicatedDiagnostics = [];
+    for (let d of diagnostics) {
+      if (d.start != null && d.length != null && d.messageText != null) {
+        let id = `${d.start}:${d.length}:${_typescript().default.flattenDiagnosticMessageText(d.messageText, '\n')}`;
+        if (!diagnosticIds.has(id)) {
+          deduplicatedDiagnostics.push(d);
+        }
+        diagnosticIds.add(id);
+      } else {
+        deduplicatedDiagnostics.push(d);
+      }
+    }
+    let atlaspackDiagnostics = deduplicatedDiagnostics.map(diagnostic => {
+      let filename = asset.filePath;
+      let {
+        file
+      } = diagnostic;
+      let diagnosticMessage = _typescript().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;
+        }
+
+        // $FlowFixMe
+        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().escapeMarkdown)(diagnosticMessage)
+            }]
+          };
+        }
+      }
+      return {
+        message: (0, _diagnostic().escapeMarkdown)(diagnosticMessage),
+        codeFrames: codeframe ? [codeframe] : undefined
+      };
+    });
+    if (host.outputCode == null) {
+      throw new (_diagnostic().default)({
+        diagnostic: atlaspackDiagnostics
+      });
+    } else {
+      for (let d of atlaspackDiagnostics) {
+        logger.warn(d);
+      }
+    }
+    let code = (0, _nullthrows().default)(host.outputCode);
+    code = code.substring(0, code.lastIndexOf('//# sourceMappingURL'));
+    let map = JSON.parse((0, _nullthrows().default)(host.outputMap));
+    map.sources = map.sources.map(source => _path().default.join(_path().default.dirname(asset.filePath), source));
+    let sourceMap = null;
+    if (map.mappings) {
+      sourceMap = new (_sourceMap().default)(options.projectRoot);
+      sourceMap.addVLQMap(map);
+    }
+    asset.type = 'ts';
+    asset.setCode(code);
+    asset.setMap(sourceMap);
+    return [asset];
+  }
+});

package/lib/collect.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collect = collect;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+var _TSModule = require("./TSModule");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function collect(moduleGraph, context, sourceFile) {
+  // Factory only exists on TS >= 4.0
+  const {
+    factory = _typescript().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().default.isBundle(node)) {
+      return factory.updateBundle(node, _typescript().default.visitNodes(node.sourceFiles, visit));
+    }
+    if (_typescript().default.isModuleDeclaration(node)) {
+      moduleStack.push(_currentModule);
+      _currentModule = new _TSModule.TSModule();
+      moduleGraph.addModule(node.name.text, _currentModule);
+    }
+    if (!_currentModule) {
+      return _typescript().default.visitEachChild(node, visit, context);
+    }
+    let currentModule = (0, _nullthrows().default)(_currentModule);
+    if (_typescript().default.isImportDeclaration(node) && node.importClause) {
+      if (node.importClause.namedBindings) {
+        if (node.importClause.namedBindings.elements) {
+          for (let element of node.importClause.namedBindings.elements) {
+            currentModule.addImport(element.name.text, node.moduleSpecifier.text, (element.propertyName ?? element.name).text);
+          }
+        } else if (node.importClause.namedBindings.name) {
+          currentModule.addImport(node.importClause.namedBindings.name.text, node.moduleSpecifier.text, '*');
+        }
+      }
+      if (node.importClause.name) {
+        currentModule.addImport(node.importClause.name.text, node.moduleSpecifier.text, 'default');
+      }
+    }
+    if (_typescript().default.isExportDeclaration(node)) {
+      if (node.exportClause) {
+        for (let element of node.exportClause.elements) {
+          if (node.moduleSpecifier) {
+            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text, node.moduleSpecifier.text);
+          } else {
+            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text);
+          }
+        }
+      } else {
+        currentModule.addWildcardExport(node.moduleSpecifier.text);
+      }
+    }
+    node = _typescript().default.visitEachChild(node, visit, context);
+    if (_typescript().default.isImportTypeNode(node) && _typescript().default.isLiteralTypeNode(node.argument) && _typescript().default.isStringLiteral(node.argument.literal)) {
+      let local = `$$atlaspack$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().default.isExportAssignment(node) && _typescript().default.isIdentifier(node.expression)) {
+      currentModule.addExport('default', node.expression.text);
+    }
+    if ((0, _utils.isDeclaration)(node)) {
+      if (node.name) {
+        currentModule.addLocal(node.name.text, node);
+      }
+      let name = (0, _utils.getExportedName)(node);
+      if (name) {
+        currentModule.addLocal(name, node);
+        currentModule.addExport(name, name);
+      }
+    }
+    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) {
+        currentModule.addLocal(v.name.text, v);
+        if (isExported) {
+          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().default.isModuleDeclaration(node)) {
+      _currentModule = moduleStack.pop();
+    }
+    return node;
+  };
+  return _typescript().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
+function getImportName(qualifier, local, factory) {
+  if (!qualifier) {
+    return ['*', factory.createIdentifier(local)];
+  }
+  if (qualifier.kind === _typescript().default.SyntaxKind.Identifier) {
+    return [qualifier.text, factory.createIdentifier(local)];
+  }
+  let [name, entity] = getImportName(qualifier.left, local, factory);
+  return [name, factory.createQualifiedName(entity, qualifier.right)];
+}

package/lib/shake.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shake = shake;
+var _TSModule = require("./TSModule");
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _wrappers = require("./wrappers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function shake(moduleGraph, context, sourceFile) {
+  // Factory only exists on TS >= 4.0
+  const {
+    factory = _typescript().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().default.isBundle(node)) {
+      return factory.updateBundle(node, _typescript().default.visitNodes(node.sourceFiles, visit));
+    }
+
+    // Flatten all module declarations into the top-level scope
+    if (_typescript().default.isModuleDeclaration(node)) {
+      // Deeply nested module declarations are assumed to be module augmentations and left alone.
+      if (moduleStack.length >= 1) {
+        var _node$modifiers$;
+        // 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.
+        node.modifiers ??= [];
+        const index = ((_node$modifiers$ = node.modifiers[0]) === null || _node$modifiers$ === void 0 ? void 0 : _node$modifiers$.kind) === _typescript().default.SyntaxKind.ExportKeyword ? 1 : 0;
+        node.modifiers.splice(index, 0, factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+        return node;
+      }
+      moduleStack.push(_currentModule);
+      let isFirstModule = !_currentModule;
+      _currentModule = moduleGraph.getModule(node.name.text);
+      let statements = _typescript().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().default.visitEachChild(node, visit, context);
+    }
+
+    // Remove inline imports. They are hoisted to the top of the output.
+    if (_typescript().default.isImportDeclaration(node)) {
+      return null;
+    }
+    let currentModule = (0, _nullthrows().default)(_currentModule);
+    // Remove exports from flattened modules
+    if (_typescript().default.isExportDeclaration(node)) {
+      if (!node.moduleSpecifier || moduleGraph.getModule(node.moduleSpecifier.text)) {
+        if (!node.moduleSpecifier && node.exportClause) {
+          // Filter exported elements to only external re-exports
+          let exported = [];
+          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.updateExportDeclaration)(factory, node, undefined,
+            // modifiers
+            false,
+            // isTypeOnly
+            factory.updateNamedExports(node.exportClause, exported), undefined,
+            // moduleSpecifier
+            undefined // assertClause
+            );
+          }
+        }
+
+        return null;
+      }
+    }
+
+    // Remove export assignment if unused.
+    if (_typescript().default.isExportAssignment(node)) {
+      let name = currentModule.getName('default');
+      if (exportedNames.get(name) !== currentModule) {
+        return null;
+      }
+    }
+    if ((0, _utils.isDeclaration)(node)) {
+      let name = (0, _utils.getExportedName)(node) || node.name.text;
+
+      // Remove unused declarations
+      if (!currentModule.used.has(name)) {
+        return null;
+      }
+
+      // Remove original export modifiers
+      node.modifiers = (node.modifiers || []).filter(m => m.kind !== _typescript().default.SyntaxKind.ExportKeyword && m.kind !== _typescript().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().default.SyntaxKind.DefaultKeyword));
+        }
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.ExportKeyword));
+      } else if (_typescript().default.isFunctionDeclaration(node) || _typescript().default.isClassDeclaration(node)) {
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+      }
+    }
+    if (_typescript().default.isVariableStatement(node)) {
+      node = _typescript().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(m => m.kind !== _typescript().default.SyntaxKind.ExportKeyword && m.kind !== _typescript().default.SyntaxKind.DeclareKeyword);
+
+      // Add export modifier if all declarations are exported.
+      let isExported = node.declarationList.declarations.every(d => exportedNames.get(d.name.text) === currentModule);
+      if (isExported) {
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.ExportKeyword));
+      } else {
+        // Otherwise, add `declare` modifier (required for top-level declarations in d.ts files).
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+      }
+      return node;
+    }
+    if (_typescript().default.isVariableDeclaration(node)) {
+      // Remove unused variables
+      if (!currentModule.used.has(node.name.text)) {
+        return null;
+      }
+    }
+
+    // Rename references
+    if (_typescript().default.isIdentifier(node) && currentModule.names.has(node.text)) {
+      let newName = (0, _nullthrows().default)(currentModule.getName(node.text));
+      if (newName !== 'default') {
+        return factory.createIdentifier(newName);
+      }
+    }
+
+    // Replace namespace references with final names
+    if (_typescript().default.isQualifiedName(node) && _typescript().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().default.isPropertyDeclaration(node)) {
+      let isPrivate = node.modifiers && node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.PrivateKeyword);
+      if (isPrivate) {
+        return null;
+      }
+    }
+    return _typescript().default.visitEachChild(node, visit, context);
+  };
+  return _typescript().default.visitNode(sourceFile, visit);
+}
+function generateImports(factory, moduleGraph) {
+  let importStatements = [];
+  for (let [specifier, names] of moduleGraph.getAllImports()) {
+    let defaultSpecifier;
+    let namespaceSpecifier;
+    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.createImportSpecifier)(factory, false, name === imported ? undefined : factory.createIdentifier(imported), factory.createIdentifier(name)));
+      }
+    }
+    if (namespaceSpecifier) {
+      let importClause = (0, _wrappers.createImportClause)(factory, false, defaultSpecifier, namespaceSpecifier);
+      importStatements.push((0, _wrappers.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+      defaultSpecifier = undefined;
+    }
+    if (defaultSpecifier || namedSpecifiers.length > 0) {
+      let importClause = (0, _wrappers.createImportClause)(factory, false, defaultSpecifier, namedSpecifiers.length > 0 ? factory.createNamedImports(namedSpecifiers) : undefined);
+      importStatements.push((0, _wrappers.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+    }
+  }
+  return importStatements;
+}

package/lib/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExportedName = getExportedName;
+exports.isDeclaration = isDeclaration;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getExportedName(node) {
+  if (!node.modifiers) {
+    return null;
+  }
+  if (!node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.ExportKeyword)) {
+    return null;
+  }
+  if (node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.DefaultKeyword)) {
+    return 'default';
+  }
+  return node.name.text;
+}
+function isDeclaration(node) {
+  return _typescript().default.isFunctionDeclaration(node) || _typescript().default.isClassDeclaration(node) || _typescript().default.isInterfaceDeclaration(node) || _typescript().default.isEnumDeclaration(node) || _typescript().default.isTypeAliasDeclaration(node);
+}

package/lib/wrappers.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateExportDeclaration = exports.createImportSpecifier = exports.createImportDeclaration = exports.createImportClause = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-unused-vars */
+const [majorVersion, minorVersion] = _typescript().default.versionMajorMinor.split('.').map(num => parseInt(num, 10));
+
+// Everything below was generated using https://github.com/mischnic/tsc-version-wrapper
+
+const createImportClause = 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().default)(false);
+  }
+})();
+const createImportDeclaration = 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) => factory.createImportDeclaration(undefined /* decorators */, modifiers, importClause, moduleSpecifier);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();
+const createImportSpecifier = 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().default)(false);
+  }
+})();
+const updateExportDeclaration = 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) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, isTypeOnly, exportClause, moduleSpecifier);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 8) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier, isTypeOnly);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 0) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();