@ssets/dts 1.0.0

package/dist/bundle-generator.js

@@ -0,0 +1,2801 @@
+// src/bundle-generator.ts
+import * as ts9 from "typescript";
+
+// src/compile-dts.ts
+import * as ts3 from "typescript";
+
+// src/logger.ts
+function verboseLog(message) {
+  logMessage(message, 0 /* Verbose */);
+}
+function normalLog(message) {
+  logMessage(message, 1 /* Normal */);
+}
+function warnLog(message) {
+  logMessage(message, 2 /* Warning */);
+}
+function errorLog(message) {
+  logMessage(message, 3 /* Error */);
+}
+var currentLogLevel = 3 /* Error */;
+function logMessage(message, level = 0 /* Verbose */) {
+  if (level < currentLogLevel) {
+    return;
+  }
+  switch (level) {
+    case 3 /* Error */:
+      console.error(`\x1B[0;31m${message}\x1B[0m`);
+      break;
+    case 2 /* Warning */:
+      console.warn(`\x1B[1;33m${message}\x1B[0m`);
+      break;
+    case 1 /* Normal */:
+    case 0 /* Verbose */:
+      console.log(message);
+  }
+}
+
+// src/get-compiler-options.ts
+import * as ts2 from "typescript";
+import * as path2 from "path";
+
+// src/helpers/get-absolute-path.ts
+import * as path from "path";
+import * as process2 from "process";
+
+// src/helpers/fix-path.ts
+function fixPath(path5) {
+  return path5.replace(/\\/g, "/");
+}
+
+// src/helpers/get-absolute-path.ts
+function getAbsolutePath(fileName, cwd2) {
+  if (!path.isAbsolute(fileName)) {
+    fileName = path.join(cwd2 !== void 0 ? cwd2 : process2.cwd(), fileName);
+  }
+  return fixPath(fileName);
+}
+
+// src/helpers/check-diagnostics-errors.ts
+import * as ts from "typescript";
+var formatDiagnosticsHost = {
+  getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+  getCurrentDirectory: ts.sys.getCurrentDirectory,
+  getNewLine: () => ts.sys.newLine
+};
+function checkProgramDiagnosticsErrors(program) {
+  if (!program.getCompilerOptions().declaration) {
+    throw new Error(
+      `Something went wrong - the program doesn't have declaration option enabled`
+    );
+  }
+  checkDiagnosticsErrors(
+    ts.getPreEmitDiagnostics(program),
+    "Compiled with errors"
+  );
+}
+function checkDiagnosticsErrors(diagnostics, failMessage) {
+  if (diagnostics.length === 0) {
+    return;
+  }
+  errorLog(ts.formatDiagnostics(diagnostics, formatDiagnosticsHost).trim());
+  throw new Error(failMessage);
+}
+
+// src/get-compiler-options.ts
+var parseConfigHost = {
+  useCaseSensitiveFileNames: ts2.sys.useCaseSensitiveFileNames,
+  readDirectory: ts2.sys.readDirectory,
+  fileExists: ts2.sys.fileExists,
+  readFile: ts2.sys.readFile
+};
+function getCompilerOptions(inputFileNames, preferredConfigPath) {
+  const configFileName = preferredConfigPath !== void 0 ? preferredConfigPath : findConfig(inputFileNames);
+  verboseLog(`Using config: ${configFileName}`);
+  const configParseResult = ts2.readConfigFile(configFileName, ts2.sys.readFile);
+  checkDiagnosticsErrors(
+    configParseResult.error !== void 0 ? [configParseResult.error] : [],
+    "Error while processing tsconfig file"
+  );
+  const compilerOptionsParseResult = ts2.parseJsonConfigFileContent(
+    configParseResult.config,
+    parseConfigHost,
+    path2.resolve(path2.dirname(configFileName)),
+    void 0,
+    getAbsolutePath(configFileName)
+  );
+  const diagnostics = compilerOptionsParseResult.errors.filter(
+    (d) => d.code !== 18003 /* NoInputsWereFoundDiagnosticCode */
+  );
+  checkDiagnosticsErrors(
+    diagnostics,
+    "Error while processing tsconfig compiler options"
+  );
+  return compilerOptionsParseResult.options;
+}
+function findConfig(inputFiles) {
+  if (inputFiles.length !== 1) {
+    throw new Error(
+      "Cannot find tsconfig for multiple files. Please specify preferred tsconfig file"
+    );
+  }
+  const searchPath = getAbsolutePath(inputFiles[0]);
+  const configFileName = ts2.findConfigFile(searchPath, ts2.sys.fileExists);
+  if (!configFileName) {
+    throw new Error(`Cannot find config file for file ${searchPath}`);
+  }
+  return configFileName;
+}
+
+// src/compile-dts.ts
+var declarationExtsRemapping = {
+  [ts3.Extension.Js]: ts3.Extension.Js,
+  [ts3.Extension.Jsx]: ts3.Extension.Jsx,
+  [ts3.Extension.Json]: ts3.Extension.Json,
+  [ts3.Extension.TsBuildInfo]: ts3.Extension.TsBuildInfo,
+  [ts3.Extension.Mjs]: ts3.Extension.Mjs,
+  [ts3.Extension.Cjs]: ts3.Extension.Cjs,
+  [ts3.Extension.Ts]: ts3.Extension.Dts,
+  [ts3.Extension.Tsx]: ts3.Extension.Dts,
+  [ts3.Extension.Dts]: ts3.Extension.Dts,
+  [ts3.Extension.Mts]: ts3.Extension.Dmts,
+  [ts3.Extension.Dmts]: ts3.Extension.Dmts,
+  [ts3.Extension.Cts]: ts3.Extension.Dcts,
+  [ts3.Extension.Dcts]: ts3.Extension.Dcts
+};
+function compileDts(rootFiles, preferredConfigPath, followSymlinks = true) {
+  const compilerOptions = getCompilerOptions(rootFiles, preferredConfigPath);
+  compilerOptions.outDir = void 0;
+  compilerOptions.incremental = void 0;
+  compilerOptions.tsBuildInfoFile = void 0;
+  compilerOptions.declarationDir = void 0;
+  compilerOptions.declaration = true;
+  if (compilerOptions.composite) {
+    warnLog(
+      `Composite projects aren't supported at the time. Prefer to use non-composite project to generate declarations instead or just ignore this message if everything works fine. See https://github.com/timocov/dts-bundle-generator/issues/93`
+    );
+    compilerOptions.composite = void 0;
+  }
+  const host = createCachingCompilerHost(compilerOptions);
+  const dtsFiles = getDeclarationFiles(rootFiles, compilerOptions, host);
+  if (!followSymlinks) {
+    host.realpath = (p) => p;
+  }
+  const moduleResolutionCache = ts3.createModuleResolutionCache(
+    host.getCurrentDirectory(),
+    host.getCanonicalFileName,
+    compilerOptions
+  );
+  host.resolveModuleNameLiterals = (moduleLiterals, containingFile) => {
+    return moduleLiterals.map(
+      (moduleLiteral) => {
+        const resolvedModule = ts3.resolveModuleName(
+          moduleLiteral.text,
+          containingFile,
+          compilerOptions,
+          host,
+          moduleResolutionCache
+        ).resolvedModule;
+        if (resolvedModule && !resolvedModule.isExternalLibraryImport) {
+          const newExt = declarationExtsRemapping[resolvedModule.extension];
+          if (newExt === void 0) {
+            verboseLog(
+              `Skipping module ${resolvedModule.resolvedFileName} because it has unsupported extension "${resolvedModule.extension}"`
+            );
+            return { resolvedModule };
+          }
+          if (newExt !== resolvedModule.extension) {
+            verboseLog(
+              `Changing module from ${resolvedModule.extension} to ${newExt} for ${resolvedModule.resolvedFileName}`
+            );
+            resolvedModule.extension = newExt;
+            resolvedModule.resolvedFileName = changeExtensionToDts(
+              resolvedModule.resolvedFileName
+            );
+          }
+        }
+        return { resolvedModule };
+      }
+    );
+  };
+  const originalGetSourceFile = host.getSourceFile;
+  host.getSourceFile = (fileName, languageVersion, onError) => {
+    const storedValue = dtsFiles.get(host.getCanonicalFileName(fileName));
+    if (storedValue !== void 0) {
+      return ts3.createSourceFile(fileName, storedValue, languageVersion);
+    }
+    return originalGetSourceFile(fileName, languageVersion, onError);
+  };
+  const rootFilesRemapping = /* @__PURE__ */ new Map();
+  const inputFiles = rootFiles.map((rootFile) => {
+    const rootDtsFile = changeExtensionToDts(rootFile);
+    rootFilesRemapping.set(rootFile, rootDtsFile);
+    return rootDtsFile;
+  });
+  const program = ts3.createProgram(inputFiles, compilerOptions, host);
+  checkProgramDiagnosticsErrors(program);
+  warnAboutTypeScriptFilesInProgram(program);
+  return { program, rootFilesRemapping };
+}
+function createCachingCompilerHost(compilerOptions) {
+  const host = ts3.createIncrementalCompilerHost(compilerOptions);
+  const sourceFilesCache = /* @__PURE__ */ new Map();
+  const originalGetSourceFile = host.getSourceFile;
+  host.getSourceFile = (fileName, languageVersion, onError) => {
+    const key = host.getCanonicalFileName(fileName);
+    let cacheValue = sourceFilesCache.get(key);
+    if (cacheValue === void 0) {
+      cacheValue = originalGetSourceFile(fileName, languageVersion, onError);
+      sourceFilesCache.set(key, cacheValue);
+    }
+    return cacheValue;
+  };
+  return host;
+}
+function changeExtensionToDts(fileName) {
+  let ext;
+  if (fileName.endsWith(ts3.Extension.Dts)) {
+    return fileName;
+  }
+  if (fileName.endsWith(ts3.Extension.Cts)) {
+    ext = ts3.Extension.Cts;
+  } else if (fileName.endsWith(ts3.Extension.Mts)) {
+    ext = ts3.Extension.Mts;
+  } else if (fileName.endsWith(ts3.Extension.Ts)) {
+    ext = ts3.Extension.Ts;
+  } else if (fileName.endsWith(ts3.Extension.Tsx)) {
+    ext = ts3.Extension.Tsx;
+  }
+  if (ext === void 0) {
+    return fileName;
+  }
+  return fileName.slice(0, -ext.length) + declarationExtsRemapping[ext];
+}
+function getDeclarationFiles(rootFiles, compilerOptions, host) {
+  compilerOptions = {
+    ...compilerOptions,
+    noEmit: false,
+    declaration: true,
+    emitDeclarationOnly: true
+  };
+  const program = ts3.createProgram(rootFiles, compilerOptions, host);
+  const allFilesAreDeclarations = program.getSourceFiles().every((s) => s.isDeclarationFile);
+  const declarations = /* @__PURE__ */ new Map();
+  if (allFilesAreDeclarations) {
+    verboseLog(
+      "Skipping compiling the project to generate d.ts because all files in it are d.ts already"
+    );
+    return declarations;
+  }
+  checkProgramDiagnosticsErrors(program);
+  const emitResult = program.emit(
+    void 0,
+    (fileName, data) => declarations.set(host.getCanonicalFileName(fileName), data),
+    void 0,
+    true
+  );
+  checkDiagnosticsErrors(
+    emitResult.diagnostics,
+    "Errors while emitting declarations"
+  );
+  return declarations;
+}
+function warnAboutTypeScriptFilesInProgram(program) {
+  const nonDeclarationFiles = program.getSourceFiles().filter((file) => !file.isDeclarationFile);
+  if (nonDeclarationFiles.length !== 0) {
+    warnLog(`WARNING: It seems that some files in the compilation still are not declaration files.
+For more information see https://github.com/timocov/dts-bundle-generator/issues/53.
+If you think this is a mistake, feel free to open new issue or just ignore this warning.
+  ${nonDeclarationFiles.map((file) => file.fileName).join("\n  ")}
+`);
+  }
+}
+
+// src/types-usage-evaluator.ts
+import * as ts5 from "typescript";
+
+// src/helpers/typescript.ts
+import * as ts4 from "typescript";
+var namedDeclarationKinds = [
+  ts4.SyntaxKind.InterfaceDeclaration,
+  ts4.SyntaxKind.ClassDeclaration,
+  ts4.SyntaxKind.EnumDeclaration,
+  ts4.SyntaxKind.TypeAliasDeclaration,
+  ts4.SyntaxKind.ModuleDeclaration,
+  ts4.SyntaxKind.FunctionDeclaration,
+  ts4.SyntaxKind.VariableDeclaration,
+  ts4.SyntaxKind.PropertySignature,
+  ts4.SyntaxKind.NamespaceExport,
+  ts4.SyntaxKind.NamespaceImport,
+  ts4.SyntaxKind.ExportSpecifier,
+  ts4.SyntaxKind.BindingElement
+];
+function isNodeNamedDeclaration(node) {
+  return namedDeclarationKinds.indexOf(node.kind) !== -1;
+}
+function hasNodeModifier(node, modifier) {
+  const modifiers = getModifiers2(node);
+  return Boolean(
+    modifiers && modifiers.some(
+      (nodeModifier) => nodeModifier.kind === modifier
+    )
+  );
+}
+function getNodeName(node) {
+  const nodeName = node.name;
+  if (nodeName === void 0) {
+    const modifiers = getModifiers2(node);
+    const defaultModifier = modifiers?.find(
+      (mod) => mod.kind === ts4.SyntaxKind.DefaultKeyword
+    );
+    if (defaultModifier !== void 0) {
+      return defaultModifier;
+    }
+  }
+  return nodeName;
+}
+function getActualSymbol(symbol, typeChecker) {
+  if (symbol.flags & ts4.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  return typeChecker.getMergedSymbol(symbol);
+}
+function getDeclarationNameSymbol(name, typeChecker) {
+  const symbol = typeChecker.getSymbolAtLocation(name);
+  if (symbol === void 0) {
+    return null;
+  }
+  return getActualSymbol(symbol, typeChecker);
+}
+function splitTransientSymbol(symbol, typeChecker) {
+  if ((symbol.flags & ts4.SymbolFlags.Transient) === 0) {
+    return /* @__PURE__ */ new Set([symbol]);
+  }
+  const declarations = getDeclarationsForSymbol(symbol);
+  const result = /* @__PURE__ */ new Set();
+  for (const declaration of declarations) {
+    if (!isNodeNamedDeclaration(declaration) || declaration.name === void 0) {
+      continue;
+    }
+    const sym = typeChecker.getSymbolAtLocation(declaration.name);
+    if (sym === void 0) {
+      continue;
+    }
+    result.add(getActualSymbol(sym, typeChecker));
+  }
+  return result;
+}
+function isGlobalScopeAugmentation(module) {
+  return Boolean(module.flags & ts4.NodeFlags.GlobalAugmentation);
+}
+function isAmbientModule(node) {
+  return ts4.isModuleDeclaration(node) && (node.name.kind === ts4.SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node));
+}
+function isDeclareModule(node) {
+  return ts4.isModuleDeclaration(node) && !(node.flags & ts4.NodeFlags.Namespace) && !isGlobalScopeAugmentation(node);
+}
+function isDeclareGlobalStatement(statement) {
+  return ts4.isModuleDeclaration(statement) && isGlobalScopeAugmentation(statement);
+}
+function getDeclarationsForSymbol(symbol) {
+  const result = [];
+  if (symbol.declarations !== void 0) {
+    result.push(...symbol.declarations);
+  }
+  if (symbol.valueDeclaration !== void 0) {
+    if (!result.includes(symbol.valueDeclaration)) {
+      result.push(symbol.valueDeclaration);
+    }
+  }
+  return result;
+}
+function getExportsForSourceFile(typeChecker, sourceFileSymbol) {
+  if (sourceFileSymbol.exports !== void 0) {
+    const commonJsExport = sourceFileSymbol.exports.get(
+      ts4.InternalSymbolName.ExportEquals
+    );
+    if (commonJsExport !== void 0) {
+      const symbol = getActualSymbol(commonJsExport, typeChecker);
+      return [
+        {
+          symbol,
+          originalSymbol: commonJsExport,
+          type: 0 /* CommonJS */,
+          exportedName: ""
+        }
+      ];
+    }
+  }
+  const result = typeChecker.getExportsOfModule(sourceFileSymbol).map((symbol) => ({
+    symbol,
+    originalSymbol: symbol,
+    exportedName: symbol.name,
+    type: 1 /* ES6Named */
+  }));
+  if (sourceFileSymbol.exports !== void 0) {
+    const defaultExportSymbol = sourceFileSymbol.exports.get(
+      ts4.InternalSymbolName.Default
+    );
+    if (defaultExportSymbol !== void 0) {
+      const defaultExport = result.find(
+        (exp) => exp.symbol === defaultExportSymbol
+      );
+      if (defaultExport !== void 0) {
+        defaultExport.type = 2 /* ES6Default */;
+      } else {
+        result.push({
+          symbol: defaultExportSymbol,
+          originalSymbol: defaultExportSymbol,
+          type: 2 /* ES6Default */,
+          exportedName: "default"
+        });
+      }
+    }
+  }
+  const symbolsMergingResolvedExports = [];
+  result.forEach((exp) => {
+    exp.symbol = getActualSymbol(exp.symbol, typeChecker);
+    const symbolsDeclarations = getDeclarationsForSymbol(exp.symbol);
+    const importSpecifierDeclaration = symbolsDeclarations.find(
+      ts4.isImportSpecifier
+    );
+    if (symbolsDeclarations.length > 1 && importSpecifierDeclaration !== void 0) {
+      const referencedModule = resolveReferencedModule(
+        importSpecifierDeclaration.parent.parent.parent,
+        typeChecker
+      );
+      if (referencedModule !== null) {
+        const referencedModuleSymbol = getNodeSymbol(
+          referencedModule,
+          typeChecker
+        );
+        if (referencedModuleSymbol !== null) {
+          const importedName = (importSpecifierDeclaration.propertyName ?? importSpecifierDeclaration.name).getText();
+          const exportedItemSymbol = typeChecker.getExportsOfModule(referencedModuleSymbol).find(
+            (exportSymbol) => exportSymbol.getName() === importedName
+          );
+          if (exportedItemSymbol !== void 0) {
+            symbolsMergingResolvedExports.push({
+              ...exp,
+              symbol: getActualSymbol(exportedItemSymbol, typeChecker)
+            });
+          }
+        }
+      }
+    }
+  });
+  return [...result, ...symbolsMergingResolvedExports];
+}
+function getExportsForStatement(exportedSymbols, typeChecker, statement) {
+  if (ts4.isVariableStatement(statement)) {
+    if (statement.declarationList.declarations.length === 0) {
+      return [];
+    }
+    const firstDeclarationExports = getExportsForName(
+      exportedSymbols,
+      typeChecker,
+      statement.declarationList.declarations[0].name
+    );
+    const allDeclarationsHaveSameExportType = statement.declarationList.declarations.every(
+      (variableDecl) => {
+        return getExportsForName(
+          exportedSymbols,
+          typeChecker,
+          variableDecl.name
+        )[0]?.type === firstDeclarationExports[0]?.type;
+      }
+    );
+    if (!allDeclarationsHaveSameExportType) {
+      return [];
+    }
+    return firstDeclarationExports;
+  }
+  const nodeName = getNodeName(statement);
+  if (nodeName === void 0) {
+    return [];
+  }
+  return getExportsForName(exportedSymbols, typeChecker, nodeName);
+}
+function getExportsForName(exportedSymbols, typeChecker, name) {
+  if (ts4.isArrayBindingPattern(name) || ts4.isObjectBindingPattern(name)) {
+    return [];
+  }
+  const declarationSymbol = typeChecker.getSymbolAtLocation(name);
+  return exportedSymbols.filter(
+    (rootExport) => rootExport.symbol === declarationSymbol
+  );
+}
+var modifiersPriority = {
+  [ts4.SyntaxKind.ExportKeyword]: 4,
+  [ts4.SyntaxKind.DefaultKeyword]: 3,
+  [ts4.SyntaxKind.DeclareKeyword]: 2,
+  [ts4.SyntaxKind.AsyncKeyword]: 1,
+  [ts4.SyntaxKind.ConstKeyword]: 1
+};
+function modifiersToMap(modifiers) {
+  modifiers = modifiers || [];
+  return modifiers.reduce(
+    (result, modifier) => {
+      result[modifier.kind] = true;
+      return result;
+    },
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    {}
+  );
+}
+function modifiersMapToArray(modifiersMap) {
+  return Object.entries(modifiersMap).filter(([kind, include]) => include).map(([kind]) => {
+    return ts4.factory.createModifier(Number(kind));
+  }).sort((a, b) => {
+    const aValue = modifiersPriority[a.kind] || 0;
+    const bValue = modifiersPriority[b.kind] || 0;
+    return bValue - aValue;
+  });
+}
+function recreateRootLevelNodeWithModifiers(node, modifiersMap, newName, keepComments = true) {
+  const newNode = recreateRootLevelNodeWithModifiersImpl(
+    node,
+    modifiersMap,
+    newName
+  );
+  if (keepComments) {
+    ts4.setCommentRange(newNode, ts4.getCommentRange(node));
+  }
+  return newNode;
+}
+function recreateRootLevelNodeWithModifiersImpl(node, modifiersMap, newName) {
+  const modifiers = modifiersMapToArray(modifiersMap);
+  if (ts4.isArrowFunction(node)) {
+    return ts4.factory.createArrowFunction(
+      modifiers,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.equalsGreaterThanToken,
+      node.body
+    );
+  }
+  if (ts4.isClassDeclaration(node)) {
+    return ts4.factory.createClassDeclaration(
+      modifiers,
+      newName || node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      node.members
+    );
+  }
+  if (ts4.isClassExpression(node)) {
+    return ts4.factory.createClassExpression(
+      modifiers,
+      newName || node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      node.members
+    );
+  }
+  if (ts4.isEnumDeclaration(node)) {
+    return ts4.factory.createEnumDeclaration(
+      modifiers,
+      newName || node.name,
+      node.members
+    );
+  }
+  if (ts4.isExportAssignment(node)) {
+    return ts4.factory.createExportAssignment(
+      modifiers,
+      node.isExportEquals,
+      node.expression
+    );
+  }
+  if (ts4.isExportDeclaration(node)) {
+    return ts4.factory.createExportDeclaration(
+      modifiers,
+      node.isTypeOnly,
+      node.exportClause,
+      node.moduleSpecifier,
+      // eslint-disable-next-line deprecation/deprecation
+      node.attributes || node.assertClause
+    );
+  }
+  if (ts4.isFunctionDeclaration(node)) {
+    return ts4.factory.createFunctionDeclaration(
+      modifiers,
+      node.asteriskToken,
+      newName || node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.body
+    );
+  }
+  if (ts4.isFunctionExpression(node)) {
+    return ts4.factory.createFunctionExpression(
+      modifiers,
+      node.asteriskToken,
+      newName || node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.body
+    );
+  }
+  if (ts4.isImportDeclaration(node)) {
+    return ts4.factory.createImportDeclaration(
+      modifiers,
+      node.importClause,
+      node.moduleSpecifier,
+      // eslint-disable-next-line deprecation/deprecation
+      node.attributes || node.assertClause
+    );
+  }
+  if (ts4.isImportEqualsDeclaration(node)) {
+    return ts4.factory.createImportEqualsDeclaration(
+      modifiers,
+      node.isTypeOnly,
+      newName || node.name,
+      node.moduleReference
+    );
+  }
+  if (ts4.isInterfaceDeclaration(node)) {
+    return ts4.factory.createInterfaceDeclaration(
+      modifiers,
+      newName || node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      node.members
+    );
+  }
+  if (ts4.isModuleDeclaration(node)) {
+    return ts4.factory.createModuleDeclaration(
+      modifiers,
+      node.name,
+      node.body,
+      node.flags
+    );
+  }
+  if (ts4.isTypeAliasDeclaration(node)) {
+    return ts4.factory.createTypeAliasDeclaration(
+      modifiers,
+      newName || node.name,
+      node.typeParameters,
+      node.type
+    );
+  }
+  if (ts4.isVariableStatement(node)) {
+    return ts4.factory.createVariableStatement(modifiers, node.declarationList);
+  }
+  throw new Error(`Unknown top-level node kind (with modifiers): ${ts4.SyntaxKind[node.kind]}.
+If you're seeing this error, please report a bug on https://github.com/timocov/dts-bundle-generator/issues`);
+}
+function getModifiers2(node) {
+  if (!ts4.canHaveModifiers(node)) {
+    return void 0;
+  }
+  return ts4.getModifiers(node);
+}
+function getRootSourceFile(program, rootFileName) {
+  if (program.getRootFileNames().indexOf(rootFileName) === -1) {
+    throw new Error(`There is no such root file ${rootFileName}`);
+  }
+  const sourceFile = program.getSourceFile(rootFileName);
+  if (sourceFile === void 0) {
+    throw new Error(`Cannot get source file for root file ${rootFileName}`);
+  }
+  return sourceFile;
+}
+function getNodeOwnSymbol(node, typeChecker) {
+  const nodeSymbol = typeChecker.getSymbolAtLocation(node);
+  if (nodeSymbol === void 0) {
+    throw new Error(
+      `Cannot find symbol for node "${node.getText()}" in "${node.parent.getText()}" from "${node.getSourceFile().fileName}"`
+    );
+  }
+  return nodeSymbol;
+}
+function getNodeSymbol(node, typeChecker) {
+  if (ts4.isSourceFile(node)) {
+    const fileSymbol = typeChecker.getSymbolAtLocation(node);
+    if (fileSymbol === void 0) {
+      return null;
+    }
+    return getActualSymbol(fileSymbol, typeChecker);
+  }
+  const nodeName = getNodeName(node);
+  if (nodeName === void 0) {
+    return null;
+  }
+  return getDeclarationNameSymbol(nodeName, typeChecker);
+}
+function getClosestModuleLikeNode(node) {
+  while (!ts4.isModuleBlock(node) && !ts4.isSourceFile(node)) {
+    node = node.parent;
+  }
+  return ts4.isSourceFile(node) ? node : node.parent;
+}
+function getClosestSourceFileLikeNode(node) {
+  while (!(ts4.isModuleBlock(node) && ts4.isStringLiteral(node.parent.name)) && !ts4.isSourceFile(node)) {
+    node = node.parent;
+  }
+  return ts4.isSourceFile(node) ? node : node.parent;
+}
+function resolveReferencedModule(node, typeChecker) {
+  let moduleName;
+  if (ts4.isExportDeclaration(node) || ts4.isImportDeclaration(node)) {
+    moduleName = node.moduleSpecifier;
+  } else if (ts4.isModuleDeclaration(node)) {
+    moduleName = node.name;
+  } else if (ts4.isImportEqualsDeclaration(node)) {
+    if (ts4.isExternalModuleReference(node.moduleReference)) {
+      moduleName = node.moduleReference.expression;
+    }
+  } else if (ts4.isLiteralTypeNode(node.argument) && ts4.isStringLiteral(node.argument.literal)) {
+    moduleName = node.argument.literal;
+  }
+  if (moduleName === void 0) {
+    return null;
+  }
+  const moduleSymbol = typeChecker.getSymbolAtLocation(moduleName);
+  if (moduleSymbol === void 0) {
+    return null;
+  }
+  const symbol = getActualSymbol(moduleSymbol, typeChecker);
+  if (symbol.valueDeclaration === void 0) {
+    return null;
+  }
+  return ts4.isSourceFile(symbol.valueDeclaration) || ts4.isModuleDeclaration(symbol.valueDeclaration) ? symbol.valueDeclaration : null;
+}
+function getImportModuleName(imp) {
+  if (ts4.isImportDeclaration(imp)) {
+    return imp.importClause === void 0 ? null : imp.moduleSpecifier.text;
+  }
+  if (ts4.isExportDeclaration(imp)) {
+    return imp.moduleSpecifier === void 0 ? null : imp.moduleSpecifier.text;
+  }
+  if (ts4.isExternalModuleReference(imp.moduleReference)) {
+    if (!ts4.isStringLiteral(imp.moduleReference.expression)) {
+      warnLog(
+        `Cannot handle non string-literal-like import expression: ${imp.moduleReference.expression.getText()}`
+      );
+      return null;
+    }
+    return imp.moduleReference.expression.text;
+  }
+  return null;
+}
+function getImportExportReferencedSymbol(importExportSpecifier, typeChecker) {
+  return importExportSpecifier.propertyName !== void 0 ? (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    typeChecker.getSymbolAtLocation(importExportSpecifier.propertyName)
+  ) : (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    typeChecker.getImmediateAliasedSymbol(
+      typeChecker.getSymbolAtLocation(importExportSpecifier.name)
+    )
+  );
+}
+function getSymbolExportStarDeclarations(symbol) {
+  if (symbol.escapedName !== ts4.InternalSymbolName.ExportStar) {
+    throw new Error(
+      `Only ExportStar symbol can have export star declaration, but got ${symbol.escapedName}`
+    );
+  }
+  return getDeclarationsForSymbol(symbol).filter(
+    (decl) => ts4.isExportDeclaration(decl) && decl.moduleSpecifier !== void 0
+  );
+}
+function getDeclarationsForExportedValues(exp, typeChecker) {
+  const nodeForSymbol = ts4.isExportAssignment(exp) ? exp.expression : exp.moduleSpecifier;
+  if (nodeForSymbol === void 0) {
+    return [];
+  }
+  const symbolForExpression = typeChecker.getSymbolAtLocation(nodeForSymbol);
+  if (symbolForExpression === void 0) {
+    return [];
+  }
+  const symbol = getActualSymbol(symbolForExpression, typeChecker);
+  return getDeclarationsForSymbol(symbol);
+}
+function resolveGlobalName(typeChecker, name) {
+  const tsSymbolFlagsAll = (
+    /* ts.SymbolFlags.All */
+    -1
+  );
+  return typeChecker.resolveName(
+    name,
+    void 0,
+    tsSymbolFlagsAll,
+    false
+  );
+}
+
+// src/types-usage-evaluator.ts
+var TypesUsageEvaluator = class {
+  typeChecker;
+  nodesParentsMap = /* @__PURE__ */ new Map();
+  usageResultCache = /* @__PURE__ */ new Map();
+  constructor(files, typeChecker) {
+    this.typeChecker = typeChecker;
+    this.computeUsages(files);
+  }
+  isSymbolUsedBySymbol(symbol, by) {
+    return this.isSymbolUsedBySymbolImpl(
+      this.getActualSymbol(symbol),
+      this.getActualSymbol(by),
+      /* @__PURE__ */ new Set()
+    );
+  }
+  getSymbolsUsingSymbol(symbol) {
+    return this.nodesParentsMap.get(this.getActualSymbol(symbol)) || null;
+  }
+  isSymbolUsedBySymbolImpl(fromSymbol, toSymbol, visitedSymbols) {
+    if (fromSymbol === toSymbol) {
+      return this.setUsageCacheValue(fromSymbol, toSymbol, true);
+    }
+    const cacheResult = this.usageResultCache.get(fromSymbol)?.get(toSymbol);
+    if (cacheResult !== void 0) {
+      return cacheResult;
+    }
+    const reachableNodes = this.nodesParentsMap.get(fromSymbol);
+    if (reachableNodes !== void 0) {
+      for (const symbol of reachableNodes) {
+        if (visitedSymbols.has(symbol)) {
+          continue;
+        }
+        visitedSymbols.add(symbol);
+        if (this.isSymbolUsedBySymbolImpl(symbol, toSymbol, visitedSymbols)) {
+          return this.setUsageCacheValue(fromSymbol, toSymbol, true);
+        }
+      }
+    }
+    visitedSymbols.add(fromSymbol);
+    return false;
+  }
+  setUsageCacheValue(fromSymbol, toSymbol, value) {
+    let fromSymbolCacheMap = this.usageResultCache.get(fromSymbol);
+    if (fromSymbolCacheMap === void 0) {
+      fromSymbolCacheMap = /* @__PURE__ */ new Map();
+      this.usageResultCache.set(fromSymbol, fromSymbolCacheMap);
+    }
+    fromSymbolCacheMap.set(toSymbol, value);
+    return value;
+  }
+  computeUsages(files) {
+    this.nodesParentsMap.clear();
+    for (const file of files) {
+      ts5.forEachChild(file, this.computeUsageForNode.bind(this));
+    }
+  }
+  // eslint-disable-next-line complexity
+  computeUsageForNode(node) {
+    if (isDeclareModule(node) && node.body !== void 0 && ts5.isModuleBlock(node.body)) {
+      const moduleSymbol = this.getSymbol(node.name);
+      for (const statement of node.body.statements) {
+        this.computeUsageForNode(statement);
+        if (isNodeNamedDeclaration(statement)) {
+          const nodeName = getNodeName(statement);
+          if (nodeName !== void 0) {
+            const statementSymbol = this.getSymbol(nodeName);
+            this.addUsages(statementSymbol, moduleSymbol);
+          }
+        }
+      }
+    }
+    if (isNodeNamedDeclaration(node)) {
+      const nodeName = getNodeName(node);
+      if (nodeName !== void 0) {
+        if (ts5.isObjectBindingPattern(nodeName) || ts5.isArrayBindingPattern(nodeName)) {
+          for (const element of nodeName.elements) {
+            this.computeUsageForNode(element);
+          }
+        } else {
+          const childSymbol = this.getSymbol(nodeName);
+          if (childSymbol !== null) {
+            this.computeUsagesRecursively(node, childSymbol);
+          }
+        }
+      }
+    }
+    if (ts5.isVariableStatement(node)) {
+      for (const varDeclaration of node.declarationList.declarations) {
+        this.computeUsageForNode(varDeclaration);
+      }
+    }
+    if (ts5.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && node.exportClause !== void 0 && ts5.isNamespaceExport(node.exportClause)) {
+      this.addUsagesForNamespacedModule(
+        node.exportClause,
+        node.moduleSpecifier
+      );
+    }
+    if (ts5.isImportDeclaration(node) && node.moduleSpecifier !== void 0 && node.importClause?.namedBindings !== void 0 && ts5.isNamespaceImport(node.importClause.namedBindings)) {
+      this.addUsagesForNamespacedModule(
+        node.importClause.namedBindings,
+        node.moduleSpecifier,
+        false
+      );
+    }
+    if (ts5.isExportDeclaration(node) && node.exportClause !== void 0 && ts5.isNamedExports(node.exportClause)) {
+      for (const exportElement of node.exportClause.elements) {
+        const exportElementSymbol = getImportExportReferencedSymbol(
+          exportElement,
+          this.typeChecker
+        );
+        const namespaceImportForElement = getDeclarationsForSymbol(
+          exportElementSymbol
+        ).find(ts5.isNamespaceImport);
+        if (namespaceImportForElement !== void 0) {
+          this.addUsagesForNamespacedModule(
+            namespaceImportForElement,
+            namespaceImportForElement.parent.parent.moduleSpecifier
+          );
+        }
+        const exportElementOwnSymbol = this.getNodeOwnSymbol(
+          exportElement.name
+        );
+        this.addUsages(exportElementSymbol, exportElementOwnSymbol);
+        this.addUsages(
+          this.getActualSymbol(exportElementSymbol),
+          exportElementOwnSymbol
+        );
+      }
+    }
+    if (ts5.isExportAssignment(node) && node.isExportEquals) {
+      this.addUsagesForExportAssignment(node);
+    }
+  }
+  addUsagesForExportAssignment(exportAssignment) {
+    for (const declaration of getDeclarationsForExportedValues(
+      exportAssignment,
+      this.typeChecker
+    )) {
+      if (ts5.isModuleDeclaration(declaration) && ts5.isIdentifier(declaration.name) && declaration.body !== void 0 && ts5.isModuleBlock(declaration.body)) {
+        const moduleSymbol = this.getSymbol(declaration.name);
+        for (const statement of declaration.body.statements) {
+          if (isNodeNamedDeclaration(statement) && statement.name !== void 0) {
+            const statementSymbol = this.getSymbol(statement.name);
+            if (statementSymbol !== null) {
+              this.addUsages(moduleSymbol, statementSymbol);
+            }
+          }
+        }
+      }
+    }
+  }
+  addUsagesForNamespacedModule(namespaceNode, moduleSpecifier, includeExports = true) {
+    const namespaceSymbol = this.getNodeOwnSymbol(namespaceNode.name);
+    const referencedSourceFileSymbol = this.getSymbol(moduleSpecifier);
+    this.addUsages(referencedSourceFileSymbol, namespaceSymbol);
+    const resolvedNamespaceSymbol = this.getSymbol(namespaceNode.name);
+    this.addUsages(resolvedNamespaceSymbol, namespaceSymbol);
+    if (includeExports) {
+      this.addExportsToSymbol(
+        referencedSourceFileSymbol.exports,
+        referencedSourceFileSymbol
+      );
+    }
+  }
+  addExportsToSymbol(exports, parentSymbol, visitedSymbols = /* @__PURE__ */ new Set()) {
+    exports?.forEach((moduleExportedSymbol, name) => {
+      if (name === ts5.InternalSymbolName.ExportStar) {
+        for (const exportStarDeclaration of getSymbolExportStarDeclarations(
+          moduleExportedSymbol
+        )) {
+          if (exportStarDeclaration.moduleSpecifier === void 0) {
+            throw new Error(
+              `Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`
+            );
+          }
+          const referencedSourceFileSymbol = this.getSymbol(
+            exportStarDeclaration.moduleSpecifier
+          );
+          if (visitedSymbols.has(referencedSourceFileSymbol)) {
+            continue;
+          }
+          visitedSymbols.add(referencedSourceFileSymbol);
+          this.addExportsToSymbol(
+            referencedSourceFileSymbol.exports,
+            parentSymbol,
+            visitedSymbols
+          );
+        }
+        return;
+      }
+      this.addUsages(moduleExportedSymbol, parentSymbol);
+    });
+  }
+  computeUsagesRecursively(parent, parentSymbol) {
+    ts5.forEachChild(parent, (child) => {
+      if (child.kind === ts5.SyntaxKind.JSDoc) {
+        return;
+      }
+      this.computeUsagesRecursively(child, parentSymbol);
+      if (ts5.isIdentifier(child) || child.kind === ts5.SyntaxKind.DefaultKeyword) {
+        if (ts5.isNamedTupleMember(child.parent) && child.parent.name === child) {
+          return;
+        }
+        if (ts5.isBindingElement(child.parent) && child.parent.propertyName === child) {
+          return;
+        }
+        this.addUsages(this.getSymbol(child), parentSymbol);
+        if (!ts5.isQualifiedName(child.parent)) {
+          const childOwnSymbol = this.getNodeOwnSymbol(child);
+          const namespaceImport = getDeclarationsForSymbol(childOwnSymbol).find(
+            ts5.isNamespaceImport
+          );
+          if (namespaceImport !== void 0) {
+            this.addUsagesForNamespacedModule(
+              namespaceImport,
+              namespaceImport.parent.parent.moduleSpecifier,
+              true
+            );
+          }
+        }
+      }
+    });
+  }
+  addUsages(childSymbol, parentSymbol) {
+    const childSymbols = splitTransientSymbol(childSymbol, this.typeChecker);
+    for (const childSplitSymbol of childSymbols) {
+      let symbols = this.nodesParentsMap.get(childSplitSymbol);
+      if (symbols === void 0) {
+        symbols = /* @__PURE__ */ new Set();
+        this.nodesParentsMap.set(childSplitSymbol, symbols);
+      }
+      if (childSplitSymbol !== parentSymbol) {
+        symbols.add(parentSymbol);
+      }
+    }
+  }
+  getSymbol(node) {
+    return this.getActualSymbol(this.getNodeOwnSymbol(node));
+  }
+  getNodeOwnSymbol(node) {
+    return getNodeOwnSymbol(node, this.typeChecker);
+  }
+  getActualSymbol(symbol) {
+    return getActualSymbol(symbol, this.typeChecker);
+  }
+};
+
+// src/module-info.ts
+import * as path3 from "path";
+import * as ts6 from "typescript";
+
+// src/helpers/node-modules.ts
+var nodeModulesFolderName = "node_modules/";
+var libraryNameRegex = /node_modules\/((?:(?=@)[^/]+\/[^/]+|[^/]+))\//;
+function getLibraryName(fileName) {
+  const lastNodeModulesIndex = fileName.lastIndexOf(nodeModulesFolderName);
+  if (lastNodeModulesIndex === -1) {
+    return null;
+  }
+  const match = libraryNameRegex.exec(fileName.slice(lastNodeModulesIndex));
+  if (match === null) {
+    return null;
+  }
+  return match[1];
+}
+function getTypesLibraryName(path5) {
+  const libraryName = getLibraryName(path5);
+  if (libraryName === null) {
+    return null;
+  }
+  const typesFolderPrefix = "@types/";
+  if (!libraryName.startsWith(typesFolderPrefix)) {
+    return null;
+  }
+  return libraryName.substring(typesFolderPrefix.length);
+}
+
+// src/module-info.ts
+function getFileModuleInfo(fileName, criteria) {
+  return getModuleInfoImpl(fileName, fileName, criteria);
+}
+function getReferencedModuleInfo(moduleDecl, criteria, typeChecker) {
+  const referencedModule = resolveReferencedModule(moduleDecl, typeChecker);
+  if (referencedModule === null) {
+    return null;
+  }
+  const moduleFilePath = ts6.isSourceFile(referencedModule) ? referencedModule.fileName : resolveModuleFileName(
+    referencedModule.getSourceFile().fileName,
+    referencedModule.name.text
+  );
+  return getFileModuleInfo(moduleFilePath, criteria);
+}
+function getModuleLikeModuleInfo(moduleLike, criteria, typeChecker) {
+  const resolvedModuleLike = ts6.isSourceFile(moduleLike) ? moduleLike : resolveReferencedModule(moduleLike, typeChecker) ?? moduleLike;
+  const fileName = ts6.isSourceFile(resolvedModuleLike) ? resolvedModuleLike.fileName : resolveModuleFileName(
+    resolvedModuleLike.getSourceFile().fileName,
+    resolvedModuleLike.name.text
+  );
+  return getFileModuleInfo(fileName, criteria);
+}
+function resolveModuleFileName(currentFileName, moduleName) {
+  return moduleName.startsWith(".") ? fixPath(path3.join(currentFileName, "..", moduleName)) : `node_modules/${moduleName}/`;
+}
+function getModuleInfoImpl(currentFilePath, originalFileName, criteria) {
+  const npmLibraryName = getLibraryName(currentFilePath);
+  if (npmLibraryName === null) {
+    if (criteria.typeRoots !== void 0) {
+      for (const root of criteria.typeRoots) {
+        const relativePath = fixPath(path3.relative(root, originalFileName));
+        if (!relativePath.startsWith("../")) {
+          return getModuleInfoImpl(
+            remapToTypesFromNodeModules(relativePath),
+            originalFileName,
+            criteria
+          );
+        }
+      }
+    }
+    return {
+      type: 0 /* ShouldBeInlined */,
+      fileName: originalFileName,
+      isExternal: false
+    };
+  }
+  const typesLibraryName = getTypesLibraryName(currentFilePath);
+  if (shouldLibraryBeInlined(
+    npmLibraryName,
+    typesLibraryName,
+    criteria.inlinedLibraries
+  )) {
+    return {
+      type: 0 /* ShouldBeInlined */,
+      fileName: originalFileName,
+      isExternal: true
+    };
+  }
+  if (shouldLibraryBeImported(
+    npmLibraryName,
+    typesLibraryName,
+    criteria.importedLibraries,
+    criteria.allowedTypesLibraries
+  )) {
+    return {
+      type: 1 /* ShouldBeImported */,
+      fileName: originalFileName,
+      isExternal: true
+    };
+  }
+  if (typesLibraryName !== null && isLibraryAllowed(typesLibraryName, criteria.allowedTypesLibraries)) {
+    return {
+      type: 2 /* ShouldBeReferencedAsTypes */,
+      fileName: originalFileName,
+      typesLibraryName,
+      isExternal: true
+    };
+  }
+  return {
+    type: 3 /* ShouldBeUsedForModulesOnly */,
+    fileName: originalFileName,
+    isExternal: true
+  };
+}
+function shouldLibraryBeInlined(npmLibraryName, typesLibraryName, inlinedLibraries) {
+  return isLibraryAllowed(npmLibraryName, inlinedLibraries) || typesLibraryName !== null && isLibraryAllowed(typesLibraryName, inlinedLibraries);
+}
+function shouldLibraryBeImported(npmLibraryName, typesLibraryName, importedLibraries, allowedTypesLibraries) {
+  if (typesLibraryName === null) {
+    return isLibraryAllowed(npmLibraryName, importedLibraries);
+  }
+  if (allowedTypesLibraries === void 0 || !isLibraryAllowed(typesLibraryName, allowedTypesLibraries)) {
+    return isLibraryAllowed(typesLibraryName, importedLibraries);
+  }
+  return false;
+}
+function isLibraryAllowed(libraryName, allowedArray) {
+  return allowedArray === void 0 || allowedArray.indexOf(libraryName) !== -1;
+}
+function remapToTypesFromNodeModules(pathRelativeToTypesRoot) {
+  return `node_modules/@types/${pathRelativeToTypesRoot}`;
+}
+
+// src/generate-output.ts
+import * as ts7 from "typescript";
+
+// src/helpers/package-info.ts
+import * as fs from "fs";
+import * as path4 from "path";
+function getPackageInfo() {
+  let dirName = process.cwd();
+  while (dirName.length !== 0) {
+    const packageJsonFilePath = path4.join(dirName, "package.json");
+    if (fs.existsSync(packageJsonFilePath)) {
+      const pkgContent = fs.readFileSync(packageJsonFilePath, "utf8");
+      const pkg = JSON.parse(pkgContent);
+      let authorName = void 0;
+      if (pkg.author) {
+        authorName = typeof pkg.author === "string" ? pkg.author : pkg.author.name;
+      }
+      return {
+        name: pkg.name || "@sse-ui/locale",
+        version: pkg.version,
+        license: pkg.license || "MIT",
+        author: authorName
+      };
+    }
+    const parentDir = path4.join(dirName, "..");
+    if (parentDir === dirName) {
+      break;
+    }
+    dirName = parentDir;
+  }
+  throw new Error(`Cannot find up package.json in ${__dirname}`);
+}
+
+// src/generate-output.ts
+function generateOutput(params, options = {}) {
+  const resultOutputParts = [];
+  if (!options.noBanner) {
+    const pkg = getPackageInfo();
+    const authorLine = pkg.author ? `
+ * @author ${pkg.author}` : "";
+    resultOutputParts.push(`/**
+ * ${pkg.name} v${pkg.version}${authorLine}
+ *
+ * @license ${pkg.license}
+ * This source code is licensed under the ${pkg.license} license found in the
+ * LICENSE file in the root directory of this source tree.
+ */`);
+  }
+  if (params.typesReferences.size !== 0) {
+    const header = generateReferenceTypesDirective(
+      Array.from(params.typesReferences)
+    );
+    resultOutputParts.push(header);
+  }
+  if (params.imports.size !== 0) {
+    const sortedEntries = Array.from(params.imports.entries()).sort(
+      (firstEntry, secondEntry) => {
+        return firstEntry[0].localeCompare(secondEntry[0]);
+      }
+    );
+    const importsArray = [];
+    for (const [libraryName, libraryImports] of sortedEntries) {
+      importsArray.push(...generateImports(libraryName, libraryImports));
+    }
+    if (importsArray.length !== 0) {
+      resultOutputParts.push(importsArray.join("\n"));
+    }
+  }
+  const statements = params.statements.map(
+    (statement) => getStatementText(statement, Boolean(options.sortStatements), params)
+  );
+  if (options.sortStatements) {
+    statements.sort(compareStatementText);
+  }
+  if (statements.length !== 0) {
+    resultOutputParts.push(statementsTextToString(statements));
+  }
+  if (params.wrappedNamespaces.size !== 0) {
+    resultOutputParts.push(
+      Array.from(params.wrappedNamespaces.entries()).map(
+        ([namespaceName, exportedNames]) => {
+          return `declare namespace ${namespaceName} {
+	export { ${Array.from(
+            exportedNames.entries()
+          ).map(
+            ([exportedName, localName]) => renamedExportValue(exportedName, localName)
+          ).sort().join(", ")} };
+}`;
+        }
+      ).join("\n")
+    );
+  }
+  if (params.renamedExports.size !== 0) {
+    resultOutputParts.push(
+      `export {
+	${Array.from(params.renamedExports.entries()).map(
+        ([exportedName, localName]) => renamedExportValue(exportedName, localName)
+      ).sort().join(",\n	")},
+};`
+    );
+  }
+  if (options.umdModuleName !== void 0) {
+    resultOutputParts.push(`export as namespace ${options.umdModuleName};`);
+  }
+  resultOutputParts.push(`export {};
+`);
+  return resultOutputParts.join("\n\n");
+}
+function statementsTextToString(statements) {
+  const statementsText = statements.map((statement) => statement.text).join("\n");
+  return spacesToTabs(prettifyStatementsText(statementsText));
+}
+function renamedExportValue(exportedName, localName) {
+  return exportedName !== localName ? `${localName} as ${exportedName}` : exportedName;
+}
+function renamedImportValue(importedName, localName) {
+  return importedName !== localName ? `${importedName} as ${localName}` : importedName;
+}
+function prettifyStatementsText(statementsText) {
+  const sourceFile = ts7.createSourceFile(
+    "output.d.ts",
+    statementsText,
+    ts7.ScriptTarget.Latest,
+    false,
+    ts7.ScriptKind.TS
+  );
+  const printer = ts7.createPrinter({
+    newLine: ts7.NewLineKind.LineFeed,
+    removeComments: false
+  });
+  return printer.printFile(sourceFile).trim();
+}
+function compareStatementText(a, b) {
+  if (a.sortingValue > b.sortingValue) {
+    return 1;
+  } else if (a.sortingValue < b.sortingValue) {
+    return -1;
+  }
+  return 0;
+}
+function recreateEntityName(node, helpers) {
+  const resolvedName = helpers.resolveIdentifierName(node);
+  if (resolvedName !== null && resolvedName !== node.getText()) {
+    const identifiers = resolvedName.split(".");
+    let result = ts7.factory.createIdentifier(identifiers[0]);
+    for (let index = 1; index < identifiers.length; index += 1) {
+      result = ts7.factory.createQualifiedName(
+        result,
+        ts7.factory.createIdentifier(identifiers[index])
+      );
+    }
+    return result;
+  }
+  return node;
+}
+function getStatementText(statement, includeSortingValue, helpers) {
+  const { shouldHaveExportKeyword, shouldHaveJSDoc } = helpers.getStatementSettings(statement);
+  const needResolveIdentifiers = !ts7.isExportDeclaration(statement) || statement.moduleSpecifier === void 0;
+  const printer = ts7.createPrinter(
+    {
+      newLine: ts7.NewLineKind.LineFeed,
+      removeComments: false
+    },
+    {
+      // eslint-disable-next-line complexity
+      substituteNode: (hint, node) => {
+        if (node.parent === void 0) {
+          return node;
+        }
+        if (needResolveIdentifiers) {
+          if (ts7.isPropertyAccessExpression(node)) {
+            const resolvedName = helpers.resolveIdentifierName(
+              node
+            );
+            if (resolvedName !== null && resolvedName !== node.getText()) {
+              const identifiers = resolvedName.split(".");
+              let result = ts7.factory.createIdentifier(identifiers[0]);
+              for (let index = 1; index < identifiers.length; index += 1) {
+                result = ts7.factory.createPropertyAccessExpression(
+                  result,
+                  ts7.factory.createIdentifier(identifiers[index])
+                );
+              }
+              return result;
+            }
+            return node;
+          }
+          if (ts7.isIdentifier(node) || ts7.isQualifiedName(node)) {
+            if (ts7.isIdentifier(node) && (ts7.isQualifiedName(node.parent) || ts7.isPropertyAccessExpression(node.parent))) {
+              return node;
+            }
+            if (ts7.isIdentifier(node) && ts7.isImportTypeNode(node.parent) && node.parent.qualifier === node) {
+              return node;
+            }
+            return recreateEntityName(node, helpers);
+          }
+        }
+        if (ts7.isImportTypeNode(node) && node.qualifier !== void 0 && helpers.needStripImportFromImportTypeNode(node)) {
+          const newQualifier = recreateEntityName(node.qualifier, helpers);
+          if (node.isTypeOf) {
+            return ts7.factory.createTypeQueryNode(newQualifier);
+          }
+          return ts7.factory.createTypeReferenceNode(
+            newQualifier,
+            node.typeArguments
+          );
+        }
+        if (node !== statement) {
+          return node;
+        }
+        const modifiersMap = modifiersToMap(getModifiers2(node));
+        if (ts7.isEnumDeclaration(node) && modifiersMap[ts7.SyntaxKind.ConstKeyword] && helpers.needStripConstFromConstEnum(node)) {
+          modifiersMap[ts7.SyntaxKind.ConstKeyword] = false;
+        }
+        const nodeName = getNodeName(node);
+        const resolvedStatementName = nodeName !== void 0 ? helpers.resolveIdentifierName(nodeName) || void 0 : void 0;
+        if (modifiersMap[ts7.SyntaxKind.DefaultKeyword]) {
+          modifiersMap[ts7.SyntaxKind.DefaultKeyword] = false;
+          if (ts7.isClassDeclaration(node)) {
+            modifiersMap[ts7.SyntaxKind.DeclareKeyword] = true;
+          }
+        }
+        if (!shouldHaveExportKeyword) {
+          modifiersMap[ts7.SyntaxKind.ExportKeyword] = false;
+        } else {
+          modifiersMap[ts7.SyntaxKind.ExportKeyword] = true;
+        }
+        if (!modifiersMap[ts7.SyntaxKind.ExportKeyword] && (ts7.isClassDeclaration(node) || ts7.isFunctionDeclaration(node) || ts7.isVariableStatement(node) || ts7.isEnumDeclaration(node) || ts7.isModuleDeclaration(node))) {
+          modifiersMap[ts7.SyntaxKind.DeclareKeyword] = true;
+        }
+        return recreateRootLevelNodeWithModifiers(
+          node,
+          modifiersMap,
+          resolvedStatementName,
+          shouldHaveJSDoc
+        );
+      }
+    }
+  );
+  const statementText = printer.printNode(ts7.EmitHint.Unspecified, statement, statement.getSourceFile()).trim();
+  let sortingValue = "";
+  if (includeSortingValue) {
+    const tempSourceFile = ts7.createSourceFile(
+      "temp.d.ts",
+      statementText,
+      ts7.ScriptTarget.ESNext
+    );
+    sortingValue = tempSourceFile.getChildren()[0].getText();
+  }
+  return { text: statementText, sortingValue };
+}
+function generateImports(libraryName, imports) {
+  const fromEnding = `from '${libraryName}';`;
+  const result = [];
+  if (imports.nsImport !== null) {
+    result.push(`import * as ${imports.nsImport} ${fromEnding}`);
+  }
+  Array.from(imports.requireImports).sort().forEach(
+    (importName) => result.push(`import ${importName} = require('${libraryName}');`)
+  );
+  Array.from(imports.defaultImports).sort().forEach(
+    (importName) => result.push(`import ${importName} ${fromEnding}`)
+  );
+  if (imports.namedImports.size !== 0) {
+    result.push(
+      `import { ${Array.from(imports.namedImports.entries()).map(
+        ([localName, importedName]) => renamedImportValue(importedName, localName)
+      ).sort().join(", ")} } ${fromEnding}`
+    );
+  }
+  if (imports.reExports.size !== 0) {
+    result.push(
+      `export { ${Array.from(imports.reExports.entries()).map(
+        ([localName, importedName]) => renamedImportValue(importedName, localName)
+      ).sort().join(", ")} } ${fromEnding}`
+    );
+  }
+  return result;
+}
+function generateReferenceTypesDirective(libraries) {
+  return libraries.sort().map((library) => {
+    return `/// <reference types="${library}" />`;
+  }).join("\n");
+}
+function spacesToTabs(text) {
+  return text.replace(/^(    )+/gm, (substring) => {
+    return "	".repeat(substring.length / 4);
+  });
+}
+
+// src/collisions-resolver.ts
+import * as ts8 from "typescript";
+var renamingSupportedSymbols = [
+  ts8.SymbolFlags.Alias,
+  ts8.SymbolFlags.Variable,
+  ts8.SymbolFlags.Class,
+  ts8.SymbolFlags.Enum,
+  ts8.SymbolFlags.Function,
+  ts8.SymbolFlags.Interface,
+  ts8.SymbolFlags.NamespaceModule,
+  ts8.SymbolFlags.TypeAlias,
+  ts8.SymbolFlags.ValueModule
+];
+var CollisionsResolver = class {
+  typeChecker;
+  collisionsMap = /* @__PURE__ */ new Map();
+  generatedNames = /* @__PURE__ */ new Map();
+  constructor(typeChecker) {
+    this.typeChecker = typeChecker;
+  }
+  /**
+   * Adds (or "registers") a top-level {@link identifier} (which takes a top-level scope name to use).
+   */
+  addTopLevelIdentifier(identifier) {
+    const symbol = getDeclarationNameSymbol(identifier, this.typeChecker);
+    if (symbol === null) {
+      throw new Error(`Something went wrong - cannot find a symbol for top-level identifier ${identifier.getText()} (from ${identifier.parent.parent.getText()})`);
+    }
+    const newLocalName = this.registerSymbol(symbol, identifier.getText());
+    if (newLocalName === null) {
+      throw new Error(`Something went wrong - a symbol ${symbol.name} for top-level identifier ${identifier.getText()} cannot be renamed`);
+    }
+    return newLocalName;
+  }
+  /**
+   * Returns a set of all already registered names for a given {@link symbol}.
+   */
+  namesForSymbol(symbol) {
+    return this.generatedNames.get(getActualSymbol(symbol, this.typeChecker)) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Resolves given {@link referencedIdentifier} to a name.
+   * It assumes that a symbol for this identifier has been registered before by calling {@link addTopLevelIdentifier} method.
+   * Otherwise it will return `null`.
+   *
+   * Note that a returned value might be of a different type of the identifier (e.g. {@link ts.QualifiedName} for a given {@link ts.Identifier})
+   */
+  resolveReferencedIdentifier(referencedIdentifier) {
+    const identifierSymbol = getDeclarationNameSymbol(referencedIdentifier, this.typeChecker);
+    if (identifierSymbol === null) {
+      return null;
+    }
+    const symbolScopePath = this.getSymbolScope(identifierSymbol);
+    const currentIdentifierScope = this.getNodeScope(referencedIdentifier);
+    if (symbolScopePath.length > 0 && currentIdentifierScope.length > 0 && symbolScopePath[0] === currentIdentifierScope[0]) {
+      return referencedIdentifier.getText();
+    }
+    const topLevelIdentifierSymbol = symbolScopePath.length === 0 ? identifierSymbol : symbolScopePath[0];
+    const namesForTopLevelSymbol = this.namesForSymbol(topLevelIdentifierSymbol);
+    if (namesForTopLevelSymbol.size === 0) {
+      return null;
+    }
+    let topLevelName = symbolScopePath.length === 0 ? referencedIdentifier.getText() : topLevelIdentifierSymbol.getName();
+    if (!namesForTopLevelSymbol.has(topLevelName)) {
+      const topLevelNamesArray = Array.from(namesForTopLevelSymbol);
+      let suitableTopLevelName = topLevelNamesArray[0];
+      for (const name of topLevelNamesArray) {
+        if (name.startsWith(`${topLevelName}$`)) {
+          suitableTopLevelName = name;
+          break;
+        }
+      }
+      topLevelName = suitableTopLevelName;
+    }
+    const newIdentifierParts = [
+      ...symbolScopePath.map((symbol) => symbol.getName()),
+      referencedIdentifier.getText()
+    ];
+    newIdentifierParts[0] = topLevelName;
+    return newIdentifierParts.join(".");
+  }
+  /**
+   * Similar to {@link resolveReferencedIdentifier}, but works with qualified names (Ns.Ns1.Interface).
+   * The main point of this resolver is that it might change the first part of the qualifier only (as it drives uniqueness of a name).
+   */
+  resolveReferencedQualifiedName(referencedIdentifier) {
+    let topLevelIdentifier = referencedIdentifier;
+    if (ts8.isQualifiedName(topLevelIdentifier) || ts8.isPropertyAccessExpression(topLevelIdentifier)) {
+      let leftmostIdentifier = ts8.isQualifiedName(topLevelIdentifier) ? topLevelIdentifier.left : topLevelIdentifier.expression;
+      while (ts8.isQualifiedName(leftmostIdentifier) || ts8.isPropertyAccessExpression(leftmostIdentifier)) {
+        leftmostIdentifier = ts8.isQualifiedName(leftmostIdentifier) ? leftmostIdentifier.left : leftmostIdentifier.expression;
+      }
+      topLevelIdentifier = leftmostIdentifier;
+    }
+    const topLevelName = this.resolveReferencedIdentifier(topLevelIdentifier);
+    if (topLevelName === null) {
+      const identifierSymbol = getDeclarationNameSymbol(referencedIdentifier, this.typeChecker);
+      if (identifierSymbol === null) {
+        return null;
+      }
+      const namesForSymbol = this.namesForSymbol(identifierSymbol);
+      if (namesForSymbol.size !== 0) {
+        return Array.from(namesForSymbol)[0];
+      }
+      return null;
+    }
+    const identifierParts = referencedIdentifier.getText().split(".");
+    identifierParts[0] = topLevelName;
+    return identifierParts.join(".");
+  }
+  getSymbolScope(identifierSymbol) {
+    const identifierDeclarations = getDeclarationsForSymbol(identifierSymbol);
+    if (identifierDeclarations.length === 0) {
+      return [];
+    }
+    return this.getNodeScope(identifierDeclarations[0]);
+  }
+  /**
+   * Returns a node's scope where it is located in terms of namespaces/modules.
+   * E.g. A scope for `Opt` in `declare module foo { type Opt = number; }` is `[Symbol(foo)]`
+   */
+  getNodeScope(node) {
+    const scopeIdentifiersPath = [];
+    let currentNode = getClosestModuleLikeNode(node);
+    while (ts8.isModuleDeclaration(currentNode) && ts8.isIdentifier(currentNode.name)) {
+      const nameSymbol = getDeclarationNameSymbol(currentNode.name, this.typeChecker);
+      if (nameSymbol === null) {
+        throw new Error(`Cannot find symbol for identifier '${currentNode.name.getText()}'`);
+      }
+      scopeIdentifiersPath.push(nameSymbol);
+      currentNode = getClosestModuleLikeNode(currentNode.parent);
+    }
+    return scopeIdentifiersPath.reverse();
+  }
+  registerSymbol(identifierSymbol, preferredName) {
+    if (!renamingSupportedSymbols.some((flag) => identifierSymbol.flags & flag)) {
+      verboseLog(`Symbol ${identifierSymbol.name} cannot be renamed because its flag (${identifierSymbol.flags}) isn't supported`);
+      return null;
+    }
+    if (identifierSymbol.flags & ts8.SymbolFlags.NamespaceModule && identifierSymbol.escapedName === ts8.InternalSymbolName.Global) {
+      return null;
+    }
+    let symbolName = preferredName;
+    if (symbolName === "default") {
+      symbolName = "_default";
+    }
+    const collisionsKey = symbolName;
+    let collisionSymbols = this.collisionsMap.get(collisionsKey);
+    if (collisionSymbols === void 0) {
+      collisionSymbols = /* @__PURE__ */ new Map();
+      this.collisionsMap.set(collisionsKey, collisionSymbols);
+    }
+    const storedSymbolName = collisionSymbols.get(identifierSymbol);
+    if (storedSymbolName !== void 0) {
+      return storedSymbolName;
+    }
+    let nameIndex = collisionSymbols.size;
+    let newName = collisionSymbols.size === 0 ? symbolName : `${symbolName}$${nameIndex}`;
+    let resolvedGlobalSymbol = resolveGlobalName(this.typeChecker, newName);
+    while (resolvedGlobalSymbol !== void 0 && resolvedGlobalSymbol !== identifierSymbol) {
+      nameIndex += 1;
+      newName = `${symbolName}$${nameIndex}`;
+      resolvedGlobalSymbol = resolveGlobalName(this.typeChecker, newName);
+    }
+    collisionSymbols.set(identifierSymbol, newName);
+    let symbolNames = this.generatedNames.get(identifierSymbol);
+    if (symbolNames === void 0) {
+      symbolNames = /* @__PURE__ */ new Set();
+      this.generatedNames.set(identifierSymbol, symbolNames);
+    }
+    symbolNames.add(newName);
+    return newName;
+  }
+};
+
+// src/bundle-generator.ts
+function generateDtsBundle(entries, options = {}) {
+  normalLog("Compiling input files...");
+  const { program, rootFilesRemapping } = compileDts(
+    entries.map((entry) => entry.filePath),
+    options.preferredConfigPath,
+    options.followSymlinks
+  );
+  const typeChecker = program.getTypeChecker();
+  const typeRoots = ts9.getEffectiveTypeRoots(program.getCompilerOptions(), {});
+  const sourceFiles = program.getSourceFiles().filter((file) => {
+    return !program.isSourceFileDefaultLibrary(file);
+  });
+  const typesUsageEvaluator = new TypesUsageEvaluator(sourceFiles, typeChecker);
+  return entries.map((entryConfig) => {
+    normalLog(`Processing ${entryConfig.filePath}`);
+    const newRootFilePath = rootFilesRemapping.get(entryConfig.filePath);
+    if (newRootFilePath === void 0) {
+      throw new Error(`Cannot remap root source file ${entryConfig.filePath}`);
+    }
+    const rootSourceFile = getRootSourceFile(program, newRootFilePath);
+    const rootSourceFileSymbol = typeChecker.getSymbolAtLocation(rootSourceFile);
+    if (rootSourceFileSymbol === void 0) {
+      throw new Error(
+        `Symbol for root source file ${newRootFilePath} not found`
+      );
+    }
+    const librariesOptions = entryConfig.libraries || {};
+    const criteria = {
+      allowedTypesLibraries: librariesOptions.allowedTypesLibraries,
+      importedLibraries: librariesOptions.importedLibraries,
+      inlinedLibraries: librariesOptions.inlinedLibraries || [],
+      typeRoots
+    };
+    const rootFileExports = getExportsForSourceFile(
+      typeChecker,
+      rootSourceFileSymbol
+    );
+    const rootFileExportSymbols = rootFileExports.map(
+      (exp) => exp.symbol
+    );
+    const collectionResult = {
+      typesReferences: /* @__PURE__ */ new Set(),
+      imports: /* @__PURE__ */ new Map(),
+      statements: [],
+      renamedExports: /* @__PURE__ */ new Map(),
+      wrappedNamespaces: /* @__PURE__ */ new Map()
+    };
+    const outputOptions = entryConfig.output || {};
+    const inlineDeclareGlobals = Boolean(outputOptions.inlineDeclareGlobals);
+    const inlineDeclareExternals = Boolean(
+      outputOptions.inlineDeclareExternals
+    );
+    const collisionsResolver = new CollisionsResolver(typeChecker);
+    function updateResultForAnyModule(statements, currentModule) {
+      const visitedModules = /* @__PURE__ */ new Set();
+      function updateResultForExternalExport(exportAssignment) {
+        for (const declaration of getDeclarationsForExportedValues(
+          exportAssignment,
+          typeChecker
+        )) {
+          if (ts9.isVariableDeclaration(declaration)) {
+            continue;
+          }
+          let exportedDeclarations = [];
+          if (ts9.isExportDeclaration(exportAssignment) && ts9.isSourceFile(declaration)) {
+            const referencedModule = getReferencedModuleInfo(
+              exportAssignment,
+              criteria,
+              typeChecker
+            );
+            if (referencedModule !== null) {
+              if (visitedModules.has(referencedModule.fileName)) {
+                continue;
+              }
+              visitedModules.add(referencedModule.fileName);
+            }
+            exportedDeclarations = declaration.statements;
+          } else if (ts9.isModuleDeclaration(declaration)) {
+            if (declaration.body !== void 0 && ts9.isModuleBlock(declaration.body)) {
+              const referencedModule = getReferencedModuleInfo(
+                declaration,
+                criteria,
+                typeChecker
+              );
+              if (referencedModule !== null) {
+                if (visitedModules.has(referencedModule.fileName)) {
+                  continue;
+                }
+                visitedModules.add(referencedModule.fileName);
+              }
+              exportedDeclarations = declaration.body.statements;
+            }
+          } else {
+            exportedDeclarations = [declaration];
+          }
+          updateResultImpl(exportedDeclarations);
+        }
+      }
+      function updateResultImpl(statementsToProcess) {
+        for (const statement of statementsToProcess) {
+          if (statement.kind === ts9.SyntaxKind.ImportDeclaration || statement.kind === ts9.SyntaxKind.ImportEqualsDeclaration) {
+            continue;
+          }
+          if (isDeclareModule(statement)) {
+            updateResultForModuleDeclaration(statement, currentModule);
+            if (ts9.isStringLiteral(statement.name)) {
+              continue;
+            }
+          }
+          if (currentModule.type === 3 /* ShouldBeUsedForModulesOnly */) {
+            continue;
+          }
+          if (isDeclareGlobalStatement(statement) && inlineDeclareGlobals && currentModule.type === 0 /* ShouldBeInlined */) {
+            collectionResult.statements.push(statement);
+            continue;
+          }
+          if (ts9.isExportDeclaration(statement)) {
+            if (currentModule.type === 0 /* ShouldBeInlined */) {
+              continue;
+            }
+            if (statement.exportClause === void 0) {
+              updateResultForExternalExport(statement);
+              continue;
+            }
+            if (ts9.isNamedExports(statement.exportClause) && currentModule.type === 1 /* ShouldBeImported */) {
+              updateImportsForStatement(statement);
+              continue;
+            }
+          }
+          if (ts9.isExportAssignment(statement) && statement.isExportEquals && currentModule.type !== 0 /* ShouldBeInlined */) {
+            updateResultForExternalExport(statement);
+            continue;
+          }
+          if (!isNodeUsed(statement)) {
+            continue;
+          }
+          switch (currentModule.type) {
+            case 2 /* ShouldBeReferencedAsTypes */:
+              forEachNodeThatShouldBeImported(
+                statement,
+                () => addTypesReference(currentModule.typesLibraryName)
+              );
+              break;
+            case 1 /* ShouldBeImported */:
+              updateImportsForStatement(statement);
+              break;
+            case 0 /* ShouldBeInlined */:
+              if (ts9.isVariableStatement(statement)) {
+                for (const variableDeclaration of statement.declarationList.declarations) {
+                  if (ts9.isIdentifier(variableDeclaration.name)) {
+                    collisionsResolver.addTopLevelIdentifier(
+                      variableDeclaration.name
+                    );
+                    continue;
+                  }
+                  for (const element of variableDeclaration.name.elements) {
+                    if (!ts9.isOmittedExpression(element) && ts9.isIdentifier(element.name)) {
+                      collisionsResolver.addTopLevelIdentifier(element.name);
+                    }
+                  }
+                }
+              } else if (isNodeNamedDeclaration(statement)) {
+                const statementName = getNodeName(statement);
+                if (statementName !== void 0) {
+                  collisionsResolver.addTopLevelIdentifier(
+                    statementName
+                  );
+                }
+              }
+              collectionResult.statements.push(statement);
+              break;
+          }
+        }
+      }
+      updateResultImpl(statements);
+    }
+    function isReferencedModuleImportable(statement) {
+      return getReferencedModuleInfo(statement, criteria, typeChecker)?.type === 1 /* ShouldBeImported */;
+    }
+    function handleExportDeclarationFromRootModule(exportDeclaration) {
+      function handleExportStarStatement(exportStarStatement, visitedSymbols = /* @__PURE__ */ new Set()) {
+        if (exportStarStatement.moduleSpecifier === void 0 || exportStarStatement.exportClause !== void 0) {
+          throw new Error(
+            `Invalid export-star declaration statement provided, ${exportStarStatement.getText()}`
+          );
+        }
+        const importModuleSpecifier = getImportModuleName(exportStarStatement);
+        if (importModuleSpecifier === null) {
+          return;
+        }
+        const referencedModuleInfo = getReferencedModuleInfo(
+          exportStarStatement,
+          criteria,
+          typeChecker
+        );
+        if (referencedModuleInfo === null) {
+          return;
+        }
+        switch (referencedModuleInfo.type) {
+          case 0 /* ShouldBeInlined */: {
+            const referencedModuleSymbol = getNodeOwnSymbol(
+              exportStarStatement.moduleSpecifier,
+              typeChecker
+            );
+            const referencedSourceFileExportStarSymbol = referencedModuleSymbol.exports?.get(
+              ts9.InternalSymbolName.ExportStar
+            );
+            if (referencedSourceFileExportStarSymbol !== void 0) {
+              if (visitedSymbols.has(referencedSourceFileExportStarSymbol)) {
+                return;
+              }
+              visitedSymbols.add(referencedSourceFileExportStarSymbol);
+              for (const exportDecl of getSymbolExportStarDeclarations(
+                referencedSourceFileExportStarSymbol
+              )) {
+                handleExportStarStatement(exportDecl, visitedSymbols);
+              }
+            }
+            break;
+          }
+          case 1 /* ShouldBeImported */: {
+            collectionResult.statements.push(exportStarStatement);
+            break;
+          }
+        }
+      }
+      function findExportingExportStarExportFromImportableModule(referencedModuleSymbol, nodeSymbol) {
+        function findResultRecursively(referencedModuleSym, exportedNodeSym, visitedSymbols) {
+          if (visitedSymbols.has(referencedModuleSym)) {
+            return null;
+          }
+          visitedSymbols.add(referencedModuleSym);
+          const exportStarExport = referencedModuleSym.exports?.get(
+            ts9.InternalSymbolName.ExportStar
+          );
+          if (exportStarExport === void 0) {
+            return null;
+          }
+          for (const exportStarDeclaration of getDeclarationsForSymbol(
+            exportStarExport
+          ).filter(ts9.isExportDeclaration)) {
+            if (exportStarDeclaration.moduleSpecifier === void 0) {
+              continue;
+            }
+            const exportStarModuleSymbol = getNodeOwnSymbol(
+              exportStarDeclaration.moduleSpecifier,
+              typeChecker
+            );
+            if (exportStarModuleSymbol.exports === void 0) {
+              continue;
+            }
+            if (isReferencedModuleImportable(exportStarDeclaration)) {
+              const referencedModuleExports = typeChecker.getExportsOfModule(
+                exportStarModuleSymbol
+              );
+              const exportedNodeSymbol = referencedModuleExports.find(
+                (exp) => getActualSymbol(exp, typeChecker) === nodeSymbol
+              );
+              if (exportedNodeSymbol !== void 0) {
+                return { exportStarDeclaration, exportedNodeSymbol };
+              }
+              continue;
+            }
+            const result = findResultRecursively(
+              exportStarModuleSymbol,
+              exportedNodeSym,
+              visitedSymbols
+            );
+            if (result !== null) {
+              return result;
+            }
+          }
+          return null;
+        }
+        if (referencedModuleSymbol.exports === void 0) {
+          throw new Error(
+            `No exports found for "${referencedModuleSymbol.getName()}" symbol`
+          );
+        }
+        const hasExplicitExportOfSymbol = Array.from(
+          referencedModuleSymbol.exports.values()
+        ).some((exp) => {
+          if (exp.escapedName === ts9.InternalSymbolName.ExportStar) {
+            return false;
+          }
+          return getActualSymbol(exp, typeChecker) === nodeSymbol;
+        });
+        if (hasExplicitExportOfSymbol) {
+          return null;
+        }
+        return findResultRecursively(
+          referencedModuleSymbol,
+          nodeSymbol,
+          /* @__PURE__ */ new Set()
+        );
+      }
+      if (exportDeclaration.exportClause === void 0) {
+        handleExportStarStatement(exportDeclaration);
+        return;
+      }
+      if (exportDeclaration.exportClause !== void 0 && ts9.isNamedExports(exportDeclaration.exportClause)) {
+        if (exportDeclaration.moduleSpecifier === void 0) {
+          for (const exportElement of exportDeclaration.exportClause.elements) {
+            const exportElementSymbol = getImportExportReferencedSymbol(
+              exportElement,
+              typeChecker
+            );
+            const namespaceImportFromImportableModule = getDeclarationsForSymbol(exportElementSymbol).find(
+              (importDecl) => {
+                return ts9.isNamespaceImport(importDecl) && isReferencedModuleImportable(
+                  importDecl.parent.parent
+                );
+              }
+            );
+            if (namespaceImportFromImportableModule !== void 0) {
+              const importModuleSpecifier = getImportModuleName(
+                namespaceImportFromImportableModule.parent.parent
+              );
+              if (importModuleSpecifier === null) {
+                throw new Error(
+                  `Cannot get import module name from '${namespaceImportFromImportableModule.parent.parent.getText()}'`
+                );
+              }
+              addNsImport(
+                getImportItem(importModuleSpecifier),
+                namespaceImportFromImportableModule.name
+              );
+            }
+          }
+          return;
+        }
+        if (exportDeclaration.moduleSpecifier !== void 0) {
+          const referencedModuleSymbol = getNodeOwnSymbol(
+            exportDeclaration.moduleSpecifier,
+            typeChecker
+          );
+          for (const exportElement of exportDeclaration.exportClause.elements) {
+            const exportedNodeSymbol = getActualSymbol(
+              getImportExportReferencedSymbol(exportElement, typeChecker),
+              typeChecker
+            );
+            const exportingExportStarResult = findExportingExportStarExportFromImportableModule(
+              referencedModuleSymbol,
+              exportedNodeSymbol
+            );
+            if (exportingExportStarResult === null) {
+              continue;
+            }
+            const importModuleSpecifier = getImportModuleName(
+              exportingExportStarResult.exportStarDeclaration
+            );
+            if (importModuleSpecifier === null) {
+              throw new Error(
+                `Cannot get import module name from '${exportingExportStarResult.exportStarDeclaration.getText()}'`
+              );
+            }
+            addReExport(
+              getImportItem(importModuleSpecifier),
+              exportingExportStarResult.exportedNodeSymbol.getName(),
+              exportElement.name.text
+            );
+          }
+          return;
+        }
+      }
+    }
+    function updateResultForRootModule(statements, currentModule) {
+      updateResultForAnyModule(statements, currentModule);
+      for (const statement of statements) {
+        if (ts9.isExportDeclaration(statement)) {
+          handleExportDeclarationFromRootModule(statement);
+          continue;
+        }
+        if (ts9.isExportAssignment(statement)) {
+          if (statement.isExportEquals || !ts9.isIdentifier(statement.expression)) {
+            collectionResult.statements.push(statement);
+          }
+          continue;
+        }
+      }
+    }
+    function updateResultForModuleDeclaration(moduleDecl, currentModule) {
+      if (moduleDecl.body === void 0 || !ts9.isModuleBlock(moduleDecl.body)) {
+        return;
+      }
+      const referencedModuleInfo = getModuleLikeModuleInfo(
+        moduleDecl,
+        criteria,
+        typeChecker
+      );
+      if (referencedModuleInfo === null) {
+        return;
+      }
+      if (!currentModule.isExternal && referencedModuleInfo.isExternal) {
+        if (inlineDeclareExternals) {
+          collectionResult.statements.push(moduleDecl);
+        }
+        return;
+      }
+      updateResultForAnyModule(
+        moduleDecl.body.statements,
+        referencedModuleInfo
+      );
+    }
+    function addTypesReference(library) {
+      if (!collectionResult.typesReferences.has(library)) {
+        normalLog(`Library "${library}" will be added via reference directive`);
+        collectionResult.typesReferences.add(library);
+      }
+    }
+    function forEachNodeThatShouldBeImported(statement, callback) {
+      const statementsToImport = ts9.isVariableStatement(statement) ? statement.declarationList.declarations : ts9.isExportDeclaration(statement) && statement.exportClause !== void 0 ? ts9.isNamespaceExport(statement.exportClause) ? [statement.exportClause] : statement.exportClause.elements : [statement];
+      for (const statementToImport of statementsToImport) {
+        if (shouldNodeBeImported(statementToImport)) {
+          callback(statementToImport);
+        }
+      }
+    }
+    function updateImportsForStatement(statement) {
+      forEachNodeThatShouldBeImported(
+        statement,
+        (statementToImport) => {
+          addImport(statementToImport);
+          const sourceFile = statementToImport.getSourceFile();
+          const moduleInfo = getFileModuleInfo(sourceFile.fileName, criteria);
+          if (moduleInfo.type === 2 /* ShouldBeReferencedAsTypes */) {
+            addTypesReference(moduleInfo.typesLibraryName);
+          }
+        }
+      );
+    }
+    function getDeclarationUsagesSourceFiles(declaration) {
+      return new Set(
+        getExportedSymbolsUsingStatement(declaration).map((symbol) => getDeclarationsForSymbol(symbol)).reduce(
+          (acc, val) => acc.concat(val),
+          []
+        ).map(getClosestModuleLikeNode)
+      );
+    }
+    function getImportItem(importModuleSpecifier) {
+      let importItem = collectionResult.imports.get(importModuleSpecifier);
+      if (importItem === void 0) {
+        importItem = {
+          defaultImports: /* @__PURE__ */ new Set(),
+          namedImports: /* @__PURE__ */ new Map(),
+          nsImport: null,
+          requireImports: /* @__PURE__ */ new Set(),
+          reExports: /* @__PURE__ */ new Map()
+        };
+        collectionResult.imports.set(importModuleSpecifier, importItem);
+      }
+      return importItem;
+    }
+    function addRequireImport(importItem, preferredLocalName) {
+      importItem.requireImports.add(
+        collisionsResolver.addTopLevelIdentifier(preferredLocalName)
+      );
+    }
+    function addNamedImport(importItem, preferredLocalName, importedIdentifier) {
+      const newLocalName = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
+      const importedName = importedIdentifier.text;
+      importItem.namedImports.set(newLocalName, importedName);
+    }
+    function addReExport(importItem, moduleExportedName, reExportedName) {
+      importItem.reExports.set(reExportedName, moduleExportedName);
+    }
+    function addNsImport(importItem, preferredLocalName) {
+      if (importItem.nsImport === null) {
+        importItem.nsImport = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
+      }
+    }
+    function addDefaultImport(importItem, preferredLocalName) {
+      importItem.defaultImports.add(
+        collisionsResolver.addTopLevelIdentifier(preferredLocalName)
+      );
+    }
+    function addImport(statement) {
+      forEachImportOfStatement(
+        statement,
+        (imp, referencedModuleInfo, importModuleSpecifier) => {
+          if (referencedModuleInfo.type !== 1 /* ShouldBeImported */) {
+            return;
+          }
+          const importItem = getImportItem(importModuleSpecifier);
+          if (ts9.isImportEqualsDeclaration(imp)) {
+            addRequireImport(importItem, imp.name);
+            return;
+          }
+          if (ts9.isExportSpecifier(imp)) {
+            addNamedImport(
+              importItem,
+              imp.name,
+              imp.propertyName || imp.name
+            );
+            return;
+          }
+          if (ts9.isNamespaceExport(imp)) {
+            addNsImport(importItem, imp.name);
+            return;
+          }
+          if (ts9.isImportClause(imp) && imp.name !== void 0) {
+            addDefaultImport(importItem, imp.name);
+            return;
+          }
+          if (ts9.isImportSpecifier(imp)) {
+            addNamedImport(
+              importItem,
+              imp.name,
+              imp.propertyName || imp.name
+            );
+            return;
+          }
+          if (ts9.isNamespaceImport(imp)) {
+            addNsImport(importItem, imp.name);
+            return;
+          }
+        }
+      );
+    }
+    function forEachImportOfStatement(statement, callback) {
+      if (!ts9.isSourceFile(statement) && statement.name === void 0) {
+        throw new Error(
+          `Import/usage unnamed declaration: ${statement.getText()}`
+        );
+      }
+      getDeclarationUsagesSourceFiles(statement).forEach(
+        (sourceFile) => {
+          if (getModuleLikeModuleInfo(sourceFile, criteria, typeChecker).type !== 0 /* ShouldBeInlined */) {
+            return;
+          }
+          const sourceFileStatements = ts9.isSourceFile(
+            sourceFile
+          ) ? sourceFile.statements : sourceFile.body !== void 0 && ts9.isModuleBlock(sourceFile.body) ? sourceFile.body.statements : [];
+          sourceFileStatements.forEach((st) => {
+            if (!ts9.isImportEqualsDeclaration(st) && !ts9.isImportDeclaration(st) && !ts9.isExportDeclaration(st)) {
+              return;
+            }
+            const importModuleSpecifier = getImportModuleName(st);
+            if (importModuleSpecifier === null) {
+              return;
+            }
+            const referencedModuleInfo = getReferencedModuleInfo(
+              st,
+              criteria,
+              typeChecker
+            );
+            if (referencedModuleInfo === null) {
+              return;
+            }
+            if (ts9.isImportEqualsDeclaration(st)) {
+              if (areDeclarationSame(statement, st)) {
+                callback(st, referencedModuleInfo, importModuleSpecifier);
+              }
+              return;
+            }
+            if (ts9.isExportDeclaration(st) && st.exportClause !== void 0) {
+              if (ts9.isNamedExports(st.exportClause)) {
+                st.exportClause.elements.filter(areDeclarationSame.bind(null, statement)).forEach((specifier) => {
+                  callback(
+                    specifier,
+                    referencedModuleInfo,
+                    importModuleSpecifier
+                  );
+                });
+              } else {
+                if (isNodeUsed(st.exportClause)) {
+                  callback(
+                    st.exportClause,
+                    referencedModuleInfo,
+                    importModuleSpecifier
+                  );
+                }
+              }
+            } else if (ts9.isImportDeclaration(st) && st.importClause !== void 0) {
+              if (st.importClause.name !== void 0 && areDeclarationSame(statement, st.importClause)) {
+                callback(
+                  st.importClause,
+                  referencedModuleInfo,
+                  importModuleSpecifier
+                );
+              }
+              if (st.importClause.namedBindings !== void 0) {
+                if (ts9.isNamedImports(st.importClause.namedBindings)) {
+                  st.importClause.namedBindings.elements.filter(areDeclarationSame.bind(null, statement)).forEach((specifier) => {
+                    callback(
+                      specifier,
+                      referencedModuleInfo,
+                      importModuleSpecifier
+                    );
+                  });
+                } else {
+                  if (isNodeUsed(st.importClause)) {
+                    callback(
+                      st.importClause.namedBindings,
+                      referencedModuleInfo,
+                      importModuleSpecifier
+                    );
+                  }
+                }
+              }
+            }
+          });
+        }
+      );
+    }
+    function getInlinedSymbolsUsingSymbol(symbol, predicate) {
+      return Array.from(
+        typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []
+      ).filter((usedInSymbol) => {
+        if (!predicate(usedInSymbol)) {
+          return false;
+        }
+        return getDeclarationsForSymbol(usedInSymbol).some(
+          (decl) => {
+            const closestModuleLike = getClosestSourceFileLikeNode(decl);
+            const moduleInfo = getModuleLikeModuleInfo(
+              closestModuleLike,
+              criteria,
+              typeChecker
+            );
+            return moduleInfo.type === 0 /* ShouldBeInlined */;
+          }
+        );
+      });
+    }
+    function isSymbolUsedByInlinedSymbols(symbol, predicate, visitedSymbols = /* @__PURE__ */ new Set()) {
+      if (visitedSymbols.has(symbol)) {
+        return false;
+      }
+      visitedSymbols.add(symbol);
+      return Array.from(
+        typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []
+      ).some((usedInSymbol) => {
+        if (!predicate(usedInSymbol)) {
+          return isSymbolUsedByInlinedSymbols(
+            usedInSymbol,
+            predicate,
+            visitedSymbols
+          );
+        }
+        const usedByThisSymbol = getDeclarationsForSymbol(usedInSymbol).some(
+          (decl) => {
+            const closestModuleLike = getClosestSourceFileLikeNode(decl);
+            const moduleInfo = getModuleLikeModuleInfo(
+              closestModuleLike,
+              criteria,
+              typeChecker
+            );
+            return moduleInfo.type === 0 /* ShouldBeInlined */;
+          }
+        );
+        if (usedByThisSymbol) {
+          return true;
+        }
+        return isSymbolUsedByInlinedSymbols(
+          usedInSymbol,
+          predicate,
+          visitedSymbols
+        );
+      });
+    }
+    function isSymbolUsedByRootFileExports(symbol) {
+      return rootFileExportSymbols.some(
+        (rootSymbol) => typesUsageEvaluator.isSymbolUsedBySymbol(symbol, rootSymbol)
+      );
+    }
+    function isSymbolForGlobalDeclaration(symbol) {
+      return symbol.escapedName === ts9.InternalSymbolName.Global;
+    }
+    function isSymbolForDeclareModuleDeclaration(symbol) {
+      return getDeclarationsForSymbol(symbol).some(isDeclareModule);
+    }
+    function isNodeUsed(node) {
+      if (isNodeNamedDeclaration(node) || ts9.isSourceFile(node)) {
+        const nodeSymbol = getNodeSymbol(node, typeChecker);
+        if (nodeSymbol === null) {
+          return false;
+        }
+        const nodeUsedByDirectExports = isSymbolUsedByRootFileExports(nodeSymbol);
+        if (nodeUsedByDirectExports) {
+          return true;
+        }
+        if (inlineDeclareGlobals && isSymbolUsedByInlinedSymbols(nodeSymbol, isSymbolForGlobalDeclaration)) {
+          return true;
+        }
+        if (inlineDeclareExternals && isSymbolUsedByInlinedSymbols(
+          nodeSymbol,
+          isSymbolForDeclareModuleDeclaration
+        )) {
+          return true;
+        }
+        return false;
+      }
+      if (ts9.isVariableStatement(node)) {
+        return node.declarationList.declarations.some(
+          (declaration) => {
+            if (ts9.isObjectBindingPattern(declaration.name) || ts9.isArrayBindingPattern(declaration.name)) {
+              return declaration.name.elements.some(isNodeUsed);
+            }
+            return isNodeUsed(declaration);
+          }
+        );
+      }
+      if (ts9.isExportDeclaration(node) && node.exportClause !== void 0 && ts9.isNamespaceExport(node.exportClause)) {
+        return isNodeUsed(node.exportClause);
+      }
+      if (ts9.isImportClause(node) && node.namedBindings !== void 0) {
+        return isNodeUsed(node.namedBindings);
+      }
+      return false;
+    }
+    function shouldNodeBeImported(node) {
+      const nodeSymbol = getNodeSymbol(node, typeChecker);
+      if (nodeSymbol === null) {
+        return false;
+      }
+      return shouldSymbolBeImported(nodeSymbol);
+    }
+    function shouldSymbolBeImported(nodeSymbol) {
+      const isSymbolDeclaredInDefaultLibrary = getDeclarationsForSymbol(
+        nodeSymbol
+      ).some(
+        (declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile())
+      );
+      if (isSymbolDeclaredInDefaultLibrary) {
+        return false;
+      }
+      const symbolsDeclarations = getDeclarationsForSymbol(nodeSymbol);
+      const shouldSymbolBeInlined = symbolsDeclarations.every(
+        (decl) => getModuleLikeModuleInfo(
+          getClosestSourceFileLikeNode(decl),
+          criteria,
+          typeChecker
+        ).type === 0 /* ShouldBeInlined */
+      );
+      if (shouldSymbolBeInlined) {
+        return false;
+      }
+      return getExportedSymbolsUsingSymbol(nodeSymbol).length !== 0;
+    }
+    function getExportedSymbolsUsingStatement(node) {
+      const nodeSymbol = getNodeSymbol(node, typeChecker);
+      if (nodeSymbol === null) {
+        return [];
+      }
+      return getExportedSymbolsUsingSymbol(nodeSymbol);
+    }
+    function getExportedSymbolsUsingSymbol(nodeSymbol) {
+      const symbolsUsingNode = typesUsageEvaluator.getSymbolsUsingSymbol(nodeSymbol);
+      if (symbolsUsingNode === null) {
+        throw new Error(
+          `Something went wrong - getSymbolsUsingSymbol returned null but expected to be a set of symbols (symbol=${nodeSymbol.name})`
+        );
+      }
+      return [
+        ...rootFileExportSymbols.includes(nodeSymbol) ? [nodeSymbol] : [],
+        // symbols which are used in types directly
+        ...getInlinedSymbolsUsingSymbol(
+          nodeSymbol,
+          isSymbolUsedByRootFileExports
+        ),
+        // symbols which are used in global types i.e. in `declare global`s
+        ...inlineDeclareGlobals ? getInlinedSymbolsUsingSymbol(
+          nodeSymbol,
+          isSymbolForGlobalDeclaration
+        ) : [],
+        // symbols which are used in "declare module" types
+        ...inlineDeclareExternals ? getInlinedSymbolsUsingSymbol(
+          nodeSymbol,
+          isSymbolForDeclareModuleDeclaration
+        ) : []
+      ];
+    }
+    function areDeclarationSame(left, right) {
+      const leftSymbols = splitTransientSymbol(
+        getNodeSymbol(left, typeChecker),
+        typeChecker
+      );
+      const rightSymbols = splitTransientSymbol(
+        getNodeSymbol(right, typeChecker),
+        typeChecker
+      );
+      for (const leftSymbol of leftSymbols) {
+        if (rightSymbols.has(leftSymbol)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function createNamespaceForExports(exports, namespaceSymbol) {
+      function addSymbolToNamespaceExports(namespaceExports2, symbol) {
+        if (!typesUsageEvaluator.isSymbolUsedBySymbol(symbol, namespaceSymbol)) {
+          return;
+        }
+        const symbolKnownNames = collisionsResolver.namesForSymbol(symbol);
+        if (symbolKnownNames.size === 0) {
+          throw new Error(
+            `Cannot get local names for symbol '${symbol.getName()}' while generating namespaced export`
+          );
+        }
+        namespaceExports2.set(symbol.getName(), Array.from(symbolKnownNames)[0]);
+      }
+      function handleNamespacedImportOrExport(namespacedImportOrExport, namespaceExports2, symbol) {
+        if (namespacedImportOrExport.moduleSpecifier === void 0) {
+          return;
+        }
+        if (isReferencedModuleImportable(namespacedImportOrExport)) {
+          addSymbolToNamespaceExports(namespaceExports2, symbol);
+          return;
+        }
+        const referencedSourceFileSymbol = getNodeOwnSymbol(
+          namespacedImportOrExport.moduleSpecifier,
+          typeChecker
+        );
+        if (referencedSourceFileSymbol.exports === void 0) {
+          return;
+        }
+        if (ts9.isImportDeclaration(namespacedImportOrExport) && referencedSourceFileSymbol.exports.has(
+          ts9.InternalSymbolName.ExportEquals
+        )) {
+          return;
+        }
+        const localNamespaceName = createNamespaceForExports(
+          referencedSourceFileSymbol.exports,
+          symbol
+        );
+        if (localNamespaceName !== null) {
+          namespaceExports2.set(symbol.getName(), localNamespaceName);
+        }
+      }
+      function processExportSymbol(namespaceExports2, symbol) {
+        if (symbol.escapedName === ts9.InternalSymbolName.ExportStar) {
+          for (const exportStarDeclaration of getSymbolExportStarDeclarations(
+            symbol
+          )) {
+            if (exportStarDeclaration.moduleSpecifier === void 0) {
+              throw new Error(
+                `Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`
+              );
+            }
+            if (isReferencedModuleImportable(exportStarDeclaration)) {
+              throw new Error(
+                `Having a re-export from an importable module as a part of namespaced export is not supported yet.`
+              );
+            }
+            const referencedSourceFileSymbol = getNodeOwnSymbol(
+              exportStarDeclaration.moduleSpecifier,
+              typeChecker
+            );
+            referencedSourceFileSymbol.exports?.forEach(
+              processExportSymbol.bind(null, namespaceExports2)
+            );
+          }
+          return;
+        }
+        symbol.declarations?.forEach((decl) => {
+          if (ts9.isNamespaceExport(decl) && decl.parent.moduleSpecifier !== void 0) {
+            handleNamespacedImportOrExport(
+              decl.parent,
+              namespaceExports2,
+              symbol
+            );
+            return;
+          }
+          if (ts9.isExportSpecifier(decl)) {
+            const exportElementSymbol = getImportExportReferencedSymbol(
+              decl,
+              typeChecker
+            );
+            const namespaceImport = getDeclarationsForSymbol(
+              exportElementSymbol
+            ).find(ts9.isNamespaceImport);
+            if (namespaceImport !== void 0) {
+              handleNamespacedImportOrExport(
+                namespaceImport.parent.parent,
+                namespaceExports2,
+                symbol
+              );
+            }
+            return;
+          }
+        });
+        addSymbolToNamespaceExports(namespaceExports2, symbol);
+      }
+      function getIdentifierOfNamespaceImportFromInlinedModule(nsSymbol) {
+        for (const decl of getDeclarationsForSymbol(nsSymbol)) {
+          if (!ts9.isNamespaceExport(decl) && !ts9.isExportSpecifier(decl) && !ts9.isNamespaceImport(decl)) {
+            continue;
+          }
+          if (ts9.isNamespaceExport(decl) && !isReferencedModuleImportable(decl.parent)) {
+            return decl.name;
+          }
+          if (ts9.isNamespaceImport(decl) && !isReferencedModuleImportable(
+            decl.parent.parent
+          )) {
+            return decl.name;
+          }
+          if (ts9.isExportSpecifier(decl)) {
+            if (decl.parent.parent.moduleSpecifier !== void 0) {
+              if (isReferencedModuleImportable(decl.parent.parent)) {
+                continue;
+              }
+              if (getIdentifierOfNamespaceImportFromInlinedModule(
+                getImportExportReferencedSymbol(decl, typeChecker)
+              )) {
+                return decl.name;
+              }
+            }
+            const result = getDeclarationsForSymbol(
+              getImportExportReferencedSymbol(decl, typeChecker)
+            ).some((importDecl) => {
+              if (ts9.isNamespaceImport(importDecl)) {
+                return !isReferencedModuleImportable(
+                  importDecl.parent.parent
+                );
+              }
+              if (ts9.isImportSpecifier(importDecl)) {
+                return getIdentifierOfNamespaceImportFromInlinedModule(
+                  getImportExportReferencedSymbol(importDecl, typeChecker)
+                );
+              }
+              return false;
+            });
+            if (result) {
+              return decl.name;
+            }
+          }
+        }
+        return null;
+      }
+      const namespaceNameIdentifier = getIdentifierOfNamespaceImportFromInlinedModule(namespaceSymbol);
+      if (namespaceNameIdentifier === null) {
+        return null;
+      }
+      const namespaceExports = /* @__PURE__ */ new Map();
+      exports.forEach(processExportSymbol.bind(null, namespaceExports));
+      if (namespaceExports.size !== 0) {
+        const namespaceLocalName = collisionsResolver.addTopLevelIdentifier(
+          namespaceNameIdentifier
+        );
+        collectionResult.wrappedNamespaces.set(
+          namespaceLocalName,
+          namespaceExports
+        );
+        return namespaceLocalName;
+      }
+      return null;
+    }
+    function syncExports() {
+      for (const exp of rootFileExports) {
+        if (exp.type === 0 /* CommonJS */) {
+          continue;
+        }
+        const namespaceLocalName = exp.symbol.flags & ts9.SymbolFlags.ValueModule && exp.symbol.exports !== void 0 ? createNamespaceForExports(exp.symbol.exports, exp.originalSymbol) : null;
+        if (namespaceLocalName !== null) {
+          collectionResult.renamedExports.set(
+            exp.exportedName,
+            namespaceLocalName
+          );
+        }
+        const symbolKnownNames = collisionsResolver.namesForSymbol(exp.symbol);
+        if (symbolKnownNames.size === 0) {
+          continue;
+        }
+        if (symbolKnownNames.has(exp.exportedName)) {
+          if (shouldSymbolBeImported(exp.symbol)) {
+            collectionResult.renamedExports.set(
+              exp.exportedName,
+              exp.exportedName
+            );
+          }
+          continue;
+        }
+        collectionResult.renamedExports.set(
+          exp.exportedName,
+          Array.from(symbolKnownNames)[0]
+        );
+      }
+    }
+    for (const sourceFile of sourceFiles) {
+      verboseLog(`======= Processing ${sourceFile.fileName} =======`);
+      const updateFn = sourceFile === rootSourceFile ? updateResultForRootModule : updateResultForAnyModule;
+      const currentModule = getFileModuleInfo(sourceFile.fileName, criteria);
+      updateFn(sourceFile.statements, currentModule);
+      if (isNodeUsed(sourceFile)) {
+        switch (currentModule.type) {
+          case 1 /* ShouldBeImported */: {
+            updateImportsForStatement(sourceFile);
+            break;
+          }
+          case 0 /* ShouldBeInlined */: {
+            const sourceFileSymbol = getNodeSymbol(sourceFile, typeChecker);
+            if (sourceFileSymbol === null || sourceFileSymbol.exports === void 0) {
+              throw new Error(
+                `Cannot find symbol or exports for source file ${sourceFile.fileName}`
+              );
+            }
+            let namespaceIdentifier = null;
+            forEachImportOfStatement(sourceFile, (imp) => {
+              if (ts9.isNamespaceExport(imp) || ts9.isNamespaceImport(imp)) {
+                namespaceIdentifier = imp.name;
+              }
+            });
+            if (namespaceIdentifier === null) {
+              break;
+            }
+            createNamespaceForExports(
+              sourceFileSymbol.exports,
+              getNodeOwnSymbol(namespaceIdentifier, typeChecker)
+            );
+            break;
+          }
+        }
+      }
+    }
+    if (entryConfig.failOnClass) {
+      const classes = collectionResult.statements.filter(ts9.isClassDeclaration);
+      if (classes.length !== 0) {
+        const classesNames = classes.map(
+          (c) => c.name === void 0 ? "anonymous class" : c.name.text
+        );
+        throw new Error(
+          `${classes.length} class statement(s) are found in generated dts: ${classesNames.join(", ")}`
+        );
+      }
+    }
+    syncExports();
+    const exportReferencedTypes = outputOptions.exportReferencedTypes !== false;
+    function isExportedWithLocalName(namedDeclaration, exportedName) {
+      const nodeName = getNodeName(namedDeclaration);
+      if (nodeName === void 0) {
+        throw new Error(`Cannot find node name ${namedDeclaration.getText()}`);
+      }
+      return collisionsResolver.resolveReferencedIdentifier(
+        nodeName
+      ) === exportedName;
+    }
+    const renamedAndNotExplicitlyExportedTypes = [];
+    const output = generateOutput(
+      {
+        ...collectionResult,
+        resolveIdentifierName: (identifier) => {
+          if (ts9.isPropertyAccessOrQualifiedName(identifier)) {
+            return collisionsResolver.resolveReferencedQualifiedName(
+              identifier
+            );
+          } else {
+            return collisionsResolver.resolveReferencedIdentifier(identifier);
+          }
+        },
+        // eslint-disable-next-line complexity
+        getStatementSettings: (statement) => {
+          if (isAmbientModule(statement) || ts9.isExportDeclaration(statement)) {
+            return { shouldHaveExportKeyword: false, shouldHaveJSDoc: true };
+          }
+          const statementExports = getExportsForStatement(
+            rootFileExports,
+            typeChecker,
+            statement
+          );
+          const isExplicitlyExportedWithOriginalName = statementExports.find((exp) => {
+            if (ts9.isVariableStatement(statement)) {
+              for (const variableDeclaration of statement.declarationList.declarations) {
+                if (ts9.isIdentifier(variableDeclaration.name)) {
+                  const resolvedName = collisionsResolver.resolveReferencedIdentifier(
+                    variableDeclaration.name
+                  );
+                  if (exp.exportedName === resolvedName) {
+                    return true;
+                  }
+                  continue;
+                }
+                warnLog(
+                  `Unhandled variable identifier type detected (${ts9.SyntaxKind[variableDeclaration.name.kind]}). Please report this issue to https://github.com/timocov/dts-bundle-generator`
+                );
+              }
+              return false;
+            }
+            return isNodeNamedDeclaration(statement) && isExportedWithLocalName(statement, exp.exportedName);
+          }) !== void 0;
+          const onlyExplicitlyExportedShouldBeExported = !exportReferencedTypes || ts9.isClassDeclaration(statement) || ts9.isEnumDeclaration(statement) && !hasNodeModifier(statement, ts9.SyntaxKind.ConstKeyword) || ts9.isFunctionDeclaration(statement) || ts9.isVariableStatement(statement) || ts9.isModuleDeclaration(statement);
+          if (onlyExplicitlyExportedShouldBeExported) {
+            return {
+              shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName,
+              shouldHaveJSDoc: statementExports.length !== 0
+            };
+          }
+          if (isNodeNamedDeclaration(statement) && !isExportedWithLocalName(
+            statement,
+            getNodeName(statement).getText()
+          )) {
+            renamedAndNotExplicitlyExportedTypes.push(statement);
+            return {
+              shouldHaveExportKeyword: false,
+              shouldHaveJSDoc: statementExports.length !== 0
+            };
+          }
+          return {
+            shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName || statementExports.length === 0,
+            shouldHaveJSDoc: true
+          };
+        },
+        needStripConstFromConstEnum: (constEnum) => {
+          if (!program.getCompilerOptions().preserveConstEnums || !outputOptions.respectPreserveConstEnum) {
+            return false;
+          }
+          const enumSymbol = getNodeSymbol(constEnum, typeChecker);
+          if (enumSymbol === null) {
+            return false;
+          }
+          return rootFileExportSymbols.includes(enumSymbol);
+        },
+        needStripImportFromImportTypeNode: (node) => {
+          if (node.qualifier === void 0) {
+            return false;
+          }
+          if (!ts9.isLiteralTypeNode(node.argument) || !ts9.isStringLiteral(node.argument.literal)) {
+            return false;
+          }
+          return getReferencedModuleInfo(node, criteria, typeChecker)?.type === 0 /* ShouldBeInlined */;
+        }
+      },
+      {
+        sortStatements: outputOptions.sortNodes,
+        umdModuleName: outputOptions.umdModuleName,
+        noBanner: outputOptions.noBanner
+      }
+    );
+    if (renamedAndNotExplicitlyExportedTypes.length !== 0) {
+      warnLog(
+        `The following type nodes were renamed because of the name collisions and will not be exported from the generated bundle:
+- ${// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        renamedAndNotExplicitlyExportedTypes.map(
+          (node) => `${getNodeName(node).getText()} (from ${node.getSourceFile().fileName})`
+        ).join("\n- ")}${"\n"}This might lead to unpredictable and unexpected output, and possible breaking changes to your API.${"\n"}Consider either (re-)exporting them explicitly from the entry point, or disable --export-referenced-types option ('output.exportReferencedTypes' in the config).`
+      );
+    }
+    return output;
+  });
+}
+export {
+  generateDtsBundle
+};