@eliasku/ts-transformers 0.0.7 → 0.0.9

package/README.md

@@ -3,7 +3,7 @@
 
 # @eliasku/ts-transformers
 
-TypeScript transformer for aggressive code minification through type-aware property renaming and const enum inlining.
+TypeScript transformer for aggressive code minification through type-aware property renaming.
 
 ## Important Requirement
 
@@ -24,7 +24,7 @@ Two-phase optimization pipeline:
 
 Based on type analysis, properties are categorized as:
 
-- **Public (External)**: Exported from entry points → **no prefix** (preserved)
+- **Public**: Exported from entry points → **no prefix** (preserved)
 - **Private**: Everything else → prefixed with `$_` (mangled by minifier)
 
 **Example:**
@@ -52,19 +52,7 @@ class A{publicApi(){},a(){},b=1}
 
 ### Const Enum Inlining
 
-Replaces const enum accesses with literal values and removes declarations.
-
-```typescript
-// Before
-const enum Status {
-  Active = 1,
-  Inactive = 0,
-}
-const status = Status.Active;
-
-// After transformer + minifier
-const status = 1;
-```
+TypeScript currently inlines const enums, if you use traditional compiler for production build. Check if you have option `isolatedModules: false` disabled in `tsconfig.json`.
 
 ## Usage
 
@@ -79,11 +67,16 @@ const bundle = await rollup({
   input: "./src/index.ts",
   plugins: [
     typescript({
+      compilerOptions: {
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        lib: ["DOM", "ESNext"],
+      },
       transformers: (program) => ({
         before: [
           optimizer(program, {
-            entrySourceFiles: ["./src/index.ts"],
-            inlineConstEnums: true,
+            entrySourceFiles: ["src/index.ts"],
           }),
         ],
       }),
@@ -107,6 +100,8 @@ await build({
 });
 ```
 
+**Note**: This plugin uses `@rollup/plugin-typescript`. The transformer receives a TypeScript `Program` object directly.
+
 ## Options
 
 ### entrySourceFiles (required)
@@ -154,10 +149,6 @@ class AppComponent {
 }
 ```
 
-### inlineConstEnums (optional, default: true)
-
-Inline const enum values and remove declarations.
-
 ## Complete Example
 
 ```typescript

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eliasku/ts-transformers",
   "description": "TypeScript transformer for code optimization",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -40,7 +40,6 @@
     "plugin",
     "transformer",
     "minify",
-    "const-enum",
     "treeshake",
     "mangle"
   ],

package/src/index.ts

@@ -1,6 +1,4 @@
 import ts from "typescript";
-export type { OptimizerOptions } from "./types";
-
 import { ExportsSymbolTree } from "./exports/tracker";
 import {
   getDeclarationsForSymbol,
@@ -16,25 +14,17 @@ import {
 } from "./utils/symbol-utils";
 import { getNodeJSDocComment } from "./utils/ast-utils";
 import { OptimizerOptions, defaultOptions, VisibilityType } from "./types";
-import { ConstEnumRegistry } from "./const-enum/registry";
-import { EnumEvaluator } from "./const-enum/evaluator";
-import { isConstEnumType } from "./const-enum/utils";
 import { LOGS } from "./config";
 
-export const optimizer = (
-  program: ts.Program,
-  config?: Partial<OptimizerOptions>,
-): ts.TransformerFactory<ts.SourceFile> => createTransformerFactory(program, config);
+export type { OptimizerOptions } from "./types";
 
-function createTransformerFactory(
+export const optimizer = (
   program: ts.Program,
   options?: Partial<OptimizerOptions>,
-): ts.TransformerFactory<ts.SourceFile> {
+): ts.TransformerFactory<ts.SourceFile> => {
   const fullOptions: OptimizerOptions = { ...defaultOptions, ...options };
   const typeChecker = program.getTypeChecker();
   const exportsSymbolTree = new ExportsSymbolTree(program, fullOptions.entrySourceFiles);
-  const constEnumRegistry = new ConstEnumRegistry(program);
-  const enumEvaluator = new EnumEvaluator();
 
   const cache = new Map<ts.Symbol, VisibilityType>();
 
@@ -45,37 +35,6 @@ function createTransformerFactory(
 
   return (context: ts.TransformationContext) => {
     function transformNode(node: ts.Node): ts.Node | undefined {
-      if (fullOptions.inlineConstEnums !== false) {
-        if (ts.isPropertyAccessExpression(node)) {
-          const inlined = tryInlineConstEnum(node);
-          if (inlined) return inlined;
-        }
-
-        // don't remove any imports
-        if (fullOptions.keepConstEnumEmptyDeclaration !== true) {
-          if (ts.isImportSpecifier(node)) {
-            const removed = tryRemoveConstEnumImport(node);
-            if (removed === undefined || node.isTypeOnly) {
-              return undefined;
-            }
-          }
-
-          if (ts.isExportSpecifier(node)) {
-            const removed = tryRemoveConstEnumExport(node);
-            if (removed === undefined || node.isTypeOnly) {
-              return undefined;
-            }
-          }
-
-          if (ts.isImportClause(node)) {
-            const removed = tryRemoveConstEnumImportClause(node);
-            if (removed === undefined) {
-              return undefined;
-            }
-          }
-        }
-      }
-
       // const a = { node }
       if (ts.isShorthandPropertyAssignment(node)) {
         return handleShorthandPropertyAssignment(node);
@@ -578,7 +537,6 @@ function createTransformerFactory(
               return putToCache(nodeSymbol, VisibilityType.External);
             }
 
-            // TODO: mute enum renames
             if (ts.isEnumDeclaration(currentNode)) {
               return putToCache(nodeSymbol, VisibilityType.External);
             }
@@ -658,84 +616,9 @@ function createTransformerFactory(
       return isSymbolClassMember(typeChecker.getSymbolAtLocation(node));
     }
 
-    function tryInlineConstEnum(node: ts.PropertyAccessExpression): ts.Expression | null {
-      const expressionType = typeChecker.getTypeAtLocation(node.expression);
-      if (!isConstEnumType(expressionType)) return null;
-
-      const enumSymbol = expressionType.symbol || expressionType.aliasSymbol;
-      if (!enumSymbol) return null;
-
-      const enumInfo = constEnumRegistry.getEnumInfo(enumSymbol);
-      if (!enumInfo) return null;
-
-      const memberValue = enumInfo.members.get(node.name.text)?.value;
-      if (memberValue === undefined || memberValue === null) return null;
-
-      return enumEvaluator.createLiteral(memberValue);
-    }
-
-    function tryRemoveConstEnumImport(node: ts.ImportSpecifier): ts.ImportSpecifier | undefined {
-      const importedType = typeChecker.getTypeAtLocation(node);
-      if (isConstEnumType(importedType)) {
-        return undefined;
-      }
-      return node;
-    }
-
-    function tryRemoveConstEnumExport(node: ts.ExportSpecifier): ts.ExportSpecifier | undefined {
-      const importedType = typeChecker.getTypeAtLocation(node);
-      if (isConstEnumType(importedType)) {
-        return undefined;
-      }
-      return node;
-    }
-
-    function tryRemoveConstEnumImportClause(node: ts.ImportClause): ts.ImportClause | undefined {
-      if (!node.name) return node;
-      const type = typeChecker.getTypeAtLocation(node.name);
-      if (isConstEnumType(type)) {
-        return undefined;
-      }
-      return node;
-    }
-
-    return (sourceFile: ts.SourceFile) => {
-      function handleEnumDeclaration(node: ts.EnumDeclaration): ts.EnumDeclaration | undefined {
-        if (fullOptions.inlineConstEnums === false) return node;
-        if (!hasModifier(node, ts.SyntaxKind.ConstKeyword)) return node;
-
-        if (sourceFile.isDeclarationFile) {
-          return ts.factory.updateEnumDeclaration(
-            node,
-            node.modifiers?.filter((m) => m.kind !== ts.SyntaxKind.ConstKeyword),
-            node.name,
-            node.members,
-          );
-        }
-
-        if (fullOptions.keepConstEnumEmptyDeclaration === true) {
-          return ts.factory.updateEnumDeclaration(node, node.modifiers, node.name, []);
-        }
-        return undefined;
-      }
-
-      function wrapTransformNode(node: ts.Node): ts.Node | undefined {
-        if (ts.isEnumDeclaration(node)) {
-          const result = handleEnumDeclaration(node);
-          if (result !== node) {
-            if (result) {
-              return transformNode(result);
-            }
-            return result;
-          }
-        }
-        return transformNode(node);
-      }
-
-      const wrappedTransformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
-        ts.visitEachChild(wrapTransformNode(node), wrappedTransformNodeAndChildren, context);
+    const transformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
+      ts.visitEachChild(transformNode(node), transformNodeAndChildren, context);
 
-      return wrappedTransformNodeAndChildren(sourceFile) as ts.SourceFile;
-    };
+    return (sourceFile: ts.SourceFile) => transformNodeAndChildren(sourceFile) as ts.SourceFile;
   };
-}
+};

package/src/types.ts

@@ -27,16 +27,6 @@ export interface OptimizerOptions {
    * A field is treated as "decorated" if itself or any its parent (on type level) has a decorator.
    */
   ignoreDecorated: boolean;
-
-  /**
-   * Whether to inline const enum values.
-   */
-  inlineConstEnums?: boolean;
-
-  /**
-   * Keep empty const enum declarations, keep imports / exports
-   */
-  keepConstEnumEmptyDeclaration?: boolean;
 }
 
 export const enum VisibilityType {
@@ -49,5 +39,4 @@ export const defaultOptions: OptimizerOptions = {
   privatePrefix: "$_",
   publicJSDocTag: "public",
   ignoreDecorated: false,
-  inlineConstEnums: true,
 };

package/src/const-enum/evaluator.ts

@@ -1,158 +0,0 @@
-import ts from "typescript";
-
-export type EnumValue = string | number;
-
-export interface EvaluationContext {
-  localMembers: Map<string, EnumValue>;
-  allowEnumReferences: boolean;
-}
-
-export class EnumEvaluator {
-  private lastImplicitValue = -1;
-
-  reset(): void {
-    this.lastImplicitValue = -1;
-  }
-
-  evaluate(expr: ts.Expression, context: EvaluationContext): EnumValue {
-    if (ts.isPrefixUnaryExpression(expr)) {
-      return this.evaluateUnary(expr, context);
-    } else if (ts.isBinaryExpression(expr)) {
-      return this.evaluateBinary(expr, context);
-    } else if (ts.isStringLiteralLike(expr)) {
-      return expr.text;
-    } else if (ts.isNumericLiteral(expr)) {
-      return +expr.text;
-    } else if (ts.isParenthesizedExpression(expr)) {
-      return this.evaluate(expr.expression, context);
-    } else if (ts.isIdentifier(expr)) {
-      return this.evaluateIdentifier(expr, context);
-    } else if (
-      expr.kind === ts.SyntaxKind.TrueKeyword ||
-      expr.kind === ts.SyntaxKind.FalseKeyword ||
-      expr.kind === ts.SyntaxKind.NullKeyword
-    ) {
-      throw this.createError(expr, `Unsupported literal: ${ts.SyntaxKind[expr.kind]}`);
-    }
-
-    throw this.createError(expr, `Cannot evaluate expression: ${expr.getText()}`);
-  }
-
-  evaluateEnumMember(member: ts.EnumMember, context: EvaluationContext): EnumValue {
-    if (!member.initializer) {
-      return this.evaluateImplicitMember(member);
-    }
-
-    const value = this.evaluate(member.initializer, context);
-
-    if (typeof value === "number") {
-      this.lastImplicitValue = value;
-    }
-
-    return value;
-  }
-
-  private evaluateImplicitMember(member: ts.EnumMember): EnumValue {
-    const name = ts.isIdentifier(member.name) ? member.name.text : `<computed>`;
-    void name;
-
-    if (this.lastImplicitValue === -1) {
-      this.lastImplicitValue = 0;
-      return 0;
-    }
-
-    const nextValue = this.lastImplicitValue + 1;
-    this.lastImplicitValue = nextValue;
-    return nextValue;
-  }
-
-  createLiteral(value: EnumValue): ts.Expression {
-    if (typeof value === "string") {
-      return ts.factory.createStringLiteral(value);
-    } else {
-      if (value < 0) {
-        return ts.factory.createPrefixMinus(ts.factory.createNumericLiteral(Math.abs(value).toString()));
-      }
-      return ts.factory.createNumericLiteral(value.toString());
-    }
-  }
-
-  private evaluateUnary(expr: ts.PrefixUnaryExpression, context: EvaluationContext): number {
-    const value = this.evaluate(expr.operand, context);
-    if (typeof value !== "number") {
-      throw this.createError(expr, `Unary operator requires numeric value, got ${typeof value}`);
-    }
-
-    switch (expr.operator) {
-      case ts.SyntaxKind.PlusToken:
-        return value;
-      case ts.SyntaxKind.MinusToken:
-        return -value;
-      case ts.SyntaxKind.TildeToken:
-        return ~value;
-      default:
-        throw this.createError(expr, `Unsupported unary operator: ${ts.SyntaxKind[expr.operator]}`);
-    }
-  }
-
-  private evaluateBinary(expr: ts.BinaryExpression, context: EvaluationContext): EnumValue {
-    const left = this.evaluate(expr.left, context);
-    const right = this.evaluate(expr.right, context);
-
-    if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-      return left + right;
-    }
-
-    if (typeof left === "number" && typeof right === "number") {
-      switch (expr.operatorToken.kind) {
-        case ts.SyntaxKind.BarToken:
-          return left | right;
-        case ts.SyntaxKind.AmpersandToken:
-          return left & right;
-        case ts.SyntaxKind.GreaterThanGreaterThanToken:
-          return left >> right;
-        case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-          return left >>> right;
-        case ts.SyntaxKind.LessThanLessThanToken:
-          return left << right;
-        case ts.SyntaxKind.CaretToken:
-          return left ^ right;
-        case ts.SyntaxKind.AsteriskToken:
-          return left * right;
-        case ts.SyntaxKind.SlashToken:
-          return left / right;
-        case ts.SyntaxKind.PlusToken:
-          return left + right;
-        case ts.SyntaxKind.MinusToken:
-          return left - right;
-        case ts.SyntaxKind.PercentToken:
-          return left % right;
-        case ts.SyntaxKind.AsteriskAsteriskToken:
-          return left ** right;
-        default:
-          throw this.createError(expr, `Unsupported binary operator: ${ts.SyntaxKind[expr.operatorToken.kind]}`);
-      }
-    }
-
-    throw this.createError(expr, `Cannot evaluate binary expression with types ${typeof left} and ${typeof right}`);
-  }
-
-  private evaluateIdentifier(expr: ts.Identifier, context: EvaluationContext): EnumValue {
-    if (!context.allowEnumReferences) {
-      throw this.createError(expr, `Cannot reference enum member here`);
-    }
-
-    const value = context.localMembers.get(expr.text);
-    if (value === undefined) {
-      throw this.createError(expr, `Undefined enum member: ${expr.text}`);
-    }
-
-    return value;
-  }
-
-  private createError(node: ts.Node, message: string): Error {
-    const sourceFile = node.getSourceFile();
-    const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    return new Error(`${sourceFile.fileName}:${pos.line + 1}:${pos.character}: ${message}`);
-  }
-}

package/src/const-enum/registry.ts

@@ -1,152 +0,0 @@
-import ts from "typescript";
-import { EnumValue, EvaluationContext } from "./evaluator";
-import { EnumEvaluator } from "./evaluator";
-import { isConstEnumSymbol } from "./utils";
-import { hasModifier } from "../typescript-helpers";
-
-export interface ConstEnumInfo {
-  declaration: ts.EnumDeclaration;
-  members: Map<string, ConstEnumMemberInfo>;
-  isExported: boolean;
-  sourceFile: ts.SourceFile;
-}
-
-export interface ConstEnumMemberInfo {
-  declaration: ts.EnumMember;
-  name: string;
-  value: EnumValue | null;
-}
-
-export class ConstEnumRegistry {
-  private readonly program: ts.Program;
-  private readonly typeChecker: ts.TypeChecker;
-  private readonly enumDeclarations: Map<string, ConstEnumInfo>;
-
-  constructor(program: ts.Program) {
-    this.program = program;
-    this.typeChecker = program.getTypeChecker();
-    this.enumDeclarations = new Map();
-    this.collectConstEnumsFromEntryPoints();
-  }
-
-  getEnum(enumName: string): ConstEnumInfo | undefined {
-    return this.enumDeclarations.get(enumName);
-  }
-
-  getEnumInfo(symbol: ts.Symbol): ConstEnumInfo | undefined {
-    const name = this.getEnumSymbolName(symbol);
-    return this.enumDeclarations.get(name);
-  }
-
-  getMemberValue(enumName: string, memberName: string): EnumValue | undefined {
-    const enumInfo = this.enumDeclarations.get(enumName);
-    if (!enumInfo) return undefined;
-    const memberInfo = enumInfo.members.get(memberName);
-    return memberInfo?.value ?? undefined;
-  }
-
-  getAllEnums(): ConstEnumInfo[] {
-    return Array.from(this.enumDeclarations.values());
-  }
-
-  getEnumCount(): number {
-    return this.enumDeclarations.size;
-  }
-
-  private collectConstEnumsFromEntryPoints(): void {
-    const sourceFiles = this.program.getSourceFiles();
-
-    for (const sourceFile of sourceFiles) {
-      if (sourceFile.isDeclarationFile) {
-        continue;
-      }
-
-      this.registerConstEnumFromSource(sourceFile);
-    }
-  }
-
-  private registerConstEnumFromSource(sourceFile: ts.SourceFile): void {
-    ts.forEachChild(sourceFile, (node) => {
-      if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
-        const symbol = this.typeChecker.getSymbolAtLocation(node.name);
-        if (symbol && isConstEnumSymbol(symbol)) {
-          this.registerEnum(symbol, node, sourceFile);
-        }
-      }
-    });
-  }
-
-  private registerEnum(symbol: ts.Symbol, declaration: ts.EnumDeclaration, sourceFile: ts.SourceFile): void {
-    const name = this.getEnumSymbolName(symbol);
-
-    if (this.enumDeclarations.has(name)) {
-      return;
-    }
-
-    const isExported = this.hasExportModifier(declaration);
-
-    const enumInfo: ConstEnumInfo = {
-      declaration,
-      members: new Map(),
-      isExported,
-      sourceFile,
-    };
-
-    this.evaluateEnumMembers(enumInfo);
-
-    this.enumDeclarations.set(name, enumInfo);
-  }
-
-  private hasExportModifier(node: ts.Node): boolean {
-    if (!ts.canHaveModifiers(node)) {
-      return false;
-    }
-    const modifiers = ts.getModifiers(node);
-    if (!modifiers) {
-      return false;
-    }
-    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-  }
-
-  private evaluateEnumMembers(enumInfo: ConstEnumInfo): void {
-    const evaluator = new EnumEvaluator();
-    evaluator.reset();
-    const context: EvaluationContext = {
-      localMembers: new Map(),
-      allowEnumReferences: true,
-    };
-
-    for (const member of enumInfo.declaration.members) {
-      if (!ts.isIdentifier(member.name)) continue;
-
-      try {
-        const value = evaluator.evaluateEnumMember(member, context);
-        context.localMembers.set(member.name.text, value);
-        enumInfo.members.set(member.name.text, {
-          declaration: member,
-          name: member.name.text,
-          value,
-        });
-      } catch (error) {
-        throw new Error(
-          `Failed to evaluate const enum member ${enumInfo.declaration.name.text}.${member.name.text}: ${error}`,
-        );
-      }
-    }
-  }
-
-  private getEnumDeclaration(symbol: ts.Symbol): ts.EnumDeclaration | null {
-    const decl = symbol.declarations?.[0];
-    if (decl && ts.isEnumDeclaration(decl)) {
-      return decl;
-    }
-    return null;
-  }
-
-  private getEnumSymbolName(symbol: ts.Symbol): string {
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      return this.typeChecker.getAliasedSymbol(symbol).name;
-    }
-    return symbol.name;
-  }
-}

package/src/const-enum/utils.ts

@@ -1,13 +0,0 @@
-import ts from "typescript";
-
-export const isConstEnumSymbol = (symbol: ts.Symbol): boolean => (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
-
-export const isConstEnumType = (type: ts.Type | undefined): boolean => {
-  if (type) {
-    const symbol = type.symbol || type.aliasSymbol;
-    if (symbol) {
-      return (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
-    }
-  }
-  return false;
-};

package/src/typescript-helpers.ts

@@ -1,204 +0,0 @@
-import ts from "typescript";
-
-const namedDeclarationKinds = [
-  ts.SyntaxKind.InterfaceDeclaration,
-  ts.SyntaxKind.ClassDeclaration,
-  ts.SyntaxKind.EnumDeclaration,
-  ts.SyntaxKind.TypeAliasDeclaration,
-  ts.SyntaxKind.ModuleDeclaration,
-  ts.SyntaxKind.FunctionDeclaration,
-  ts.SyntaxKind.VariableDeclaration,
-  ts.SyntaxKind.PropertySignature,
-  ts.SyntaxKind.Parameter,
-];
-
-export const isNodeNamedDeclaration = (node: ts.Node): node is ts.NamedDeclaration =>
-  namedDeclarationKinds.indexOf(node.kind) !== -1;
-
-export function getActualSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): ts.Symbol {
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = typeChecker.getAliasedSymbol(symbol);
-  }
-
-  return symbol;
-}
-
-export function splitTransientSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): ts.Symbol[] {
-  // actually I think we even don't need to operate/use "Transient" symbols anywhere
-  // it's kind of aliased symbol, but just merged
-  // but it's hard to refractor everything to use array of symbols instead of just symbol
-  // so let's fix it for some places
-  if ((symbol.flags & ts.SymbolFlags.Transient) === 0) {
-    return [symbol];
-  }
-
-  // "Transient" symbol is kinda "merged" symbol
-  // I don't really know is this way to "split" is correct
-  // but it seems that it works for now ¯\_(ツ)_/¯
-  const declarations = getDeclarationsForSymbol(symbol);
-  const result: ts.Symbol[] = [];
-  for (const declaration of declarations) {
-    if (!isNodeNamedDeclaration(declaration) || declaration.name === undefined) {
-      continue;
-    }
-
-    const sym = typeChecker.getSymbolAtLocation(declaration.name);
-    if (sym === undefined) {
-      continue;
-    }
-
-    result.push(getActualSymbol(sym, typeChecker));
-  }
-
-  return result;
-}
-
-export function getDeclarationsForSymbol(symbol: ts.Symbol): ts.Declaration[] {
-  const result: ts.Declaration[] = [];
-
-  if (symbol.declarations !== undefined) {
-    result.push(...symbol.declarations);
-  }
-
-  if (symbol.valueDeclaration !== undefined) {
-    // push valueDeclaration might be already in declarations array
-    // so let's check first to avoid duplication nodes
-    if (!result.includes(symbol.valueDeclaration)) {
-      result.push(symbol.valueDeclaration);
-    }
-  }
-
-  return result;
-}
-
-export function getExportsForSourceFile(typeChecker: ts.TypeChecker, sourceFileSymbol: ts.Symbol): ts.Symbol[] {
-  if (sourceFileSymbol.exports !== undefined) {
-    const commonJsExport = sourceFileSymbol.exports.get(ts.InternalSymbolName.ExportEquals);
-    if (commonJsExport !== undefined) {
-      return [getActualSymbol(commonJsExport, typeChecker)];
-    }
-  }
-
-  const result: ts.Symbol[] = typeChecker.getExportsOfModule(sourceFileSymbol);
-
-  if (sourceFileSymbol.exports !== undefined) {
-    const defaultExportSymbol = sourceFileSymbol.exports.get(ts.InternalSymbolName.Default);
-    if (defaultExportSymbol !== undefined) {
-      if (!result.includes(defaultExportSymbol)) {
-        // it seems that default export is always returned by getExportsOfModule
-        // but let's add it to be sure add if there is no such export
-        result.push(defaultExportSymbol);
-      }
-    }
-  }
-
-  return result.map((symbol: ts.Symbol) => getActualSymbol(symbol, typeChecker));
-}
-
-export type ClassMember =
-  | ts.MethodDeclaration
-  | ts.PropertyDeclaration
-  | ts.GetAccessorDeclaration
-  | ts.SetAccessorDeclaration;
-
-export const isClassMember = (node: ts.Node): node is ClassMember =>
-  ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node);
-
-export function getClassOfMemberSymbol(
-  nodeSymbol: ts.Symbol,
-): ts.ClassLikeDeclaration | ts.ObjectLiteralExpression | ts.TypeLiteralNode | ts.InterfaceDeclaration | null {
-  const classMembers = getClassMemberDeclarations(nodeSymbol);
-  if (classMembers.length !== 0) {
-    // we need any member to get class' declaration
-    const classMember = classMembers[0];
-    if (isConstructorParameter(classMember)) {
-      return (classMember.parent as ts.ConstructorDeclaration).parent;
-    }
-
-    // we're sure that it is a class, not interface
-    return classMember.parent as ts.ClassLikeDeclaration | ts.ObjectLiteralExpression;
-  }
-
-  return null;
-}
-
-export const hasPrivateKeyword = (node: ClassMember | ts.ParameterDeclaration) =>
-  hasModifier(node, ts.SyntaxKind.PrivateKeyword);
-
-function getModifiers(node: ts.Node): readonly ts.Modifier[] {
-  if (isBreakingTypeScriptApi(ts)) {
-    if (!ts.canHaveModifiers(node)) {
-      return [];
-    }
-
-    return ts.getModifiers(node) || [];
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  return node.modifiers || [];
-}
-
-export const hasModifier = (node: ts.Node, modifier: ts.SyntaxKind): boolean =>
-  ts.canHaveModifiers(node) && getModifiers(node)?.some((mod) => mod.kind === modifier);
-
-function getDecorators(node: ts.Node): readonly unknown[] {
-  if (isBreakingTypeScriptApi(ts)) {
-    if (!ts.canHaveDecorators(node)) {
-      return [];
-    }
-
-    return ts.getDecorators(node) || [];
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  return node.decorators || [];
-}
-
-export const hasDecorators = (node: ts.Node) => getDecorators(node).length !== 0;
-
-export const isConstructorParameter = (node: ts.Node): node is ts.ParameterDeclaration =>
-  ts.isParameter(node) &&
-  ts.isConstructorDeclaration(node.parent as ts.Node) &&
-  (hasModifier(node, ts.SyntaxKind.PublicKeyword) ||
-    hasModifier(node, ts.SyntaxKind.ProtectedKeyword) ||
-    hasModifier(node, ts.SyntaxKind.PrivateKeyword) ||
-    hasModifier(node, ts.SyntaxKind.ReadonlyKeyword));
-
-function getClassMemberDeclarations(symbol: ts.Symbol | undefined): (ClassMember | ts.ParameterDeclaration)[] {
-  if (symbol === undefined) {
-    return [];
-  }
-
-  const declarations = symbol.getDeclarations();
-  if (declarations === undefined) {
-    return [];
-  }
-
-  return declarations.filter((x: ts.Declaration): x is ClassMember | ts.ParameterDeclaration => {
-    return isClassMember(x) || isConstructorParameter(x);
-  });
-}
-
-export const isSymbolClassMember = (symbol: ts.Symbol | undefined) => getClassMemberDeclarations(symbol).length !== 0;
-
-export const isPrivateClassMember = (symbol: ts.Symbol | undefined) =>
-  getClassMemberDeclarations(symbol).some(hasPrivateKeyword);
-
-export function getNodeJSDocComment(node: ts.Node): string {
-  const start = node.getStart();
-  const jsDocStart = node.getStart(undefined, true);
-  return node.getSourceFile().getFullText().substring(jsDocStart, start).trim();
-}
-
-// decorators and modifiers-related api added in ts 4.8
-interface BreakingTypeScriptApi {
-  canHaveDecorators(node: ts.Node): boolean;
-  getDecorators(node: ts.Node): readonly ts.Decorator[] | undefined;
-  canHaveModifiers(node: ts.Node): boolean;
-  getModifiers(node: ts.Node): readonly ts.Modifier[] | undefined;
-}
-
-const isBreakingTypeScriptApi = (compiler: object): compiler is BreakingTypeScriptApi =>
-  "canHaveDecorators" in compiler;