@tellahq/rescript 10.1.0-alpha.2 → 10.1.4-republish-2

package/scripts/ninja.js

@@ -1,1980 +0,0 @@
-#!/usr/bin/env node
-//@ts-check
-
-var fs = require("fs");
-var path = require("path");
-var cp = require("child_process");
-var semver = require("semver");
-
-var jscompDir = path.join(__dirname, "..", "jscomp");
-var runtimeDir = path.join(jscompDir, "runtime");
-var othersDir = path.join(jscompDir, "others");
-var testDir = path.join(jscompDir, "test");
-
-var jsDir = path.join(__dirname, "..", "lib", "js");
-
-var runtimeFiles = fs.readdirSync(runtimeDir, "ascii");
-var runtimeMlFiles = runtimeFiles.filter(
-  x => !x.startsWith("bs_stdlib_mini") && x.endsWith(".ml") && x !== "js.ml"
-);
-var runtimeMliFiles = runtimeFiles.filter(
-  x => !x.startsWith("bs_stdlib_mini") && x.endsWith(".mli") && x !== "js.mli"
-);
-var runtimeSourceFiles = runtimeMlFiles.concat(runtimeMliFiles);
-var runtimeJsFiles = [...new Set(runtimeSourceFiles.map(baseName))];
-
-var commonBsFlags = `-no-keep-locs -no-alias-deps -bs-no-version-header -bs-no-check-div-by-zero -nostdlib `;
-var js_package = pseudoTarget("js_pkg");
-var runtimeTarget = pseudoTarget("runtime");
-var othersTarget = pseudoTarget("others");
-var stdlibTarget = pseudoTarget("$stdlib");
-var my_target = require("./bin_path").absolutePath;
-var bsc_exe = require("./bin_path").bsc_exe;
-
-var vendorNinjaPath = require("./bin_path").ninja_exe;
-
-// Let's enforce a Node version >= 16 to make sure M1 users don't trip up on
-// cryptic issues caused by mismatching assembly architectures Node 16 ships
-// with a native arm64 binary, and will set process.arch to "arm64" (instead of
-// Rosetta emulated "x86")
-if (semver.lt(process.version, "16.0.0")) {
-  console.error("Requires node version 16 or above... Abort.");
-  process.exit(1);
-}
-
-exports.vendorNinjaPath = vendorNinjaPath;
-/**
- * By default we use vendored,
- * we produce two ninja files which won't overlap
- * one is build.ninja which use  vendored config
- * the other is env.ninja which use binaries from environment
- *
- * In dev mode, files generated for vendor config
- *
- * build.ninja
- * compiler.ninja
- * snapshot.ninja
- * runtime/build.ninja
- * others/build.ninja
- * $stdlib/build.ninja
- * test/build.ninja
- *
- * files generated for env config
- *
- * env.ninja
- * compilerEnv.ninja (no snapshot since env can not provide snapshot)
- * runtime/env.ninja
- * others/env.ninja
- * $stdlib/env.ninja
- * test/env.ninja
- *
- * In release mode:
- *
- * release.ninja
- * runtime/release.ninja
- * others/release.ninja
- * $stdlib/release.ninja
- *
- * Like that our snapshot is so robust that
- * we don't do snapshot in CI, we don't
- * need do test build in CI either
- *
- */
-
-/**
- * @type {string}
- */
-var versionString = undefined;
-
-/**
- *
- * @returns {string}
- */
-var getVersionString = () => {
-  if (versionString === undefined) {
-    var searcher = "version";
-    try {
-      var output = cp.execSync(`ocamldep.opt -version`, {
-        encoding: "ascii",
-      });
-      versionString = output
-        .substring(output.indexOf(searcher) + searcher.length)
-        .trim();
-    } catch (err) {
-      //
-      console.error(`This error  probably came from that you don't have our vendored ocaml installed
-      If this is the first time you clone the repo
-      try this
-      git submodule init && git submodule update
-      node ./scripts/buildocaml.js
-      `);
-      console.error(err.message);
-      process.exit(err.status);
-    }
-  }
-  return versionString;
-};
-
-/**
- *
- * @param {string} ninjaCwd
- */
-function ruleCC(ninjaCwd) {
-  return `
-rule cc
-    command = $bsc -bs-cmi -bs-cmj $bsc_flags   -I ${ninjaCwd}  $in
-    description = $in -> $out
-rule cc_cmi
-    command = $bsc -bs-read-cmi -bs-cmi -bs-cmj $bsc_flags  -I ${ninjaCwd}  $in
-    description = $in -> $out    
-`;
-}
-/**
- * Fixed since it is already vendored
- */
-var cppoMonoFile = `../vendor/cppo/cppo_bin.ml`;
-/**
- *
- * @param {string} name
- * @param {string} content
- */
-function writeFileAscii(name, content) {
-  fs.writeFile(name, content, "ascii", throwIfError);
-}
-
-/**
- *
- * @param {string} name
- * @param {string} content
- */
-function writeFileSync(name, content) {
-  return fs.writeFileSync(name, content, "ascii");
-}
-/**
- *
- * @param {NodeJS.ErrnoException} err
- */
-function throwIfError(err) {
-  if (err !== null) {
-    throw err;
-  }
-}
-/**
- *
- * @typedef { {kind : "file" , name : string} | {kind : "pseudo" , name : string}} Target
- * @typedef {{key : string, value : string}} Override
- * @typedef { Target[]} Targets
- * @typedef {Map<string,TargetSet>} DepsMap
- */
-
-class TargetSet {
-  /**
-   *
-   * @param {Targets} xs
-   */
-  constructor(xs = []) {
-    this.data = xs;
-  }
-  /**
-   *
-   * @param {Target} x
-   */
-  add(x) {
-    var data = this.data;
-    var found = false;
-    for (var i = 0; i < data.length; ++i) {
-      var cur = data[i];
-      if (cur.kind === x.kind && cur.name === x.name) {
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      this.data.push(x);
-    }
-    return this;
-  }
-  /**
-   * @returns {Targets} a copy
-   *
-   */
-  toSortedArray() {
-    var newData = this.data.concat();
-    newData.sort((x, y) => {
-      var kindx = x.kind;
-      var kindy = y.kind;
-      if (kindx > kindy) {
-        return 1;
-      } else if (kindx < kindy) {
-        return -1;
-      } else {
-        if (x.name > y.name) {
-          return 1;
-        } else if (x.name < y.name) {
-          return -1;
-        } else {
-          return 0;
-        }
-      }
-    });
-    return newData;
-  }
-  /**
-   *
-   * @param {(item:Target)=>void} callback
-   */
-  forEach(callback) {
-    this.data.forEach(callback);
-  }
-}
-
-/**
- *
- * @param {string} target
- * @param {string} dependency
- * @param {DepsMap} depsMap
- */
-function updateDepsKVByFile(target, dependency, depsMap) {
-  var singleTon = fileTarget(dependency);
-  if (depsMap.has(target)) {
-    depsMap.get(target).add(singleTon);
-  } else {
-    depsMap.set(target, new TargetSet([singleTon]));
-  }
-}
-
-/**
- *
- * @param {string} s
- */
-function uncapitalize(s) {
-  if (s.length === 0) {
-    return s;
-  }
-  return s[0].toLowerCase() + s.slice(1);
-}
-/**
- *
- * @param {string} target
- * @param {string[]} dependencies
- * @param {DepsMap} depsMap
- */
-function updateDepsKVsByFile(target, dependencies, depsMap) {
-  var targets = fileTargets(dependencies);
-  if (depsMap.has(target)) {
-    var s = depsMap.get(target);
-    for (var i = 0; i < targets.length; ++i) {
-      s.add(targets[i]);
-    }
-  } else {
-    depsMap.set(target, new TargetSet(targets));
-  }
-}
-
-/**
- *
- * @param {string} target
- * @param {string[]} modules
- * @param {DepsMap} depsMap
- */
-function updateDepsKVsByModule(target, modules, depsMap) {
-  if (depsMap.has(target)) {
-    let s = depsMap.get(target);
-    for (let module of modules) {
-      let filename = uncapitalize(module);
-      let filenameAsCmi = filename + ".cmi";
-      let filenameAsCmj = filename + ".cmj";
-      if (target.endsWith(".cmi")) {
-        if (depsMap.has(filenameAsCmi) || depsMap.has(filenameAsCmj)) {
-          s.add(fileTarget(filenameAsCmi));
-        }
-      } else if (target.endsWith(".cmj")) {
-        if (depsMap.has(filenameAsCmj)) {
-          s.add(fileTarget(filenameAsCmj));
-        } else if (depsMap.has(filenameAsCmi)) {
-          s.add(fileTarget(filenameAsCmi));
-        }
-      }
-    }
-  }
-}
-/**
- *
- * @param {string[]}sources
- * @return {DepsMap}
- */
-function createDepsMapWithTargets(sources) {
-  /**
-   * @type {DepsMap}
-   */
-  let depsMap = new Map();
-  for (let source of sources) {
-    let target = sourceToTarget(source);
-    depsMap.set(target, new TargetSet([]));
-  }
-  depsMap.forEach((set, name) => {
-    let cmiFile;
-    if (
-      name.endsWith(".cmj") &&
-      depsMap.has((cmiFile = replaceExt(name, ".cmi")))
-    ) {
-      set.add(fileTarget(cmiFile));
-    }
-  });
-  return depsMap;
-}
-
-/**
- *
- * @param {Target} file
- * @param {string} cwd
- */
-function targetToString(file, cwd) {
-  switch (file.kind) {
-    case "file":
-      return path.join(cwd, file.name);
-    case "pseudo":
-      return file.name;
-    default:
-      throw Error;
-  }
-}
-/**
- *
- * @param {Targets} files
- * @param {string} cwd
- *
- * @returns {string} return a string separated with whitespace
- */
-function targetsToString(files, cwd) {
-  return files.map(x => targetToString(x, cwd)).join(" ");
-}
-/**
- *
- * @param {Targets} outputs
- * @param {Targets} inputs
- * @param {Targets} deps
- * @param {Override[]} overrides
- * @param {string} rule
- * @param {string} cwd
- * @return {string}
- */
-function ninjaBuild(outputs, inputs, rule, deps, cwd, overrides) {
-  var fileOutputs = targetsToString(outputs, cwd);
-  var fileInputs = targetsToString(inputs, cwd);
-  var stmt = `o ${fileOutputs} : ${rule} ${fileInputs}`;
-  // deps.push(pseudoTarget('../lib/bsc'))
-  if (deps.length > 0) {
-    var fileDeps = targetsToString(deps, cwd);
-    stmt += ` | ${fileDeps}`;
-  }
-  if (overrides.length > 0) {
-    stmt +=
-      `\n` +
-      overrides
-        .map(x => {
-          return `    ${x.key} = ${x.value}`;
-        })
-        .join("\n");
-  }
-  return stmt;
-}
-
-/**
- *
- * @param {Target} outputs
- * @param {Targets} inputs
- * @param {string} cwd
- */
-function phony(outputs, inputs, cwd) {
-  return ninjaBuild([outputs], inputs, "phony", [], cwd, []);
-}
-
-/**
- *
- * @param {string | string[]} outputs
- * @param {string | string[]} inputs
- * @param {string | string[]} fileDeps
- * @param {string} rule
- * @param {string} cwd
- * @param {[string,string][]} overrides
- * @param {Target | Targets} extraDeps
- */
-function ninjaQuickBuild(
-  outputs,
-  inputs,
-  rule,
-  cwd,
-  overrides,
-  fileDeps,
-  extraDeps
-) {
-  var os = Array.isArray(outputs)
-    ? fileTargets(outputs)
-    : [fileTarget(outputs)];
-  var is = Array.isArray(inputs) ? fileTargets(inputs) : [fileTarget(inputs)];
-  var ds = Array.isArray(fileDeps)
-    ? fileTargets(fileDeps)
-    : [fileTarget(fileDeps)];
-  var dds = Array.isArray(extraDeps) ? extraDeps : [extraDeps];
-
-  return ninjaBuild(
-    os,
-    is,
-    rule,
-    ds.concat(dds),
-    cwd,
-    overrides.map(x => {
-      return { key: x[0], value: x[1] };
-    })
-  );
-}
-
-/**
- * @typedef { (string | string []) } Strings
- * @typedef { [string,string]} KV
- * @typedef { [Strings, Strings,  string, string, KV[], Strings, (Target|Targets)] } BuildList
- * @param {BuildList[]} xs
- * @returns {string}
- */
-function ninjaQuickBuidList(xs) {
-  return xs
-    .map(x => ninjaQuickBuild(x[0], x[1], x[2], x[3], x[4], x[5], x[6]))
-    .join("\n");
-}
-
-/**
- * @typedef { [string,string,string?]} CppoInput
- * @param {CppoInput[]} xs
- * @param {string} cwd
- * @returns {string}
- */
-function cppoList(cwd, xs) {
-  return xs
-    .map(x => {
-      /**
-       * @type {KV[]}
-       */
-      var variables;
-      if (x[2]) {
-        variables = [["type", `-D ${x[2]}`]];
-      } else {
-        variables = [];
-      }
-      var extraDeps = pseudoTarget(cppoFile);
-      return ninjaQuickBuild(
-        x[0],
-        x[1],
-        cppoRuleName,
-        cwd,
-        variables,
-        [],
-        extraDeps
-      );
-    })
-    .join("\n");
-}
-/**
- *
- * @param {string} cwd
- * @param {string[]} xs
- * @returns {string}
- */
-function mllList(cwd, xs) {
-  return xs
-    .map(x => {
-      var output = baseName(x) + ".ml";
-      return ninjaQuickBuild(output, x, mllRuleName, cwd, [], [], []);
-    })
-    .join("\n");
-}
-
-/**
- *
- * @param {string} cwd
- * @param {string[]} xs
- * @returns {string}
- */
-function mlyList(cwd, xs) {
-  return xs
-    .map(x => {
-      var output = baseName(x) + ".ml";
-      return ninjaQuickBuild(output, x, mlyRuleName, cwd, [], [], []);
-    })
-    .join("\n");
-}
-/**
- *
- * @param {string} name
- * @returns {Target}
- */
-function fileTarget(name) {
-  return { kind: "file", name };
-}
-
-/**
- *
- * @param {string} name
- * @returns {Target}
- */
-function pseudoTarget(name) {
-  return { kind: "pseudo", name };
-}
-
-/**
- *
- * @param {string[]} args
- * @returns {Targets}
- */
-function fileTargets(args) {
-  return args.map(name => fileTarget(name));
-}
-
-/**
- *
- * @param {string[]} outputs
- * @param {string[]} inputs
- * @param {DepsMap} depsMap
- * @param {Override[]} overrides
- * @param {Targets} extraDeps
- * @param {string} rule
- * @param {string} cwd
- */
-function buildStmt(outputs, inputs, rule, depsMap, cwd, overrides, extraDeps) {
-  var os = outputs.map(fileTarget);
-  var is = inputs.map(fileTarget);
-  var deps = new TargetSet();
-  for (var i = 0; i < outputs.length; ++i) {
-    var curDeps = depsMap.get(outputs[i]);
-    if (curDeps !== undefined) {
-      curDeps.forEach(x => deps.add(x));
-    }
-  }
-  extraDeps.forEach(x => deps.add(x));
-  return ninjaBuild(os, is, rule, deps.toSortedArray(), cwd, overrides);
-}
-
-/**
- *
- * @param {string} x
- */
-function replaceCmj(x) {
-  return x.trim().replace("cmx", "cmj");
-}
-
-/**
- *
- * @param {string} y
- */
-function sourceToTarget(y) {
-  if (y.endsWith(".ml") || y.endsWith(".re") || y.endsWith(".res")) {
-    return replaceExt(y, ".cmj");
-  } else if (y.endsWith(".mli") || y.endsWith(".rei") || y.endsWith(".resi")) {
-    return replaceExt(y, ".cmi");
-  }
-  return y;
-}
-/**
- *
- * @param {string[]} files
- * @param {string} dir
- * @param {DepsMap} depsMap
- * @return {Promise<void>}
- * Note `bsdep.exe` does not need post processing and -one-line flag
- * By default `ocamldep.opt` only list dependencies in its args
- */
-function ocamlDepForBscAsync(files, dir, depsMap) {
-  return new Promise((resolve, reject) => {
-    cp.exec(
-      `ocamldep.opt -allow-approx -one-line -native ${files.join(" ")}`,
-      {
-        cwd: dir,
-        encoding: "ascii",
-      },
-      function (error, stdout, stderr) {
-        if (error !== null) {
-          return reject(error);
-        } else {
-          var pairs = stdout.split("\n").map(x => x.split(":"));
-          pairs.forEach(x => {
-            var deps;
-            let source = replaceCmj(x[0]);
-            if (x[1] !== undefined && (deps = x[1].trim())) {
-              deps = deps.split(" ");
-              updateDepsKVsByFile(
-                source,
-                deps.map(x => replaceCmj(x)),
-                depsMap
-              );
-            }
-          });
-          return resolve();
-        }
-      }
-    );
-  });
-}
-
-/**
- *
- * @param {string[]} files
- * @param {string} dir
- * @param {DepsMap} depsMap
- * @return { Promise<void> []}
- * Note `bsdep.exe` does not need post processing and -one-line flag
- * By default `ocamldep.opt` only list dependencies in its args
- */
-function depModulesForBscAsync(files, dir, depsMap) {
-  let ocamlFiles = files.filter(x => x.endsWith(".ml") || x.endsWith(".mli"));
-  let reFiles = files.filter(x => x.endsWith(".re") || x.endsWith(".rei"));
-  let resFiles = files.filter(x => x.endsWith(".res") || x.endsWith(".resi"));
-  /**
-   *
-   * @param {(value:void) =>void} resolve
-   * @param {(value:any)=>void} reject
-   */
-  let cb = (resolve, reject) => {
-    /**
-     * @param {any} error
-     * @param {string} stdout
-     * @param {string} stderr
-     */
-    let fn = function (error, stdout, stderr) {
-      if (error !== null) {
-        return reject(error);
-      } else {
-        var pairs = stdout.split("\n").map(x => x.split(":"));
-        pairs.forEach(x => {
-          var modules;
-          let source = sourceToTarget(x[0].trim());
-          if (x[1] !== undefined && (modules = x[1].trim())) {
-            modules = modules.split(" ");
-            updateDepsKVsByModule(source, modules, depsMap);
-          }
-        });
-        return resolve();
-      }
-    };
-    return fn;
-  };
-  let config = {
-    cwd: dir,
-    encoding: "ascii",
-  };
-  return [
-    new Promise((resolve, reject) => {
-      cp.exec(
-        `${bsc_exe}  -modules -bs-syntax-only ${resFiles.join(
-          " "
-        )} ${reFiles.join(" ")} ${ocamlFiles.join(" ")}`,
-        config,
-        cb(resolve, reject)
-      );
-    }),
-  ];
-}
-
-/**
- * @typedef {('HAS_ML' | 'HAS_MLI' | 'HAS_BOTH' | 'HAS_RE' | 'HAS_RES' | 'HAS_REI' | 'HAS_RESI' | 'HAS_BOTH_RE' | 'HAS_BOTH_RES')} FileInfo
- * @param {string[]} sourceFiles
- * @returns {Map<string, FileInfo>}
- * We make a set to ensure that `sourceFiles` are not duplicated
- */
-function collectTarget(sourceFiles) {
-  /**
-   * @type {Map<string,FileInfo>}
-   */
-  var allTargets = new Map();
-  sourceFiles.forEach(x => {
-    var { ext, name } = path.parse(x);
-    var existExt = allTargets.get(name);
-    if (existExt === undefined) {
-      if (ext === ".ml") {
-        allTargets.set(name, "HAS_ML");
-      } else if (ext === ".mli") {
-        allTargets.set(name, "HAS_MLI");
-      } else if (ext === ".re") {
-        allTargets.set(name, "HAS_RE");
-      } else if (ext === ".res") {
-        allTargets.set(name, "HAS_RES");
-      } else if (ext === ".rei") {
-        allTargets.set(name, "HAS_REI");
-      } else if (ext === ".resi") {
-        allTargets.set(name, "HAS_RESI");
-      }
-    } else {
-      switch (existExt) {
-        case "HAS_ML":
-          if (ext === ".mli") {
-            allTargets.set(name, "HAS_BOTH");
-          }
-          break;
-        case "HAS_RE":
-          if (ext === ".rei") {
-            allTargets.set(name, "HAS_BOTH_RE");
-          }
-          break;
-        case "HAS_RES":
-          if (ext === ".resi") {
-            allTargets.set(name, "HAS_BOTH_RES");
-          }
-          break;
-        case "HAS_MLI":
-          if (ext === ".ml") {
-            allTargets.set(name, "HAS_BOTH");
-          }
-          break;
-        case "HAS_REI":
-          if (ext === ".re") {
-            allTargets.set(name, "HAS_BOTH_RE");
-          }
-          break;
-        case "HAS_RESI":
-          if (ext === ".res") {
-            allTargets.set(name, "HAS_BOTH_RES");
-          }
-          break;
-        case "HAS_BOTH_RE":
-        case "HAS_BOTH":
-        case "HAS_BOTH_RES":
-          break;
-      }
-    }
-  });
-  return allTargets;
-}
-
-/**
- *
- * @param {Map<string, FileInfo>} allTargets
- * @param {string[]} collIn
- * @returns {string[]} A new copy which is
- *
- */
-function scanFileTargets(allTargets, collIn) {
-  var coll = collIn.concat();
-  allTargets.forEach((ext, mod) => {
-    switch (ext) {
-      case "HAS_MLI":
-      case "HAS_REI":
-      case "HAS_RESI":
-        coll.push(`${mod}.cmi`);
-        break;
-      case "HAS_BOTH_RES":
-      case "HAS_BOTH_RE":
-      case "HAS_BOTH":
-        coll.push(`${mod}.cmi`, `${mod}.cmj`);
-        break;
-      case "HAS_RE":
-      case "HAS_RES":
-      case "HAS_ML":
-        coll.push(`${mod}.cmi`, `${mod}.cmj`);
-        break;
-    }
-  });
-  return coll;
-}
-
-/**
- *
- * @param {DepsMap} depsMap
- * @param {Map<string,string>} allTargets
- * @param {string} cwd
- * @param {Targets} extraDeps
- * @return {string[]}
- */
-function generateNinja(depsMap, allTargets, cwd, extraDeps = []) {
-  /**
-   * @type {string[]}
-   */
-  var build_stmts = [];
-  allTargets.forEach((x, mod) => {
-    let ouptput_cmj = mod + ".cmj";
-    let output_cmi = mod + ".cmi";
-    let input_ml = mod + ".ml";
-    let input_mli = mod + ".mli";
-    let input_re = mod + ".re";
-    let input_res = mod + ".res";
-    let input_rei = mod + ".rei";
-    let input_resi = mod + ".resi";
-    /**
-     * @type {Override[]}
-     */
-    var overrides = [];
-    // if (mod.endsWith("Labels")) {
-    //   overrides.push({ key: "bsc_flags", value: "$bsc_flags -nolabels" });
-    // }
-
-    /**
-     *
-     * @param {string[]} outputs
-     * @param {string[]} inputs
-     *
-     */
-    let mk = (outputs, inputs, rule = "cc") => {
-      return build_stmts.push(
-        buildStmt(outputs, inputs, rule, depsMap, cwd, overrides, extraDeps)
-      );
-    };
-    switch (x) {
-      case "HAS_BOTH":
-        mk([ouptput_cmj], [input_ml], "cc_cmi");
-        mk([output_cmi], [input_mli]);
-        break;
-      case "HAS_BOTH_RE":
-        mk([ouptput_cmj], [input_re], "cc_cmi");
-        mk([output_cmi], [input_rei], "cc");
-        break;
-      case "HAS_BOTH_RES":
-        mk([ouptput_cmj], [input_res], "cc_cmi");
-        mk([output_cmi], [input_resi], "cc");
-        break;
-      case "HAS_RE":
-        mk([output_cmi, ouptput_cmj], [input_re], "cc");
-        break;
-      case "HAS_RES":
-        mk([output_cmi, ouptput_cmj], [input_res], "cc");
-        break;
-      case "HAS_ML":
-        mk([output_cmi, ouptput_cmj], [input_ml]);
-        break;
-      case "HAS_REI":
-        mk([output_cmi], [input_rei], "cc");
-        break;
-      case "HAS_RESI":
-        mk([output_cmi], [input_resi], "cc");
-        break;
-      case "HAS_MLI":
-        mk([output_cmi], [input_mli]);
-        break;
-    }
-  });
-  return build_stmts;
-}
-
-var COMPILIER = bsc_exe;
-var BSC_COMPILER = `bsc = ${COMPILIER}`;
-
-async function runtimeNinja(devmode = true) {
-  var ninjaCwd = "runtime";
-  var compilerTarget = pseudoTarget("$bsc");
-  var externalDeps = devmode ? [compilerTarget] : [];
-  var ninjaOutput = devmode ? "build.ninja" : "release.ninja";
-  var templateRuntimeRules = `
-bsc_no_open_flags =  ${commonBsFlags} -bs-cross-module-opt -make-runtime  -nopervasives  -unsafe -w +50 -warn-error A
-bsc_flags = $bsc_no_open_flags -open Bs_stdlib_mini
-${ruleCC(ninjaCwd)}
-${ninjaQuickBuidList([
-  [
-    "bs_stdlib_mini.cmi",
-    "bs_stdlib_mini.mli",
-    "cc",
-    ninjaCwd,
-    [["bsc_flags", "-nostdlib -nopervasives"]],
-    [],
-    externalDeps,
-  ],
-  [
-    ["js.cmj", "js.cmi"],
-    "js.ml",
-    "cc",
-    ninjaCwd,
-    [["bsc_flags", "$bsc_no_open_flags"]],
-    [],
-    externalDeps,
-  ],
-])}
-`;
-  /**
-   * @type {DepsMap}
-   */
-  var depsMap = new Map();
-  var allTargets = collectTarget([...runtimeMliFiles, ...runtimeMlFiles]);
-  var manualDeps = ["bs_stdlib_mini.cmi", "js.cmj", "js.cmi"];
-  var allFileTargetsInRuntime = scanFileTargets(allTargets, manualDeps);
-  allTargets.forEach((ext, mod) => {
-    switch (ext) {
-      case "HAS_MLI":
-      case "HAS_BOTH":
-        updateDepsKVsByFile(mod + ".cmi", manualDeps, depsMap);
-        break;
-      case "HAS_ML":
-        updateDepsKVsByFile(mod + ".cmj", manualDeps, depsMap);
-        break;
-    }
-  });
-  // FIXME: in dev mode, it should not rely on reading js file
-  // since it may cause a bootstrapping issues
-  try {
-    await Promise.all([
-      runJSCheckAsync(depsMap),
-      ocamlDepForBscAsync(runtimeSourceFiles, runtimeDir, depsMap),
-    ]);
-    var stmts = generateNinja(depsMap, allTargets, ninjaCwd, externalDeps);
-    stmts.push(
-      phony(runtimeTarget, fileTargets(allFileTargetsInRuntime), ninjaCwd)
-    );
-    writeFileAscii(
-      path.join(runtimeDir, ninjaOutput),
-      templateRuntimeRules + stmts.join("\n") + "\n"
-    );
-  } catch (e) {
-    console.log(e);
-  }
-}
-
-var dTypeString = "TYPE_STRING";
-
-var dTypeInt = "TYPE_INT";
-
-var dTypeFunctor = "TYPE_FUNCTOR";
-
-var dTypeLocalIdent = "TYPE_LOCAL_IDENT";
-
-var dTypeIdent = "TYPE_IDENT";
-
-var dTypePoly = "TYPE_POLY";
-
-var cppoRuleName = `cppo`;
-var cppoFile = `./bin/cppo.exe`;
-
-var cppoRule = (flags = "") => `
-rule ${cppoRuleName}
-    command = ${cppoFile} -V OCAML:${getVersionString()} ${flags} $type $in -o $out
-    generator = true
-`;
-
-var mllRuleName = `mll`;
-var mllRule = `
-rule ${mllRuleName}
-    command = $ocamllex $in
-    generator = true
-`;
-
-var mlyRuleName = `mly`;
-var mlyRule = `
-rule ${mlyRuleName}
-    command = $ocamlyacc -v --strict $in
-    generator = true
-`;
-async function othersNinja(devmode = true) {
-  var compilerTarget = pseudoTarget("$bsc");
-  var externalDeps = [
-    compilerTarget,
-    fileTarget("belt_internals.cmi"),
-    fileTarget("js.cmi"),
-  ];
-  var ninjaOutput = devmode ? "build.ninja" : "release.ninja";
-  var ninjaCwd = "others";
-
-  var templateOthersRules = `
-bsc_primitive_flags =  ${commonBsFlags} -bs-cross-module-opt -make-runtime   -nopervasives  -unsafe  -w +50 -warn-error A
-bsc_flags = $bsc_primitive_flags -open Belt_internals
-${ruleCC(ninjaCwd)}
-${ninjaQuickBuidList([
-  [
-    ["belt.cmj", "belt.cmi"],
-    "belt.ml",
-    "cc",
-    ninjaCwd,
-    [["bsc_flags", "$bsc_primitive_flags"]],
-    [],
-    [compilerTarget],
-  ],
-  [
-    ["js.cmj", "js.cmi"],
-    "js.ml",
-    "cc",
-    ninjaCwd,
-    [["bsc_flags", "$bsc_primitive_flags"]],
-    [],
-    [compilerTarget],
-  ],
-  [
-    ["belt_internals.cmi"],
-    "belt_internals.mli",
-    "cc",
-    ninjaCwd,
-    [["bsc_flags", "$bsc_primitive_flags"]],
-    [],
-    [compilerTarget],
-  ],
-  [
-    ["node.cmj", "node.cmi"],
-    "node.ml",
-    "cc",
-    ninjaCwd,
-    [], // depends on belt_internals
-    [],
-    [compilerTarget, fileTarget("js.cmi"), fileTarget("belt_internals.cmi")], // need js.cm*
-  ],
-])}
-`;
-  var othersDirFiles = fs.readdirSync(othersDir, "ascii");
-  var jsPrefixSourceFiles = othersDirFiles.filter(
-    x =>
-      x.startsWith("js") &&
-      (x.endsWith(".ml") || x.endsWith(".mli")) &&
-      !x.includes(".cppo") &&
-      !x.includes(".pp") &&
-      !x.includes("#") &&
-      x !== "js.ml"
-  );
-  var othersFiles = othersDirFiles.filter(
-    x =>
-      !x.startsWith("js") &&
-      x !== "belt.ml" &&
-      x !== "belt_internals.mli" &&
-      x !== "node.ml" &&
-      (x.endsWith(".ml") || x.endsWith(".mli")) &&
-      !x.includes("#") &&
-      !x.includes(".cppo") // we have node ..
-  );
-  var jsTargets = collectTarget(jsPrefixSourceFiles);
-  var allJsTargets = scanFileTargets(jsTargets, []);
-  let jsDepsMap = new Map();
-  let depsMap = new Map();
-  await Promise.all([
-    ocamlDepForBscAsync(jsPrefixSourceFiles, othersDir, jsDepsMap),
-    ocamlDepForBscAsync(othersFiles, othersDir, depsMap),
-  ]);
-  var jsOutput = generateNinja(jsDepsMap, jsTargets, ninjaCwd, externalDeps);
-  jsOutput.push(phony(js_package, fileTargets(allJsTargets), ninjaCwd));
-
-  // Note compiling belt.ml still try to read
-  // belt_xx.cmi we need enforce the order to
-  // avoid data race issues
-  var beltPackage = fileTarget("belt.cmi");
-  var nodePackage = fileTarget("node.cmi");
-  var beltTargets = collectTarget(othersFiles);
-  depsMap.forEach((s, k) => {
-    if (k.startsWith("belt")) {
-      s.add(beltPackage);
-    } else if (k.startsWith("node")) {
-      s.add(nodePackage);
-    }
-    s.add(js_package);
-  });
-  var allOthersTarget = scanFileTargets(beltTargets, []);
-  var beltOutput = generateNinja(depsMap, beltTargets, ninjaCwd, externalDeps);
-  beltOutput.push(phony(othersTarget, fileTargets(allOthersTarget), ninjaCwd));
-  // ninjaBuild([`belt_HashSetString.ml`,])
-  writeFileAscii(
-    path.join(othersDir, ninjaOutput),
-    templateOthersRules +
-      jsOutput.join("\n") +
-      "\n" +
-      beltOutput.join("\n") +
-      "\n"
-  );
-}
-/**
- *
- * @param {boolean} devmode
- * generate build.ninja/release.ninja for stdlib-402
- */
-async function stdlibNinja(devmode = true) {
-  var stdlibVersion = "stdlib-406";
-  var ninjaCwd = stdlibVersion;
-  var stdlibDir = path.join(jscompDir, stdlibVersion);
-  var compilerTarget = pseudoTarget("$bsc");
-  var externalDeps = [compilerTarget, othersTarget];
-  var ninjaOutput = devmode ? "build.ninja" : "release.ninja";
-  var bsc_flags = "bsc_flags";
-  /**
-   * @type [string,string][]
-   */
-  var bsc_builtin_overrides = [[bsc_flags, `$${bsc_flags} -nopervasives`]];
-  // It is interesting `-w -a` would generate not great code sometimes
-  // deprecations diabled due to string_of_float
-  var warnings = "-w -9-3-106 -warn-error A";
-  var templateStdlibRules = `
-${bsc_flags} = ${commonBsFlags} -bs-cross-module-opt -make-runtime ${warnings} -I others
-${ruleCC(ninjaCwd)}
-${ninjaQuickBuidList([
-  // we make it still depends on external
-  // to enjoy free ride on dev config for compiler-deps
-
-  [
-    "pervasives.cmj",
-    "pervasives.ml",
-    "cc_cmi",
-    ninjaCwd,
-    bsc_builtin_overrides,
-    "pervasives.cmi",
-    externalDeps,
-  ],
-  [
-    "pervasives.cmi",
-    "pervasives.mli",
-    "cc",
-    ninjaCwd,
-    bsc_builtin_overrides,
-    [],
-    externalDeps,
-  ],
-])}
-`;
-  var stdlibDirFiles = fs.readdirSync(stdlibDir, "ascii");
-  var sources = stdlibDirFiles.filter(x => {
-    return (
-      !x.startsWith("pervasives") && (x.endsWith(".ml") || x.endsWith(".mli"))
-    );
-  });
-  let depsMap = new Map();
-  await ocamlDepForBscAsync(sources, stdlibDir, depsMap);
-  var targets = collectTarget(sources);
-  var allTargets = scanFileTargets(targets, [
-    "pervasives.cmi",
-    "pervasives.cmj",
-  ]);
-  targets.forEach((ext, mod) => {
-    switch (ext) {
-      case "HAS_MLI":
-      case "HAS_BOTH":
-        updateDepsKVByFile(mod + ".cmi", "pervasives.cmj", depsMap);
-        break;
-      case "HAS_ML":
-        updateDepsKVByFile(mod + ".cmj", "pervasives.cmj", depsMap);
-        break;
-    }
-  });
-  var output = generateNinja(depsMap, targets, ninjaCwd, externalDeps);
-  output.push(phony(stdlibTarget, fileTargets(allTargets), ninjaCwd));
-
-  writeFileAscii(
-    path.join(stdlibDir, ninjaOutput),
-    templateStdlibRules + output.join("\n") + "\n"
-  );
-}
-
-/**
- *
- * @param {string} text
- */
-function getDeps(text) {
-  /**
-   * @type {string[]}
-   */
-  var deps = [];
-  text.replace(
-    /(\/\*[\w\W]*?\*\/|\/\/[^\n]*|[.$]r)|\brequire\s*\(\s*["']([^"']*)["']\s*\)/g,
-    function (_, ignore, id) {
-      if (!ignore) deps.push(id);
-      return ""; // TODO: examine the regex
-    }
-  );
-  return deps;
-}
-
-/**
- *
- * @param {string} x
- * @param {string} newExt
- * @example
- *
- * ```js
- * replaceExt('xx.cmj', '.a') // return 'xx.a'
- * ```
- *
- */
-function replaceExt(x, newExt) {
-  let index = x.lastIndexOf(".");
-  if (index < 0) {
-    return x;
-  }
-  return x.slice(0, index) + newExt;
-}
-/**
- *
- * @param {string} x
- */
-function baseName(x) {
-  return x.substr(0, x.indexOf("."));
-}
-
-/**
- *
- * @returns {Promise<void>}
- */
-async function testNinja() {
-  var ninjaOutput = "build.ninja";
-  var ninjaCwd = `test`;
-  var templateTestRules = `
-bsc_flags = -bs-no-version-header  -bs-cross-module-opt -make-runtime-test -bs-package-output commonjs:jscomp/test  -w -3-6-26-27-29-30-32..40-44-45-52-60-9-106+104 -warn-error A  -I runtime -I $stdlib -I others
-${ruleCC(ninjaCwd)}
-
-
-${mllRule}
-${mllList(ninjaCwd, [
-  "arith_lexer.mll",
-  "number_lexer.mll",
-  "simple_lexer_test.mll",
-])}
-`;
-  var testDirFiles = fs.readdirSync(testDir, "ascii");
-  var sources = testDirFiles.filter(x => {
-    return (
-      x.endsWith(".re") ||
-      x.endsWith(".rei") ||
-      x.endsWith(".resi") ||
-      x.endsWith(".res") ||
-      ((x.endsWith(".ml") || x.endsWith(".mli")) && !x.endsWith("bspack.ml"))
-    );
-  });
-
-  let depsMap = createDepsMapWithTargets(sources);
-  await Promise.all(depModulesForBscAsync(sources, testDir, depsMap));
-  var targets = collectTarget(sources);
-  var output = generateNinja(depsMap, targets, ninjaCwd, [
-    runtimeTarget,
-    stdlibTarget,
-    pseudoTarget("$bsc"),
-  ]);
-  output.push(
-    phony(
-      pseudoTarget("test"),
-      fileTargets(scanFileTargets(targets, [])),
-      ninjaCwd
-    )
-  );
-  writeFileAscii(
-    path.join(testDir, ninjaOutput),
-    templateTestRules + output.join("\n") + "\n"
-  );
-}
-
-/**
- *
- * @param {DepsMap} depsMap
- */
-function runJSCheckAsync(depsMap) {
-  return new Promise(resolve => {
-    var count = 0;
-    var tasks = runtimeJsFiles.length;
-    var updateTick = () => {
-      count++;
-      if (count === tasks) {
-        resolve(count);
-      }
-    };
-    runtimeJsFiles.forEach(name => {
-      var jsFile = path.join(jsDir, name + ".js");
-      fs.readFile(jsFile, "utf8", function (err, fileContent) {
-        if (err === null) {
-          var deps = getDeps(fileContent).map(x => path.parse(x).name + ".cmj");
-          fs.exists(path.join(runtimeDir, name + ".mli"), exist => {
-            if (exist) {
-              deps.push(name + ".cmi");
-            }
-            updateDepsKVsByFile(`${name}.cmj`, deps, depsMap);
-            updateTick();
-          });
-        } else {
-          // file non exist or reading error ignore
-          updateTick();
-        }
-      });
-    });
-  });
-}
-
-function checkEffect() {
-  var jsPaths = runtimeJsFiles.map(x => path.join(jsDir, x + ".js"));
-  var effect = jsPaths
-    .map(x => {
-      return {
-        file: x,
-        content: fs.readFileSync(x, "utf8"),
-      };
-    })
-    .map(({ file, content: x }) => {
-      if (/No side effect|This output is empty/.test(x)) {
-        return {
-          file,
-          effect: "pure",
-        };
-      } else if (/Not a pure module/.test(x)) {
-        return {
-          file,
-          effect: "false",
-        };
-      } else {
-        return {
-          file,
-          effect: "unknown",
-        };
-      }
-    })
-    .filter(({ effect }) => effect !== "pure")
-    .map(({ file, effect }) => {
-      return { file: path.basename(file), effect };
-    });
-
-  var black_list = new Set([
-    "caml_int32.js",
-    "caml_int64.js",
-    "caml_lexer.js",
-    "caml_parser.js",
-  ]);
-
-  var assert = require("assert");
-  // @ts-ignore
-  assert(
-    effect.length === black_list.size &&
-      effect.every(x => black_list.has(x.file))
-  );
-
-  console.log(effect);
-}
-
-/**
- *
- * @param {string[]} domain
- * @param {Map<string,Set<string>>} dependency_graph
- * @returns {string[]}
- */
-function sortFilesByDeps(domain, dependency_graph) {
-  /**
-   * @type{string[]}
-   */
-  var result = [];
-  var workList = new Set(domain);
-  /**
-   *
-   * @param {Set<string>} visiting
-   * @param {string[]} path
-   * @param {string} current
-   */
-  var visit = function (visiting, path, current) {
-    if (visiting.has(current)) {
-      throw new Error(`cycle: ${path.concat(current).join(" ")}`);
-    }
-    if (workList.has(current)) {
-      visiting.add(current);
-      var next = dependency_graph.get(current);
-      if (next !== undefined && next.size > 0) {
-        next.forEach(x => {
-          visit(visiting, path.concat(current), x);
-        });
-      }
-      visiting.delete(current);
-      workList.delete(current);
-      result.push(current);
-    }
-  };
-  while (workList.size > 0) {
-    visit(new Set(), [], workList.values().next().value);
-  }
-  return result;
-}
-
-function updateRelease() {
-  runtimeNinja(false);
-  stdlibNinja(false);
-  othersNinja(false);
-}
-
-function updateDev() {
-  writeFileAscii(
-    path.join(jscompDir, "build.ninja"),
-    `
-subninja compiler.ninja
-stdlib = stdlib-406
-${BSC_COMPILER}
-ocamllex = ocamllex.opt
-subninja runtime/build.ninja
-subninja others/build.ninja
-subninja $stdlib/build.ninja
-subninja test/build.ninja
-o all: phony runtime others $stdlib test
-`
-  );
-  writeFileAscii(
-    path.join(jscompDir, "..", "lib", "build.ninja"),
-    `
-ocamlopt = ocamlopt.opt 
-ext = exe
-INCL= "4.06.1+BS"
-include body.ninja               
-`
-  );
-
-  preprocessorNinjaSync(); // This is needed so that ocamldep makes sense
-  nativeNinja();
-  runtimeNinja();
-  stdlibNinja(true);
-  if (fs.existsSync(bsc_exe)) {
-    testNinja();
-  }
-  othersNinja();
-}
-exports.updateDev = updateDev;
-exports.updateRelease = updateRelease;
-
-/**
- *
- * @param {string} dir
- */
-function readdirSync(dir) {
-  return fs.readdirSync(dir, "ascii");
-}
-/**
- * @type {string[]}
- */
-var black_list = [];
-/**
- *
- * @param {string} dir
- */
-function test(dir) {
-  return readdirSync(path.join(jscompDir, dir))
-    .filter(x => {
-      return (
-        (x.endsWith(".ml") || x.endsWith(".mli")) &&
-        !(x.endsWith(".cppo.ml") || x.endsWith(".cppo.mli")) &&
-        !(x.endsWith(".pp.ml") || x.endsWith(".pp.mli")) &&
-        !black_list.some(name => x.includes(name))
-      );
-    })
-    .map(x => path.join(dir, x));
-}
-
-/**
- *
- * @param {Set<string>} xs
- * @returns {string}
- */
-function setSortedToStringAsNativeDeps(xs) {
-  var arr = Array.from(xs).sort();
-  // it relies on we have -opaque, so that .cmx is dummy file
-  return arr.join(" ").replace(/\.cmx/g, ".cmi");
-}
-
-/**
- * Built cppo.exe refmt.exe etc for dev purpose
- */
-function preprocessorNinjaSync() {
-  var napkinFiles = fs
-    .readdirSync(path.join(jscompDir, "..", "syntax", "src"), "ascii")
-    .filter(x => x.endsWith(".ml") || x.endsWith(".mli"));
-  var napkinCliFiles = fs
-    .readdirSync(path.join(jscompDir, "..", "syntax", "cli"), "ascii")
-    .filter(x => x.endsWith(".ml") || x.endsWith(".mli"));
-  var buildNapkinFiles = napkinFiles
-    .map(file => `o napkin/${file} : copy ../syntax/src/${file}`)
-    .join("\n");
-  var buildNapkinCliFiles = napkinCliFiles
-    .map(file => `o napkin/${file} : copy ../syntax/cli/${file}`)
-    .join("\n");
-  var cppoNative = `
-ocamlopt = ocamlopt.opt
-ocamllex = ocamllex.opt
-ocamlc = ocamlc.opt
-ocamlmklib = ocamlmklib
-ocaml = ocaml
-ocamlyacc = ocamlyacc  
-rule link
-    command =  $ocamlopt -g   $flags $libs $in -o $out
-rule bytelink
-    command =  $ocamlc -g  $flags $libs $in -o $out
-o ${cppoFile}: link ${cppoMonoFile}
-    libs = unix.cmxa str.cmxa
-    generator = true
-${cppoRule()}
-${cppoList("ext", [
-  ["hash_set_string.ml", "hash_set.cppo.ml", dTypeString],
-  ["hash_set_int.ml", "hash_set.cppo.ml", dTypeInt],
-  ["hash_set_ident.ml", "hash_set.cppo.ml", dTypeIdent],
-  ["hash_set.ml", "hash_set.cppo.ml", dTypeFunctor],
-  ["hash_set_poly.ml", "hash_set.cppo.ml", dTypePoly],
-  ["vec_int.ml", "vec.cppo.ml", dTypeInt],
-  ["vec.ml", "vec.cppo.ml", dTypeFunctor],
-  ["set_string.ml", "set.cppo.ml", dTypeString],
-  ["set_int.ml", "set.cppo.ml", dTypeInt],
-  ["set_ident.ml", "set.cppo.ml", dTypeIdent],
-  ["map_string.ml", "map.cppo.ml", dTypeString],
-  ["map_int.ml", "map.cppo.ml", dTypeInt],
-  ["map_ident.ml", "map.cppo.ml", dTypeIdent],
-  [
-    "ordered_hash_map_local_ident.ml",
-    "ordered_hash_map.cppo.ml",
-    dTypeLocalIdent,
-  ],
-  ["hash_string.ml", "hash.cppo.ml", dTypeString],
-  ["hash_int.ml", "hash.cppo.ml", dTypeInt],
-  ["hash_ident.ml", "hash.cppo.ml", dTypeIdent],
-  ["hash.ml", "hash.cppo.ml", dTypeFunctor],
-  ["ext_string.ml", "ext_string.pp.ml"],
-  ["ext_string.mli", "ext_string.pp.mli"],
-  ["ext_sys.ml", "ext_sys.pp.ml"],
-])}
-${cppoList("stubs", [["bs_hash_stubs.ml", "bs_hash_stubs.pp.ml"]])}
-${cppoList("ml", [
-  ["cmt_format.ml", "cmt_format.pp.ml"],
-  ["pprintast.ml", "pprintast.pp.ml"],
-])}
-${cppoList("common", [["js_config.ml", "js_config.pp.ml"]])}
-${cppoList("frontend", [["external_ffi_types.ml", "external_ffi_types.pp.ml"]])}
-${cppoList("core", [
-  ["lam_compile_main.ml", "lam_compile_main.pp.ml"],
-  ["bs_cmi_load.ml", "bs_cmi_load.pp.ml"],
-  ["bs_conditional_initial.ml", "bs_conditional_initial.pp.ml"],
-  ["js_cmj_load.ml", "js_cmj_load.pp.ml"],
-  ["js_name_of_module_id.ml", "js_name_of_module_id.pp.ml"],
-  ["js_pass_debug.ml", "js_pass_debug.pp.ml"],
-  ["lam_pass_lets_dce.ml", "lam_pass_lets_dce.pp.ml"],
-  ["lam_util.ml", "lam_util.pp.ml"],
-])}
-${cppoList("others", [
-  ["belt_HashSetString.ml", "hashset.cppo.ml", dTypeString],
-  ["belt_HashSetString.mli", "hashset.cppo.mli", dTypeString],
-  ["belt_HashSetInt.ml", "hashset.cppo.ml", dTypeInt],
-  ["belt_HashSetInt.mli", "hashset.cppo.mli", dTypeInt],
-  ["belt_HashMapString.ml", "hashmap.cppo.ml", dTypeString],
-  ["belt_HashMapString.mli", "hashmap.cppo.mli", dTypeString],
-  ["belt_HashMapInt.ml", "hashmap.cppo.ml", dTypeInt],
-  ["belt_HashMapInt.mli", "hashmap.cppo.mli", dTypeInt],
-  ["belt_MapString.ml", "map.cppo.ml", dTypeString],
-  ["belt_MapString.mli", "map.cppo.mli", dTypeString],
-  ["belt_MapInt.ml", "map.cppo.ml", dTypeInt],
-  ["belt_MapInt.mli", "map.cppo.mli", dTypeInt],
-  ["belt_SetString.ml", "belt_Set.cppo.ml", dTypeString],
-  ["belt_SetString.mli", "belt_Set.cppo.mli", dTypeString],
-  ["belt_SetInt.ml", "belt_Set.cppo.ml", dTypeInt],
-  ["belt_SetInt.mli", "belt_Set.cppo.mli", dTypeInt],
-  ["belt_MutableMapString.ml", "mapm.cppo.ml", dTypeString],
-  ["belt_MutableMapString.mli", "mapm.cppo.mli", dTypeString],
-  ["belt_MutableMapInt.ml", "mapm.cppo.ml", dTypeInt],
-  ["belt_MutableMapInt.mli", "mapm.cppo.mli", dTypeInt],
-  ["belt_MutableSetString.ml", "setm.cppo.ml", dTypeString],
-  ["belt_MutableSetString.mli", "setm.cppo.mli", dTypeString],
-  ["belt_MutableSetInt.ml", "setm.cppo.ml", dTypeInt],
-  ["belt_MutableSetInt.mli", "setm.cppo.mli", dTypeInt],
-  ["belt_SortArrayString.ml", "sort.cppo.ml", dTypeString],
-  ["belt_SortArrayString.mli", "sort.cppo.mli", dTypeString],
-  ["belt_SortArrayInt.ml", "sort.cppo.ml", dTypeInt],
-  ["belt_SortArrayInt.mli", "sort.cppo.mli", dTypeInt],
-  ["belt_internalMapString.ml", "internal_map.cppo.ml", dTypeString],
-  ["belt_internalMapInt.ml", "internal_map.cppo.ml", dTypeInt],
-  ["belt_internalSetString.ml", "internal_set.cppo.ml", dTypeString],
-  ["belt_internalSetInt.ml", "internal_set.cppo.ml", dTypeInt],
-  ["js_typed_array.ml", "js_typed_array.cppo.ml", ""],
-  ["js_typed_array2.ml", "js_typed_array2.cppo.ml", ""],
-])}
-
-${mllRule}
-${mllList("ext", ["ext_json_parse.mll"])}
-${mllList("ml", ["lexer.mll"])}
-rule copy
-  command = cp $in $out
-  description = $in -> $out    
-${buildNapkinFiles}    
-${buildNapkinCliFiles}
-`;
-  var cppoNinjaFile = "cppoVendor.ninja";
-  writeFileSync(path.join(jscompDir, cppoNinjaFile), cppoNative);
-  cp.execFileSync(vendorNinjaPath, ["-f", cppoNinjaFile, "--verbose", "-v"], {
-    cwd: jscompDir,
-    stdio: [0, 1, 2],
-    encoding: "utf8",
-  });
-}
-
-var sourceDirs = [
-  "bsb",
-  "bsb_helper",
-  "common",
-  "core",
-  "depends",
-  "frontend",
-  "gentype",
-  "js_parser",
-  "ext",
-  "main",
-  "ml",
-  "ounit",
-  "ounit_tests",
-  "outcome_printer",
-  "napkin",
-  "stubs",
-  "super_errors",
-];
-/**
- *
- * @param {string[]} dirs
- */
-function makeLibs(dirs) {
-  return dirs.map(x => `${x}/${x}.cmxa`).join(" ");
-}
-var compiler_libs = ["ml"];
-var bsc_libs = [
-  "stubs",
-  "ext",
-  ...compiler_libs,
-  "js_parser",
-  "napkin",
-  "common",
-  "frontend",
-  "depends",
-  "gentype",
-  "super_errors",
-  "outcome_printer",
-  "core",
-];
-
-var bsb_helper_libs = ["stubs", "ext", "common", "bsb_helper"];
-
-var rescript_libs = ["stubs", "ext", "common", "bsb"];
-
-var cmjdumps_libs = [
-  "stubs",
-  ...compiler_libs,
-  "ext",
-  "common",
-  "frontend",
-  "depends",
-  "core",
-];
-
-var cmij_libs = [
-  "stubs",
-  "ext",
-  ...compiler_libs,
-  "common",
-  "frontend",
-  "depends",
-  "core",
-];
-
-var tests_libs = [
-  "stubs",
-  "ext",
-  ...compiler_libs,
-  "ounit",
-  "common",
-  "frontend",
-  "depends",
-  "bsb",
-  "bsb_helper",
-  "core",
-  "ounit_tests",
-];
-/**
- * Note don't run `ninja -t clean -g`
- * Since it will remove generated ml file which has
- * an effect on depfile
- */
-function nativeNinja() {
-  var ninjaOutput = "compiler.ninja";
-
-  var includes = sourceDirs.map(x => `-I ${x}`).join(" ");
-
-  var flags = "-w A-4-9-40..42-30-48-50-44-45";
-  var minor_version = +getVersionString().split(".")[1];
-  if (minor_version > 12) {
-    flags += "-69-70"; // we should turn -69 on except for vendored files
-  }
-  if (minor_version > 7) {
-    flags += "-3-67 -error-style short";
-  }
-  var templateNative = `
-ocamlopt = ocamlopt.opt
-ocamllex = ocamllex.opt
-ocamlc = ocamlc.opt
-ocamlmklib = ocamlmklib
-ocaml = ocaml
-ocamlyacc = ocamlyacc
-subninja cppoVendor.ninja
-
-rule optc
-    command = $ocamlopt -bin-annot -strict-sequence -safe-string  -opaque ${includes} -g -linscan ${flags} -warn-error A -absname -c $in 
-    description = $out : $in
-rule archive
-    command = $ocamlopt -a $in -o $out
-    description = arcive -> $out
-rule link
-    command =  $ocamlopt -g   $flags $libs $in -o $out 
-    description = linking -> $out
-rule mk_bsversion
-    command = node $in
-    generator = true
-rule gcc
-    command = $ocamlopt -ccopt -fPIC -ccopt -O2 -ccopt -o -ccopt $out -c $in
-o stubs/ext_basic_hash_stubs.o : gcc  stubs/ext_basic_hash_stubs.c
-rule ocamlmklib
-    command = $ocamlmklib -v $in -o $name && touch $out
-
-rule mk_keywords
-    command = $ocaml $in
-    generator = true
-o ext/js_reserved_map.ml: mk_keywords ../scripts/build_sorted.ml keywords.list
-
-o stubs/libbs_hash.a stubs/dllbs_hash.so: ocamlmklib stubs/ext_basic_hash_stubs.o
-    name = stubs/bs_hash
-rule stubslib
-    command = $ocamlopt -a $ml -o $out -cclib $clib
-o stubs/stubs.cmxa : stubslib stubs/bs_hash_stubs.cmx stubs/libbs_hash.a
-    ml = stubs/bs_hash_stubs.cmx
-    clib = stubs/libbs_hash.a
-
-rule p4of
-    command = node ../ocaml-tree/wasm.js $flags -i $i -o $out
-    generator = true
-o core/js_fold.ml: p4of core/j.ml
-    flags = -fold
-o core/js_record_iter.ml: p4of core/j.ml
-    flags = -record-iter
-o core/js_record_map.ml: p4of core/j.ml
-    flags = -record-map
-o core/js_record_fold.ml: p4of core/j.ml
-    flags = -record-fold
-
-o ${my_target}/bsc.exe: link  ${makeLibs(
-    bsc_libs
-  )} main/rescript_compiler_main.cmx
-  libs =  unix.cmxa str.cmxa    
-o ${my_target}/rescript.exe: link ${makeLibs(
-    rescript_libs
-  )} main/rescript_main.cmx
-      libs =  unix.cmxa str.cmxa    
-o ${my_target}/bsb_helper.exe: link ${makeLibs(
-    bsb_helper_libs
-  )} main/bsb_helper_main.cmx
-    libs =  unix.cmxa str.cmxa
-o ./bin/bspack.exe: link  ./main/bspack_main.cmx
-    libs = unix.cmxa 
-    flags = -I ./bin -w -40-30-50    
-o ./bin/cmjdump.exe: link ${makeLibs(cmjdumps_libs)} main/cmjdump_main.cmx
-    
-o ./bin/cmij.exe: link ${makeLibs(cmij_libs)} main/cmij_main.cmx
-    
-o ./bin/tests.exe: link ${makeLibs(tests_libs)} main/ounit_tests_main.cmx
-    libs = str.cmxa unix.cmxa 
-build native: phony ${my_target}/bsc.exe ${my_target}/rescript.exe ${my_target}/bsb_helper.exe ./bin/bspack.exe ./bin/cmjdump.exe ./bin/cmij.exe ./bin/tests.exe
-
-
-${mllRule}
-${mlyRule}
-
-
-${mlyList("ml", ["parser.mly"])}
-rule mk_shared
-    command = $ocamlopt -I +compiler-libs -shared $flags -o $out $in
-o ../odoc_gen/generator.cmxs : mk_shared ../odoc_gen/generator.mli ../odoc_gen/generator.ml
-    flags = -I +ocamldoc -I ../odoc_gen -absname
-`;
-  /**
-   * @type { {name : string, libs: string[]}[]}
-   */
-  var libs = [];
-  sourceDirs.forEach(name => {
-    if (name !== "main" && name !== "stubs") {
-      libs.push({ name, libs: [] });
-    }
-  });
-
-  /**
-   * @type{string[]}
-   */
-  var files = [];
-  for (let dir of sourceDirs) {
-    files = files.concat(test(dir));
-  }
-
-  cp.exec(
-    `ocamldep.opt -allow-approx -one-line -native ${includes} ${files.join(
-      " "
-    )}`,
-    { cwd: jscompDir, encoding: "ascii" },
-    function (error, out) {
-      if (error !== null) {
-        throw error;
-      }
-      /**
-       * @type {Map<string,Set<string>>}
-       */
-      var map = new Map();
-
-      var pairs = out.split("\n").map(x => x.split(":").map(x => x.trim()));
-      pairs.forEach(pair => {
-        /**
-         * @type {string[]|string}
-         */
-
-        var deps;
-        var key = pair[0];
-        if (pair[1] !== undefined && (deps = pair[1].trim())) {
-          // deps = deps.replace(/.cmx/g, ".cmi");
-          deps = deps.split(" ");
-          map.set(key, new Set(deps));
-        }
-        if (key.endsWith("cmx")) {
-          libs.forEach(x => {
-            if (path.dirname(key) === x.name) {
-              x.libs.push(key);
-            }
-          });
-        }
-      });
-
-      // not ocamldep output
-      // when no mli exists no deps for cmi otherwise add cmi
-      var stmts = pairs.map(pair => {
-        if (pair[0]) {
-          var target = pair[0];
-          var y = path.parse(target);
-          /**
-           * @type {Set<string>}
-           */
-          var deps = map.get(target) || new Set();
-          if (y.ext === ".cmx") {
-            var intf = path.join(y.dir, y.name + ".cmi");
-            var ml = path.join(y.dir, y.name + ".ml");
-            return `o ${
-              deps.has(intf) ? target : [target, intf].join(" ")
-            } : optc ${ml} | ${setSortedToStringAsNativeDeps(deps)}`;
-          } else {
-            // === 'cmi'
-            var mli = path.join(y.dir, y.name + ".mli");
-            return `o ${target} : optc ${mli} | ${setSortedToStringAsNativeDeps(
-              deps
-            )}`;
-          }
-        }
-      });
-      libs.forEach(x => {
-        var output = sortFilesByDeps(x.libs, map);
-        var name = x.name;
-        stmts.push(`o ${name}/${name}.cmxa : archive ${output.join(" ")}`);
-      });
-
-      writeFileAscii(
-        path.join(jscompDir, ninjaOutput),
-        templateNative + stmts.join("\n") + "\n"
-      );
-    }
-  );
-}
-
-function main() {
-  var emptyCount = 2;
-  var isPlayground = false;
-  if (require.main === module) {
-    if (process.argv.includes("-check")) {
-      checkEffect();
-    }
-    if (process.argv.includes("-playground")) {
-      isPlayground = true;
-      emptyCount++;
-    }
-
-    var subcommand = process.argv[2];
-    switch (subcommand) {
-      case "build":
-        try {
-          cp.execFileSync(vendorNinjaPath, ["native", "all"], {
-            encoding: "utf8",
-            cwd: jscompDir,
-            stdio: [0, 1, 2],
-          });
-          if (!isPlayground) {
-            cp.execFileSync(
-              path.join(__dirname, "..", "jscomp", "bin", "cmij.exe"),
-              {
-                encoding: "utf8",
-                cwd: jscompDir,
-                stdio: [0, 1, 2],
-              }
-            );
-          }
-          cp.execFileSync(vendorNinjaPath, ["-f", "snapshot.ninja"], {
-            encoding: "utf8",
-            cwd: jscompDir,
-            stdio: [0, 1, 2],
-          });
-        } catch (e) {
-          console.log(e.message);
-          console.log(`please run "./scripts/ninja.js config" first`);
-          process.exit(2);
-        }
-        cp.execSync(`node ${__filename} config`, {
-          cwd: __dirname,
-          stdio: [0, 1, 2],
-        });
-        break;
-      case "clean":
-        try {
-          cp.execFileSync(vendorNinjaPath, ["-t", "clean"], {
-            encoding: "utf8",
-            cwd: jscompDir,
-            stdio: [0, 1],
-          });
-        } catch (e) {}
-        cp.execSync(
-          `git clean -dfx jscomp ${my_target} lib && rm -rf lib/js/*.js && rm -rf lib/es6/*.js`,
-          {
-            encoding: "utf8",
-            cwd: path.join(__dirname, ".."),
-            stdio: [0, 1, 2],
-          }
-        );
-        break;
-      case "config":
-        console.log(`config for the first time may take a while`);
-        updateDev();
-        updateRelease();
-
-        break;
-      case "cleanbuild":
-        console.log(`run cleaning first`);
-        cp.execSync(`node ${__filename} clean`, {
-          cwd: __dirname,
-          stdio: [0, 1, 2],
-        });
-        cp.execSync(`node ${__filename} config`, {
-          cwd: __dirname,
-          stdio: [0, 1, 2],
-        });
-        cp.execSync(`node ${__filename} build`, {
-          cwd: __dirname,
-          stdio: [0, 1, 2],
-        });
-        break;
-      case "docs":
-        console.log(`building docs`);
-        require("./doc_gen").main();
-        break;
-      case "help":
-        console.log(`supported subcommands:
-[exe] config        
-[exe] build
-[exe] cleanbuild
-[exe] docs
-[exe] help
-[exe] clean
-        `);
-        break;
-      default:
-        if (process.argv.length === emptyCount) {
-          updateDev();
-          updateRelease();
-        } else {
-          var dev = process.argv.includes("-dev");
-          var release = process.argv.includes("-release");
-          var all = process.argv.includes("-all");
-          if (all) {
-            updateDev();
-            updateRelease();
-          } else if (dev) {
-            updateDev();
-          } else if (release) {
-            updateRelease();
-          }
-        }
-        break;
-    }
-  }
-}
-
-main();