/**
     * Load schema package information from a schema directory.
     */
    private async loadSchemaPackageInfoAsync(schemaName: string): Promise<PackageInfo | null> {
        // By convention there is a .js file with the same name as the schema directory,
        // so the module path is just the name/name. Note schemas are not required to
        // have a package.json that enables them to be packaged separately; they may only
        // be packaged along with translators. In that case NO schema package info will
        // be loaded here.
        let schemaModulePath = schemaName + "/" + schemaName;
        let schemaPackageJsonPath = schemaName + "/package.json";

        if (!(await fs.exists(path.join(this.sourceDirectory, schemaModulePath + ".js"))) ||
                !(await fs.exists(path.join(this.sourceDirectory, schemaPackageJsonPath)))) {
            // The requested schema package was not found.
            return null;
        }

        let packageJson: any = await this.loadJsonAsync(schemaPackageJsonPath);
        return {
            description: packageJson.description,
            name: packageJson.name,
            onboardingInfo: null,
            schemas: [{
                moduleName: schemaModulePath,
            }],
            translators: [],
            version: packageJson.version,
        };
    }

    private async loadOnboardingPackageInfoAsync(
        onboardingName: string): Promise<PackageInfo | null> {

        // By convention there is package.json files under 'js' directory. 
        let onboardingManifestPath = onboardingName + "/js/manifest.xml";
        let onboardinPackageJsonPath = onboardingName + "/js/package.json";
        let translatorModulePath = onboardingName + "/js/thingOnboarding";

        if (!(await fs.exists(path.join(this.sourceDirectory, translatorModulePath + ".js"))) ||
            !(await fs.exists(path.join(this.sourceDirectory, onboardingManifestPath))) ||
            !(await fs.exists(path.join(this.sourceDirectory, onboardinPackageJsonPath)))) {
            // The requested onboarding package was not found.
            return null;
        }

        let packageJson: any = await this.loadJsonAsync(onboardinPackageJsonPath);
        let manifestXml: any = await this.loadXmlAsync(onboardingManifestPath);
        let manifestXmlRoot: any = manifestXml && manifestXml.manifest;

        if (!packageJson || !manifestXmlRoot) {
            return null;
        }

        // Parse schema info from the manifest.
        let schemaInfos: any[] = [];
        let schemaModulePaths: string[] = [];
        if (Array.isArray(manifestXmlRoot.schemas) &&
                manifestXmlRoot.schemas.length === 1 &&
                Array.isArray(manifestXmlRoot.schemas[0].schema)) {
            let schemaElements = manifestXmlRoot.schemas[0].schema;
           // TODO: Will onboarding schemas also have 'main' schema concept ?

            schemaElements.forEach((schemaElement: any) => {
                let schemaId: string = schemaElement.$.id;
                if (schemaId) {
                    // By convention the schema module file and its parent directory
                    // both match the name of the schema.
                    let schemaModulePath: string = packageJson.name + "/" + schemaId + "/" + schemaId;
                    schemaModulePaths.push(schemaModulePath);
                    schemaInfos.push({
                        moduleName: schemaModulePath,
                    });
                }
            });
        }

        return {
            description: packageJson.description,
            name: packageJson.name,
            onboardingInfo: {
                moduleName: translatorModulePath,
                schemas: schemaModulePaths },
            schemas: schemaInfos,
            translators: [],
            version: packageJson.version,
        };
    }

async function runProject(project: string, shouldSave: boolean): Promise<boolean> {
  const repoURL = EXAMPLES[project];
  const originalCwd = process.cwd();
  const repoDir = `./example-runner/example-repos/${project}`;

  if (!(await exists(repoDir))) {
    console.log(`Directory ${repoDir} not found, cloning a new one.`);
    await run(`git clone ${repoURL} ${repoDir}`);
  }
  process.chdir(repoDir);

  const revPath = `../../example-configs/${project}.revision`;
  const patchPath = `../../example-configs/${project}.patch`;
  if (!(await exists(revPath)) || !(await exists(patchPath)) || shouldSave) {
    console.log(`Generating metadata for ${project}`);
    await run(`git rev-parse HEAD > ${revPath}`);
    await run(`git diff HEAD > ${patchPath}`);
  }

  try {
    await run(`cat ${revPath} | xargs git reset --hard`);
    await run(`git clean -f`);
  } catch (e) {
    await run("git fetch");
    await run(`cat ${revPath} | xargs git reset --hard`);
    await run(`git clean -f`);
  }
  if ((await readFile(patchPath)).length) {
    await run(`cat ${patchPath} | git apply`);
    await run(`git add -A`);
  }

  await run("yarn");
  await run("yarn link sucrase");
  for (const integration of INTEGRATIONS) {
    await run(`yarn link @sucrase/${integration}`);
  }

  let passed = true;
  try {
    await run("yarn test");
  } catch (e) {
    passed = false;
    console.error(`Project ${project} failed tests.`);
    console.error(e);
    process.exitCode = 1;
  }
  process.chdir(originalCwd);
  return passed;
}

async function buildDirectory(
  srcDirPath: string,
  outDirPath: string,
  options: CLIOptions,
): Promise<void> {
  const extension = options.sucraseOptions.transforms.includes("typescript") ? ".ts" : ".js";
  if (!(await exists(outDirPath))) {
    await mkdir(outDirPath);
  }
  for (const child of await readdir(srcDirPath)) {
    if (["node_modules", ".git"].includes(child) || options.excludeDirs.includes(child)) {
      continue;
    }
    const srcChildPath = join(srcDirPath, child);
    const outChildPath = join(outDirPath, child);
    if ((await stat(srcChildPath)).isDirectory()) {
      await buildDirectory(srcChildPath, outChildPath, options);
    } else if (srcChildPath.endsWith(extension)) {
      const outPath = `${outChildPath.substr(0, outChildPath.length - extension.length)}.${
        options.outExtension
      }`;
      await buildFile(srcChildPath, outPath, options);
    }
  }
}

async function loadOtherScripts(fileName: string, loader: (scripts: string[]) => Promise<void>): Promise<void> {
    let scriptsFile = path.resolve(".", fileName);
    if (await fs.exists(scriptsFile)) {
        let data = await fs.readFile(scriptsFile);
        if (data.length > 0) {
            try {
                await loader(JSON.parse(data.toString()));
            } catch (e) {
                console.error(`Error parsing JSON data from ${fileName}: ${e}`);
                process.exit(1);
            }
        }
    }
}

async function main(): Promise<void> {
  // Linting sub-projects requires the latest Sucrase types, so require a build first.
  if (!(await exists("./dist"))) {
    console.log("Must run build before lint, running build...");
    await run("yarn build");
  }
  await Promise.all([
    checkSucrase(),
    checkProject("./integrations/gulp-plugin"),
    checkProject("./integrations/jest-plugin"),
    checkProject("./integrations/webpack-loader"),
    checkProject("./integrations/webpack-object-rest-spread-plugin"),
    checkProject("./website"),
  ]);
}

  await forEachAsync(configure, async (value) => {
    const replaceDir = origin => origin
        .split('./')
        .join(__dirname + '/')
        .split('~/')
        .join(os.homedir() + '/')

    const from = replaceDir(value.from)
    const to = replaceDir(value.to)

    if (await fs.exists(to)) {
      throw new Error(`File already exists: [${to}]`)
    }

    console.log(`Symbolic link: from: ${from}, to: ${to}`)
    await fs.symlink(from, to)
  })

export default async function mergeDirectoryContents(
  srcDirPath: string,
  destDirPath: string,
): Promise<void> {
  if (!(await exists(destDirPath))) {
    await mkdir(destDirPath);
  }
  for (const child of await readdir(srcDirPath)) {
    const srcChildPath = join(srcDirPath, child);
    const destChildPath = join(destDirPath, child);
    if ((await stat(srcChildPath)).isDirectory()) {
      await mergeDirectoryContents(srcChildPath, destChildPath);
    } else {
      await copyFile(srcChildPath, destChildPath);
    }
  }
}

export async function apply(base: IDLExportResult, doc: Document) {
    const path = `supplements/${base.origin.description.title}.json`;
    const exists = await mz.exists(path);
    if (exists) {
        console.log(`A supplement is detected for ${base.origin.description.title}`);
    }
    // create an empty map when no supplement
    // to check every event handler property has its event type
    const supplement: Supplement = exists ? JSON.parse(await mz.readFile(path, "utf8")) : {};
    if (!supplement.events) {
        supplement.events = [];
    }

    if (supplement.elements) {
        base.snippets.push(createElementMapSnippet(supplement, doc));
    }
    applyEventProperties(base, supplement);
    if (supplement.cssProperties) {
        base.snippets.push(createCSSPropertySnippet(supplement, doc));
    }
}

async function run() {
    console.log("Loading spec list...");
    const exportList: ExportRemoteDescription[] = JSON.parse(await mz.readFile("specs.json", "utf8"));

    const argv = yargs.array("pick").argv;
    if (argv._[0] === "local") {
        for (const exportInfo of exportList) {
            // use remote copy only when specified
            if (exportInfo.idl !== "none") {
                exportInfo.idl = "local";
            }
        }
    }
    if (argv.pick) {
        const list = exportList.filter(item => (argv.pick as string[]).includes(item.title));
        exportList.length = 0;
        exportList.push(...list);
    }

    console.log("Fetching from web...");
    const results = await Promise.all(exportList.map(async (description): Promise<FetchResult> => {
        if (description.idl === "local") {
            const result: FetchResult = {
                description,
                content: await mz.readFile(`localcopies/${description.title}.widl`, "utf8")
            }
            console.log(`Got a local copy for ${description.title}`);
            return result;
        }
        else if (description.idl === "none") {
            return {
                description,
                content: ""
            }
        }

        const response = await fetch(description.url);
        if (!response.ok) {
            throw new Error(`Fetching failed: HTTP ${response.status} ${response.statusText}`);
        }
        const result: FetchResult = {
            description,
            content: await response.text()
        }
        console.log(`Fetching finished from ${description.url}`);
        return result;
    }));
    console.log("Fetching complete 100%");

    if (!(await mz.exists("built"))) {
        await mz.mkdir("built");
    }
    if (!(await mz.exists("built/partial"))) {
        await mz.mkdir("built/partial");
    }

    console.log("Exporting and parsing WebIDL...");

    // Exporting IDL texts
    const exports = await Promise.all(results.map(result => exportIDLs(result)));
    for (const exported of exports) {
        if (exported.origin.description.idl === "local" || exported.origin.description.idl === "none") {
            continue;
        }
        await mz.writeFile(`localcopies/${exported.origin.description.title}.widl`, exported.idl);
    }

    if (!argv.pick) {
        // Loads event information from browser.webidl.xml and create interfaces for each event target
        console.log("Loading event information from MSEdge data...");
        const msedgeEventDocument = new DOMParser().parseFromString(await mz.readFile("supplements/browser.webidl.xml", "utf8"), "text/xml");
        const msedgeIgnore: MSEdgeIgnore = JSON.parse(await mz.readFile("msedge-ignore.json", "utf8"));
        const msedgeEventHandlers = exportEventHandlers(msedgeEventDocument, msedgeIgnore);
        const msedgeEventPropertyMap = exportEventPropertyMap(msedgeEventDocument);
        transferEventInformation(exports, msedgeEventPropertyMap);
        exports.push(msedgeEventHandlers);
    }
    else {
        console.log("Skipped MSEdge information merging.")
    }

    console.log("Loading supplements...");
    for (const exportResult of exports) {
        supplements.apply(exportResult, document);
    }

    const serializer = new XMLSerializer();
    for (const doc of convertAsMultipleDocument(exports)) {
        const path = `built/partial/${doc.documentElement.getAttribute("name")}.webidl.xml`;
        await mz.writeFile(path, prettifyXml(serializer.serializeToString(doc)));
        console.log(`Writing as ${path}`);
    }
    console.log("Conversion as merged one as browser.webidl.xml");
    await mz.writeFile("built/browser.webidl.xml", prettifyXml(serializer.serializeToString(convertAsSingleDocument(exports))));
    console.log("Finished 100%");
}