exports.foo = function foo() {};

export function foo() {}

module.exports = {
  foo() {
    return 2 + 2;
  },
  bar: 3,
  baz: new RegExp("")
};

export function foo() {
  return 2 + 2;
}
export const bar = 3;
export const baz = new RegExp("");
export default {foo, bar, baz};

const {foo: bar} = require("./my-module");

import {foo as bar} from "./my-module.js";

const {
  foo: {bar: baz}
} = require("./my-module").something("bar");

import {something} from "./my-module.js";
const {
  foo: {bar: baz}
} = {something}.something("bar");

const pkg = require("./package.json");

import pkg from "./package.json" with {type: "json"};

import {transform} from "cjstoesm";

await transform({
  input: "src/**/*.*",
  outDir: "dist"
});

import {transform} from "cjstoesm";
import {writeFileSync} from "fs";

const result = await transform({
  input: "src/**/*.*",
  write: false
});

// Write to disk
for (const {fileName, text} of result.files) {
  writeFileSync(fileName, text);
}

interface TransformOptions {
  /**
   * The input glob(s) to match against the file system
   */
  input: string[] | string;
  /**
   * Optionally, the output directory to use. Defaults to inheriting that of the matched input files`
   */
  outDir?: string;
  /**
   * If write is false, no files will be written to disk
   */
  write: boolean;
  /**
   * The FileSystem to use. Useful if you want to work with a virtual file system. Defaults to using the "fs" module
   */
  fileSystem: FileSystem;
  /**
   * A logger that can print messages of varying severity depending on the log level
   */
  logger: Loggable;
  /**
   * The base directory (defaults to process.cwd())
   */
  cwd: string;
  /**
   * Determines how module specifiers are treated.
   * - external (default): CommonJS module specifiers identifying libraries or built-in modules are preserved (default)
   * - internal: CommonJS module specifiers identifying anything else than libraries or built-in modules are preserved
   * - always: CommonJS module specifiers are never transformed.
   * - never: CommonJS module specifiers are always transformed
   * It can also take a function that is invoked with a module specifier and returns a boolean determining whether or not it should be preserved
   */
  preserveModuleSpecifiers:
    | "always"
    | "never"
    | "external"
    | "internal"
    | ((specifier: string) => boolean);

  /**
   * Determines whether or not to include import attributes when converting require() calls referencing JSON files to ESM.
   * - true (default): Import attributes will always be added when relevant.
   * - false: Import attributes will never be added.
   * It can also take a function that is invoked with a module specifier and returns a boolean determining whether or not import attributes should be added
   */
  importAttributes: boolean | ((specifier: string) => boolean);

  /**
   * If given, a specific TypeScript version to use
   */
  typescript: typeof TS;
  /**
   * If true, debug information will be printed. If a function is provided, it will be invoked for each file name. Returning true from the function
   * determines that debug information will be printed related to that file
   */
  debug: boolean | string | ((file: string) => boolean);
}

import {ModuleKind, transpileModule} from "typescript";
import {cjsToEsm} from "cjstoesm";

const result = transpileModule(`const {join} = require("path");`, {
  transformers: cjsToEsm(),
  compilerOptions: {
    module: ModuleKind.ESNext
  }
});

// 'import { join } from "path"' is printed to the console
console.log(result.outputText);

import {ModuleKind, transpileModule} from "typescript";
import {cjsToEsmTransformerFactory} from "cjstoesm";

transpileModule(`const {join} = require("path");`, {
  transformers: {
    before: [cjsToEsmTransformerFactory(), someOtherTransformerFactory()],
    after: [
      // ...
    ],
    afterDeclarations: [
      // ...
    ]
  },
  compilerOptions: {
    module: ModuleKind.ESNext
  }
});

import {getDefaultCompilerOptions, createProgram, createCompilerHost} from "typescript";
import {cjsToEsm} from "cjstoesm";

const options = getDefaultCompilerOptions();
const program = createProgram({
  options,
  rootNames: ["my-file.js", "my-other-file.ts"],
  host: createCompilerHost(options)
});
program.emit(undefined, undefined, undefined, undefined, cjsToEsm());

import ts from "@rollup/plugin-typescript";
import {cjsToEsm} from "cjstoesm";

export default {
  input: "...",
  output: [
    /* ... */
  ],
  plugins: [
    ts({
      transformers: program => cjsToEsm({program})
    })
  ]
};

import {cjsToEsm} from "cjstoesm";
const config = {
  // ...
  module: {
    rules: [
      {
        // Match .mjs, .js, .jsx, and .tsx files
        test: /(\.mjs)|(\.[jt]sx?)$/,
        loader: "awesome-typescript-loader",
        options: {
          // ...
          getCustomTransformers: () => cjsToEsm()
        }
      }
    ]
  }
  // ...
};

import {cjsToEsm} from "cjstoesm";
const config = {
  // ...
  module: {
    rules: [
      {
        // Match .mjs, .js, .jsx, and .tsx files
        test: /(\.mjs)|(\.[jt]sx?)$/,
        loader: "ts-loader",
        options: {
          // ...
          getCustomTransformers: () => cjsToEsm
        }
      }
    ]
  }
  // ...
};

const result = true ? require("./foo") : require("./bar");

import foo from "./foo.js";
import bar from "./bar.js";

const result = true ? foo : bar;