@vc-shell/framework 2.0.0-alpha.23 → 2.0.0-alpha.25

package/dist/scripts/check-locales.cjs

@@ -0,0 +1,3182 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../node_modules/universalify/index.js"(exports2) {
+    "use strict";
+    exports2.fromCallback = function(fn) {
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+        else {
+          return new Promise((resolve, reject) => {
+            args.push((err, res) => err != null ? reject(err) : resolve(res));
+            fn.apply(this, args);
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports2.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function") return fn.apply(this, args);
+        else {
+          args.pop();
+          fn.apply(this, args).then((r) => cb(null, r), cb);
+        }
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// ../node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    var constants = require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs2) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs2);
+      }
+      if (!fs2.lutimes) {
+        patchLutimes(fs2);
+      }
+      fs2.chown = chownFix(fs2.chown);
+      fs2.fchown = chownFix(fs2.fchown);
+      fs2.lchown = chownFix(fs2.lchown);
+      fs2.chmod = chmodFix(fs2.chmod);
+      fs2.fchmod = chmodFix(fs2.fchmod);
+      fs2.lchmod = chmodFix(fs2.lchmod);
+      fs2.chownSync = chownFixSync(fs2.chownSync);
+      fs2.fchownSync = chownFixSync(fs2.fchownSync);
+      fs2.lchownSync = chownFixSync(fs2.lchownSync);
+      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+      fs2.stat = statFix(fs2.stat);
+      fs2.fstat = statFix(fs2.fstat);
+      fs2.lstat = statFix(fs2.lstat);
+      fs2.statSync = statFixSync(fs2.statSync);
+      fs2.fstatSync = statFixSync(fs2.fstatSync);
+      fs2.lstatSync = statFixSync(fs2.lstatSync);
+      if (fs2.chmod && !fs2.lchmod) {
+        fs2.lchmod = function(path2, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs2.lchmodSync = function() {
+        };
+      }
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path2, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs2.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : (function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs2.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            });
+          }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        })(fs2.rename);
+      }
+      fs2.read = typeof fs2.read !== "function" ? fs2.read : (function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path2, mode, callback) {
+          fs3.open(
+            path2,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs3.lchmodSync = function(path2, mode) {
+          var fd = fs3.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs3.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs3.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs3.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs3) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+          fs3.lutimes = function(path2, at, mt, cb) {
+            fs3.open(path2, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs3.lutimesSync = function(path2, at, mt) {
+            var fd = fs3.openSync(path2, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs3.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs3.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs3.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs3.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs2, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs2, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs2, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs2, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    var Stream = require("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs2) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path2, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path2, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path2;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path2, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path2, options);
+        Stream.call(this);
+        this.path = path2;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs2.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs2[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs2, queue);
+      fs2.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs2, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs2.close);
+      fs2.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs2, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs2.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs2[gracefulQueue]);
+          require("assert").equal(fs2[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs2[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs2));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+      module2.exports = patch(fs2);
+      fs2.__patched = true;
+    }
+    function patch(fs3) {
+      polyfills(fs3);
+      fs3.gracefulify = patch;
+      fs3.createReadStream = createReadStream;
+      fs3.createWriteStream = createWriteStream;
+      var fs$readFile = fs3.readFile;
+      fs3.readFile = readFile;
+      function readFile(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path2, options, cb);
+        function go$readFile(path3, options2, cb2, startTime) {
+          return fs$readFile(path3, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs3.writeFile;
+      fs3.writeFile = writeFile;
+      function writeFile(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path2, data, options, cb);
+        function go$writeFile(path3, data2, options2, cb2, startTime) {
+          return fs$writeFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs3.appendFile;
+      if (fs$appendFile)
+        fs3.appendFile = appendFile;
+      function appendFile(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path2, data, options, cb);
+        function go$appendFile(path3, data2, options2, cb2, startTime) {
+          return fs$appendFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs3.copyFile;
+      if (fs$copyFile)
+        fs3.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs3.readdir;
+      fs3.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, options2, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path2, options, cb);
+        function fs$readdirCallback(path3, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path3, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs3);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs3.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs3.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs3, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs3, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs3, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs3, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path2, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path2, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path2, options) {
+        return new fs3.ReadStream(path2, options);
+      }
+      function createWriteStream(path2, options) {
+        return new fs3.WriteStream(path2, options);
+      }
+      var fs$open = fs3.open;
+      fs3.open = open;
+      function open(path2, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path2, flags, mode, cb);
+        function go$open(path3, flags2, mode2, cb2, startTime) {
+          return fs$open(path3, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs3;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs2[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
+        if (fs2[gracefulQueue][i].length > 2) {
+          fs2[gracefulQueue][i][3] = now;
+          fs2[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs2[gracefulQueue].length === 0)
+        return;
+      var elem = fs2[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs2[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "../node_modules/fs-extra/lib/fs/index.js"(exports2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs2 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs2[key] === "function";
+    });
+    Object.keys(fs2).forEach((key) => {
+      if (key === "promises") {
+        return;
+      }
+      exports2[key] = fs2[key];
+    });
+    api.forEach((method) => {
+      exports2[method] = u(fs2[method]);
+    });
+    exports2.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs2.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs2.exists(filename, resolve);
+      });
+    };
+    exports2.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs2.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs2.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    if (typeof fs2.writev === "function") {
+      exports2.writev = function(fd, buffers, ...args) {
+        if (typeof args[args.length - 1] === "function") {
+          return fs2.writev(fd, buffers, ...args);
+        }
+        return new Promise((resolve, reject) => {
+          fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+            if (err) return reject(err);
+            resolve({ bytesWritten, buffers: buffers2 });
+          });
+        });
+      };
+    }
+    if (typeof fs2.realpath.native === "function") {
+      exports2.realpath.native = u(fs2.realpath.native);
+    }
+  }
+});
+
+// ../node_modules/at-least-node/index.js
+var require_at_least_node = __commonJS({
+  "../node_modules/at-least-node/index.js"(exports2, module2) {
+    module2.exports = (r) => {
+      const n = process.versions.node.split(".").map((x) => parseInt(x, 10));
+      r = r.split(".").map((x) => parseInt(x, 10));
+      return n[0] > r[0] || n[0] === r[0] && (n[1] > r[1] || n[1] === r[1] && n[2] >= r[2]);
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs();
+    var path2 = require("path");
+    var atLeastNode = require_at_least_node();
+    var useNativeRecursiveOption = atLeastNode("10.12.0");
+    var checkPath = (pth) => {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path2.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+    var processOptions = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number") options = { mode: options };
+      return { ...defaults, ...options };
+    };
+    var permissionError = (pth) => {
+      const error = new Error(`operation not permitted, mkdir '${pth}'`);
+      error.code = "EPERM";
+      error.errno = -4048;
+      error.path = pth;
+      error.syscall = "mkdir";
+      return error;
+    };
+    module2.exports.makeDir = async (input, options) => {
+      checkPath(input);
+      options = processOptions(options);
+      if (useNativeRecursiveOption) {
+        const pth = path2.resolve(input);
+        return fs2.mkdir(pth, {
+          mode: options.mode,
+          recursive: true
+        });
+      }
+      const make = async (pth) => {
+        try {
+          await fs2.mkdir(pth, options.mode);
+        } catch (error) {
+          if (error.code === "EPERM") {
+            throw error;
+          }
+          if (error.code === "ENOENT") {
+            if (path2.dirname(pth) === pth) {
+              throw permissionError(pth);
+            }
+            if (error.message.includes("null bytes")) {
+              throw error;
+            }
+            await make(path2.dirname(pth));
+            return make(pth);
+          }
+          try {
+            const stats = await fs2.stat(pth);
+            if (!stats.isDirectory()) {
+              throw new Error("The path is not a directory");
+            }
+          } catch {
+            throw error;
+          }
+        }
+      };
+      return make(path2.resolve(input));
+    };
+    module2.exports.makeDirSync = (input, options) => {
+      checkPath(input);
+      options = processOptions(options);
+      if (useNativeRecursiveOption) {
+        const pth = path2.resolve(input);
+        return fs2.mkdirSync(pth, {
+          mode: options.mode,
+          recursive: true
+        });
+      }
+      const make = (pth) => {
+        try {
+          fs2.mkdirSync(pth, options.mode);
+        } catch (error) {
+          if (error.code === "EPERM") {
+            throw error;
+          }
+          if (error.code === "ENOENT") {
+            if (path2.dirname(pth) === pth) {
+              throw permissionError(pth);
+            }
+            if (error.message.includes("null bytes")) {
+              throw error;
+            }
+            make(path2.dirname(pth));
+            return make(pth);
+          }
+          try {
+            if (!fs2.statSync(pth).isDirectory()) {
+              throw new Error("The path is not a directory");
+            }
+          } catch {
+            throw error;
+          }
+        }
+      };
+      return make(path2.resolve(input));
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module2.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    function utimesMillis(path2, atime, mtime, callback) {
+      fs2.open(path2, "r+", (err, fd) => {
+        if (err) return callback(err);
+        fs2.futimes(fd, atime, mtime, (futimesErr) => {
+          fs2.close(fd, (closeErr) => {
+            if (callback) callback(futimesErr || closeErr);
+          });
+        });
+      });
+    }
+    function utimesMillisSync(path2, atime, mtime) {
+      const fd = fs2.openSync(path2, "r+");
+      fs2.futimesSync(fd, atime, mtime);
+      return fs2.closeSync(fd);
+    }
+    module2.exports = {
+      utimesMillis,
+      utimesMillisSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs();
+    var path2 = require("path");
+    var util = require("util");
+    var atLeastNode = require_at_least_node();
+    var nodeSupportsBigInt = atLeastNode("10.5.0");
+    var stat = (file) => nodeSupportsBigInt ? fs2.stat(file, { bigint: true }) : fs2.stat(file);
+    var statSync = (file) => nodeSupportsBigInt ? fs2.statSync(file, { bigint: true }) : fs2.statSync(file);
+    function getStats(src, dest) {
+      return Promise.all([
+        stat(src),
+        stat(dest).catch((err) => {
+          if (err.code === "ENOENT") return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest) {
+      let destStat;
+      const srcStat = statSync(src);
+      try {
+        destStat = statSync(dest);
+      } catch (err) {
+        if (err.code === "ENOENT") return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    function checkPaths(src, dest, funcName, cb) {
+      util.callbackify(getStats)(src, dest, (err, stats) => {
+        if (err) return cb(err);
+        const { srcStat, destStat } = stats;
+        if (destStat && areIdentical(srcStat, destStat)) {
+          return cb(new Error("Source and destination must not be the same."));
+        }
+        if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+          return cb(new Error(errMsg(src, dest, funcName)));
+        }
+        return cb(null, { srcStat, destStat });
+      });
+    }
+    function checkPathsSync(src, dest, funcName) {
+      const { srcStat, destStat } = getStatsSync(src, dest);
+      if (destStat && areIdentical(srcStat, destStat)) {
+        throw new Error("Source and destination must not be the same.");
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkParentPaths(src, srcStat, dest, funcName, cb) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root) return cb();
+      const callback = (err, destStat) => {
+        if (err) {
+          if (err.code === "ENOENT") return cb();
+          return cb(err);
+        }
+        if (areIdentical(srcStat, destStat)) {
+          return cb(new Error(errMsg(src, dest, funcName)));
+        }
+        return checkParentPaths(src, srcStat, destParent, funcName, cb);
+      };
+      if (nodeSupportsBigInt) fs2.stat(destParent, { bigint: true }, callback);
+      else fs2.stat(destParent, callback);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = statSync(destParent);
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
+        if (nodeSupportsBigInt || destStat.ino < Number.MAX_SAFE_INTEGER) {
+          return true;
+        }
+        if (destStat.size === srcStat.size && destStat.mode === srcStat.mode && destStat.nlink === srcStat.nlink && destStat.atimeMs === srcStat.atimeMs && destStat.mtimeMs === srcStat.mtimeMs && destStat.ctimeMs === srcStat.ctimeMs && destStat.birthtimeMs === srcStat.birthtimeMs) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path2.resolve(src).split(path2.sep).filter((i) => i);
+      const destArr = path2.resolve(dest).split(path2.sep).filter((i) => i);
+      return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module2.exports = {
+      checkPaths,
+      checkPathsSync,
+      checkParentPaths,
+      checkParentPathsSync,
+      isSrcSubdir
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/copy-sync/copy-sync.js
+var require_copy_sync = __commonJS({
+  "../node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
+
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+      }
+      const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy");
+      stat.checkParentPathsSync(src, srcStat, dest, "copy");
+      return handleFilterAndCopy(destStat, src, dest, opts);
+    }
+    function handleFilterAndCopy(destStat, src, dest, opts) {
+      if (opts.filter && !opts.filter(src, dest)) return;
+      const destParent = path2.dirname(dest);
+      if (!fs2.existsSync(destParent)) mkdirsSync(destParent);
+      return startCopy(destStat, src, dest, opts);
+    }
+    function startCopy(destStat, src, dest, opts) {
+      if (opts.filter && !opts.filter(src, dest)) return;
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
+      const srcStat = statSync(src);
+      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs2.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs2.copyFileSync(src, dest);
+      if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs2.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs2.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      if (destStat && !destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+      }
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs2.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path2.join(src, item);
+      const destItem = path2.join(dest, item);
+      const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy");
+      return startCopy(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs2.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs2.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs2.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs2.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (fs2.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs2.unlinkSync(dest);
+      return fs2.symlinkSync(resolvedSrc, dest);
+    }
+    module2.exports = copySync;
+  }
+});
+
+// ../node_modules/fs-extra/lib/copy-sync/index.js
+var require_copy_sync2 = __commonJS({
+  "../node_modules/fs-extra/lib/copy-sync/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs2 = require_fs();
+    function pathExists(path2) {
+      return fs2.access(path2).then(() => true).catch(() => false);
+    }
+    module2.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs2.existsSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var mkdirs = require_mkdirs().mkdirs;
+    var pathExists = require_path_exists().pathExists;
+    var utimesMillis = require_utimes().utimesMillis;
+    var stat = require_stat();
+    function copy(src, dest, opts, cb) {
+      if (typeof opts === "function" && !cb) {
+        cb = opts;
+        opts = {};
+      } else if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      cb = cb || function() {
+      };
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
+
+    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+      }
+      stat.checkPaths(src, dest, "copy", (err, stats) => {
+        if (err) return cb(err);
+        const { srcStat, destStat } = stats;
+        stat.checkParentPaths(src, srcStat, dest, "copy", (err2) => {
+          if (err2) return cb(err2);
+          if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb);
+          return checkParentDir(destStat, src, dest, opts, cb);
+        });
+      });
+    }
+    function checkParentDir(destStat, src, dest, opts, cb) {
+      const destParent = path2.dirname(dest);
+      pathExists(destParent, (err, dirExists) => {
+        if (err) return cb(err);
+        if (dirExists) return startCopy(destStat, src, dest, opts, cb);
+        mkdirs(destParent, (err2) => {
+          if (err2) return cb(err2);
+          return startCopy(destStat, src, dest, opts, cb);
+        });
+      });
+    }
+    function handleFilter(onInclude, destStat, src, dest, opts, cb) {
+      Promise.resolve(opts.filter(src, dest)).then((include) => {
+        if (include) return onInclude(destStat, src, dest, opts, cb);
+        return cb();
+      }, (error) => cb(error));
+    }
+    function startCopy(destStat, src, dest, opts, cb) {
+      if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb);
+      return getStats(destStat, src, dest, opts, cb);
+    }
+    function getStats(destStat, src, dest, opts, cb) {
+      const stat2 = opts.dereference ? fs2.stat : fs2.lstat;
+      stat2(src, (err, srcStat) => {
+        if (err) return cb(err);
+        if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb);
+        else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb);
+        else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb);
+      });
+    }
+    function onFile(srcStat, destStat, src, dest, opts, cb) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts, cb);
+      return mayCopyFile(srcStat, src, dest, opts, cb);
+    }
+    function mayCopyFile(srcStat, src, dest, opts, cb) {
+      if (opts.overwrite) {
+        fs2.unlink(dest, (err) => {
+          if (err) return cb(err);
+          return copyFile(srcStat, src, dest, opts, cb);
+        });
+      } else if (opts.errorOnExist) {
+        return cb(new Error(`'${dest}' already exists`));
+      } else return cb();
+    }
+    function copyFile(srcStat, src, dest, opts, cb) {
+      fs2.copyFile(src, dest, (err) => {
+        if (err) return cb(err);
+        if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
+        return setDestMode(dest, srcStat.mode, cb);
+      });
+    }
+    function handleTimestampsAndMode(srcMode, src, dest, cb) {
+      if (fileIsNotWritable(srcMode)) {
+        return makeFileWritable(dest, srcMode, (err) => {
+          if (err) return cb(err);
+          return setDestTimestampsAndMode(srcMode, src, dest, cb);
+        });
+      }
+      return setDestTimestampsAndMode(srcMode, src, dest, cb);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode, cb) {
+      return setDestMode(dest, srcMode | 128, cb);
+    }
+    function setDestTimestampsAndMode(srcMode, src, dest, cb) {
+      setDestTimestamps(src, dest, (err) => {
+        if (err) return cb(err);
+        return setDestMode(dest, srcMode, cb);
+      });
+    }
+    function setDestMode(dest, srcMode, cb) {
+      return fs2.chmod(dest, srcMode, cb);
+    }
+    function setDestTimestamps(src, dest, cb) {
+      fs2.stat(src, (err, updatedSrcStat) => {
+        if (err) return cb(err);
+        return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
+      });
+    }
+    function onDir(srcStat, destStat, src, dest, opts, cb) {
+      if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb);
+      if (destStat && !destStat.isDirectory()) {
+        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
+      }
+      return copyDir(src, dest, opts, cb);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts, cb) {
+      fs2.mkdir(dest, (err) => {
+        if (err) return cb(err);
+        copyDir(src, dest, opts, (err2) => {
+          if (err2) return cb(err2);
+          return setDestMode(dest, srcMode, cb);
+        });
+      });
+    }
+    function copyDir(src, dest, opts, cb) {
+      fs2.readdir(src, (err, items) => {
+        if (err) return cb(err);
+        return copyDirItems(items, src, dest, opts, cb);
+      });
+    }
+    function copyDirItems(items, src, dest, opts, cb) {
+      const item = items.pop();
+      if (!item) return cb();
+      return copyDirItem(items, item, src, dest, opts, cb);
+    }
+    function copyDirItem(items, item, src, dest, opts, cb) {
+      const srcItem = path2.join(src, item);
+      const destItem = path2.join(dest, item);
+      stat.checkPaths(srcItem, destItem, "copy", (err, stats) => {
+        if (err) return cb(err);
+        const { destStat } = stats;
+        startCopy(destStat, srcItem, destItem, opts, (err2) => {
+          if (err2) return cb(err2);
+          return copyDirItems(items, src, dest, opts, cb);
+        });
+      });
+    }
+    function onLink(destStat, src, dest, opts, cb) {
+      fs2.readlink(src, (err, resolvedSrc) => {
+        if (err) return cb(err);
+        if (opts.dereference) {
+          resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+        }
+        if (!destStat) {
+          return fs2.symlink(resolvedSrc, dest, cb);
+        } else {
+          fs2.readlink(dest, (err2, resolvedDest) => {
+            if (err2) {
+              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs2.symlink(resolvedSrc, dest, cb);
+              return cb(err2);
+            }
+            if (opts.dereference) {
+              resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+            }
+            if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+              return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
+            }
+            if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+              return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
+            }
+            return copyLink(resolvedSrc, dest, cb);
+          });
+        }
+      });
+    }
+    function copyLink(resolvedSrc, dest, cb) {
+      fs2.unlink(dest, (err) => {
+        if (err) return cb(err);
+        return fs2.symlink(resolvedSrc, dest, cb);
+      });
+    }
+    module2.exports = copy;
+  }
+});
+
+// ../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      copy: u(require_copy())
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/remove/rimraf.js
+var require_rimraf = __commonJS({
+  "../node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var assert = require("assert");
+    var isWindows = process.platform === "win32";
+    function defaults(options) {
+      const methods = [
+        "unlink",
+        "chmod",
+        "stat",
+        "lstat",
+        "rmdir",
+        "readdir"
+      ];
+      methods.forEach((m) => {
+        options[m] = options[m] || fs2[m];
+        m = m + "Sync";
+        options[m] = options[m] || fs2[m];
+      });
+      options.maxBusyTries = options.maxBusyTries || 3;
+    }
+    function rimraf(p, options, cb) {
+      let busyTries = 0;
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      assert(p, "rimraf: missing path");
+      assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
+      assert.strictEqual(typeof cb, "function", "rimraf: callback function required");
+      assert(options, "rimraf: invalid options argument provided");
+      assert.strictEqual(typeof options, "object", "rimraf: options should be object");
+      defaults(options);
+      rimraf_(p, options, function CB(er) {
+        if (er) {
+          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
+            busyTries++;
+            const time = busyTries * 100;
+            return setTimeout(() => rimraf_(p, options, CB), time);
+          }
+          if (er.code === "ENOENT") er = null;
+        }
+        cb(er);
+      });
+    }
+    function rimraf_(p, options, cb) {
+      assert(p);
+      assert(options);
+      assert(typeof cb === "function");
+      options.lstat(p, (er, st) => {
+        if (er && er.code === "ENOENT") {
+          return cb(null);
+        }
+        if (er && er.code === "EPERM" && isWindows) {
+          return fixWinEPERM(p, options, er, cb);
+        }
+        if (st && st.isDirectory()) {
+          return rmdir(p, options, er, cb);
+        }
+        options.unlink(p, (er2) => {
+          if (er2) {
+            if (er2.code === "ENOENT") {
+              return cb(null);
+            }
+            if (er2.code === "EPERM") {
+              return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
+            }
+            if (er2.code === "EISDIR") {
+              return rmdir(p, options, er2, cb);
+            }
+          }
+          return cb(er2);
+        });
+      });
+    }
+    function fixWinEPERM(p, options, er, cb) {
+      assert(p);
+      assert(options);
+      assert(typeof cb === "function");
+      options.chmod(p, 438, (er2) => {
+        if (er2) {
+          cb(er2.code === "ENOENT" ? null : er);
+        } else {
+          options.stat(p, (er3, stats) => {
+            if (er3) {
+              cb(er3.code === "ENOENT" ? null : er);
+            } else if (stats.isDirectory()) {
+              rmdir(p, options, er, cb);
+            } else {
+              options.unlink(p, cb);
+            }
+          });
+        }
+      });
+    }
+    function fixWinEPERMSync(p, options, er) {
+      let stats;
+      assert(p);
+      assert(options);
+      try {
+        options.chmodSync(p, 438);
+      } catch (er2) {
+        if (er2.code === "ENOENT") {
+          return;
+        } else {
+          throw er;
+        }
+      }
+      try {
+        stats = options.statSync(p);
+      } catch (er3) {
+        if (er3.code === "ENOENT") {
+          return;
+        } else {
+          throw er;
+        }
+      }
+      if (stats.isDirectory()) {
+        rmdirSync(p, options, er);
+      } else {
+        options.unlinkSync(p);
+      }
+    }
+    function rmdir(p, options, originalEr, cb) {
+      assert(p);
+      assert(options);
+      assert(typeof cb === "function");
+      options.rmdir(p, (er) => {
+        if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) {
+          rmkids(p, options, cb);
+        } else if (er && er.code === "ENOTDIR") {
+          cb(originalEr);
+        } else {
+          cb(er);
+        }
+      });
+    }
+    function rmkids(p, options, cb) {
+      assert(p);
+      assert(options);
+      assert(typeof cb === "function");
+      options.readdir(p, (er, files) => {
+        if (er) return cb(er);
+        let n = files.length;
+        let errState;
+        if (n === 0) return options.rmdir(p, cb);
+        files.forEach((f) => {
+          rimraf(path2.join(p, f), options, (er2) => {
+            if (errState) {
+              return;
+            }
+            if (er2) return cb(errState = er2);
+            if (--n === 0) {
+              options.rmdir(p, cb);
+            }
+          });
+        });
+      });
+    }
+    function rimrafSync(p, options) {
+      let st;
+      options = options || {};
+      defaults(options);
+      assert(p, "rimraf: missing path");
+      assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
+      assert(options, "rimraf: missing options");
+      assert.strictEqual(typeof options, "object", "rimraf: options should be object");
+      try {
+        st = options.lstatSync(p);
+      } catch (er) {
+        if (er.code === "ENOENT") {
+          return;
+        }
+        if (er.code === "EPERM" && isWindows) {
+          fixWinEPERMSync(p, options, er);
+        }
+      }
+      try {
+        if (st && st.isDirectory()) {
+          rmdirSync(p, options, null);
+        } else {
+          options.unlinkSync(p);
+        }
+      } catch (er) {
+        if (er.code === "ENOENT") {
+          return;
+        } else if (er.code === "EPERM") {
+          return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+        } else if (er.code !== "EISDIR") {
+          throw er;
+        }
+        rmdirSync(p, options, er);
+      }
+    }
+    function rmdirSync(p, options, originalEr) {
+      assert(p);
+      assert(options);
+      try {
+        options.rmdirSync(p);
+      } catch (er) {
+        if (er.code === "ENOTDIR") {
+          throw originalEr;
+        } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") {
+          rmkidsSync(p, options);
+        } else if (er.code !== "ENOENT") {
+          throw er;
+        }
+      }
+    }
+    function rmkidsSync(p, options) {
+      assert(p);
+      assert(options);
+      options.readdirSync(p).forEach((f) => rimrafSync(path2.join(p, f), options));
+      if (isWindows) {
+        const startTime = Date.now();
+        do {
+          try {
+            const ret = options.rmdirSync(p, options);
+            return ret;
+          } catch {
+          }
+        } while (Date.now() - startTime < 500);
+      } else {
+        const ret = options.rmdirSync(p, options);
+        return ret;
+      }
+    }
+    module2.exports = rimraf;
+    rimraf.sync = rimrafSync;
+  }
+});
+
+// ../node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var rimraf = require_rimraf();
+    module2.exports = {
+      remove: u(rimraf),
+      removeSync: rimraf.sync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var mkdir = require_mkdirs();
+    var remove = require_remove();
+    var emptyDir = u(function emptyDir2(dir, callback) {
+      callback = callback || function() {
+      };
+      fs2.readdir(dir, (err, items) => {
+        if (err) return mkdir.mkdirs(dir, callback);
+        items = items.map((item) => path2.join(dir, item));
+        deleteItem();
+        function deleteItem() {
+          const item = items.pop();
+          if (!item) return callback();
+          remove.remove(item, (err2) => {
+            if (err2) return callback(err2);
+            deleteItem();
+          });
+        }
+      });
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs2.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path2.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module2.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path2 = require("path");
+    var fs2 = require_graceful_fs();
+    var mkdir = require_mkdirs();
+    function createFile(file, callback) {
+      function makeFile() {
+        fs2.writeFile(file, "", (err) => {
+          if (err) return callback(err);
+          callback();
+        });
+      }
+      fs2.stat(file, (err, stats) => {
+        if (!err && stats.isFile()) return callback();
+        const dir = path2.dirname(file);
+        fs2.stat(dir, (err2, stats2) => {
+          if (err2) {
+            if (err2.code === "ENOENT") {
+              return mkdir.mkdirs(dir, (err3) => {
+                if (err3) return callback(err3);
+                makeFile();
+              });
+            }
+            return callback(err2);
+          }
+          if (stats2.isDirectory()) makeFile();
+          else {
+            fs2.readdir(dir, (err3) => {
+              if (err3) return callback(err3);
+            });
+          }
+        });
+      });
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs2.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path2.dirname(file);
+      try {
+        if (!fs2.statSync(dir).isDirectory()) {
+          fs2.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+        else throw err;
+      }
+      fs2.writeFileSync(file, "");
+    }
+    module2.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path2 = require("path");
+    var fs2 = require_graceful_fs();
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    function createLink(srcpath, dstpath, callback) {
+      function makeLink(srcpath2, dstpath2) {
+        fs2.link(srcpath2, dstpath2, (err) => {
+          if (err) return callback(err);
+          callback(null);
+        });
+      }
+      pathExists(dstpath, (err, destinationExists) => {
+        if (err) return callback(err);
+        if (destinationExists) return callback(null);
+        fs2.lstat(srcpath, (err2) => {
+          if (err2) {
+            err2.message = err2.message.replace("lstat", "ensureLink");
+            return callback(err2);
+          }
+          const dir = path2.dirname(dstpath);
+          pathExists(dir, (err3, dirExists) => {
+            if (err3) return callback(err3);
+            if (dirExists) return makeLink(srcpath, dstpath);
+            mkdir.mkdirs(dir, (err4) => {
+              if (err4) return callback(err4);
+              makeLink(srcpath, dstpath);
+            });
+          });
+        });
+      });
+    }
+    function createLinkSync(srcpath, dstpath) {
+      const destinationExists = fs2.existsSync(dstpath);
+      if (destinationExists) return void 0;
+      try {
+        fs2.lstatSync(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path2.dirname(dstpath);
+      const dirExists = fs2.existsSync(dir);
+      if (dirExists) return fs2.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs2.linkSync(srcpath, dstpath);
+    }
+    module2.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
+    "use strict";
+    var path2 = require("path");
+    var fs2 = require_graceful_fs();
+    var pathExists = require_path_exists().pathExists;
+    function symlinkPaths(srcpath, dstpath, callback) {
+      if (path2.isAbsolute(srcpath)) {
+        return fs2.lstat(srcpath, (err) => {
+          if (err) {
+            err.message = err.message.replace("lstat", "ensureSymlink");
+            return callback(err);
+          }
+          return callback(null, {
+            toCwd: srcpath,
+            toDst: srcpath
+          });
+        });
+      } else {
+        const dstdir = path2.dirname(dstpath);
+        const relativeToDst = path2.join(dstdir, srcpath);
+        return pathExists(relativeToDst, (err, exists) => {
+          if (err) return callback(err);
+          if (exists) {
+            return callback(null, {
+              toCwd: relativeToDst,
+              toDst: srcpath
+            });
+          } else {
+            return fs2.lstat(srcpath, (err2) => {
+              if (err2) {
+                err2.message = err2.message.replace("lstat", "ensureSymlink");
+                return callback(err2);
+              }
+              return callback(null, {
+                toCwd: srcpath,
+                toDst: path2.relative(dstdir, srcpath)
+              });
+            });
+          }
+        });
+      }
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      let exists;
+      if (path2.isAbsolute(srcpath)) {
+        exists = fs2.existsSync(srcpath);
+        if (!exists) throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      } else {
+        const dstdir = path2.dirname(dstpath);
+        const relativeToDst = path2.join(dstdir, srcpath);
+        exists = fs2.existsSync(relativeToDst);
+        if (exists) {
+          return {
+            toCwd: relativeToDst,
+            toDst: srcpath
+          };
+        } else {
+          exists = fs2.existsSync(srcpath);
+          if (!exists) throw new Error("relative srcpath does not exist");
+          return {
+            toCwd: srcpath,
+            toDst: path2.relative(dstdir, srcpath)
+          };
+        }
+      }
+    }
+    module2.exports = {
+      symlinkPaths,
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    function symlinkType(srcpath, type, callback) {
+      callback = typeof type === "function" ? type : callback;
+      type = typeof type === "function" ? false : type;
+      if (type) return callback(null, type);
+      fs2.lstat(srcpath, (err, stats) => {
+        if (err) return callback(null, "file");
+        type = stats && stats.isDirectory() ? "dir" : "file";
+        callback(null, type);
+      });
+    }
+    function symlinkTypeSync(srcpath, type) {
+      let stats;
+      if (type) return type;
+      try {
+        stats = fs2.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module2.exports = {
+      symlinkType,
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var path2 = require("path");
+    var fs2 = require_graceful_fs();
+    var _mkdirs = require_mkdirs();
+    var mkdirs = _mkdirs.mkdirs;
+    var mkdirsSync = _mkdirs.mkdirsSync;
+    var _symlinkPaths = require_symlink_paths();
+    var symlinkPaths = _symlinkPaths.symlinkPaths;
+    var symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
+    var _symlinkType = require_symlink_type();
+    var symlinkType = _symlinkType.symlinkType;
+    var symlinkTypeSync = _symlinkType.symlinkTypeSync;
+    var pathExists = require_path_exists().pathExists;
+    function createSymlink(srcpath, dstpath, type, callback) {
+      callback = typeof type === "function" ? type : callback;
+      type = typeof type === "function" ? false : type;
+      pathExists(dstpath, (err, destinationExists) => {
+        if (err) return callback(err);
+        if (destinationExists) return callback(null);
+        symlinkPaths(srcpath, dstpath, (err2, relative) => {
+          if (err2) return callback(err2);
+          srcpath = relative.toDst;
+          symlinkType(relative.toCwd, type, (err3, type2) => {
+            if (err3) return callback(err3);
+            const dir = path2.dirname(dstpath);
+            pathExists(dir, (err4, dirExists) => {
+              if (err4) return callback(err4);
+              if (dirExists) return fs2.symlink(srcpath, dstpath, type2, callback);
+              mkdirs(dir, (err5) => {
+                if (err5) return callback(err5);
+                fs2.symlink(srcpath, dstpath, type2, callback);
+              });
+            });
+          });
+        });
+      });
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      const destinationExists = fs2.existsSync(dstpath);
+      if (destinationExists) return void 0;
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path2.dirname(dstpath);
+      const exists = fs2.existsSync(dir);
+      if (exists) return fs2.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs2.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+    "use strict";
+    var file = require_file();
+    var link = require_link();
+    var symlink = require_symlink();
+    module2.exports = {
+      // file
+      createFile: file.createFile,
+      createFileSync: file.createFileSync,
+      ensureFile: file.createFile,
+      ensureFileSync: file.createFileSync,
+      // link
+      createLink: link.createLink,
+      createLinkSync: link.createLinkSync,
+      ensureLink: link.createLink,
+      ensureLinkSync: link.createLinkSync,
+      // symlink
+      createSymlink: symlink.createSymlink,
+      createSymlinkSync: symlink.createSymlinkSync,
+      ensureSymlink: symlink.createSymlink,
+      ensureSymlinkSync: symlink.createSymlinkSync
+    };
+  }
+});
+
+// ../node_modules/jsonfile/utils.js
+var require_utils = __commonJS({
+  "../node_modules/jsonfile/utils.js"(exports2, module2) {
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content)) content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module2.exports = { stringify, stripBom };
+  }
+});
+
+// ../node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../node_modules/jsonfile/index.js"(exports2, module2) {
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs2 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs2.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs2 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs2.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs2 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs2.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs2 = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs2.writeFileSync(file, str, options);
+    }
+    module2.exports = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module2.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/output/index.js
+var require_output = __commonJS({
+  "../node_modules/fs-extra/lib/output/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    function outputFile(file, data, encoding, callback) {
+      if (typeof encoding === "function") {
+        callback = encoding;
+        encoding = "utf8";
+      }
+      const dir = path2.dirname(file);
+      pathExists(dir, (err, itDoes) => {
+        if (err) return callback(err);
+        if (itDoes) return fs2.writeFile(file, data, encoding, callback);
+        mkdir.mkdirs(dir, (err2) => {
+          if (err2) return callback(err2);
+          fs2.writeFile(file, data, encoding, callback);
+        });
+      });
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path2.dirname(file);
+      if (fs2.existsSync(dir)) {
+        return fs2.writeFileSync(file, ...args);
+      }
+      mkdir.mkdirsSync(dir);
+      fs2.writeFileSync(file, ...args);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils();
+    var { outputFile } = require_output();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module2.exports = outputJson;
+  }
+});
+
+// ../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils();
+    var { outputFileSync } = require_output();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module2.exports = outputJsonSync;
+  }
+});
+
+// ../node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module2.exports = jsonFile;
+  }
+});
+
+// ../node_modules/fs-extra/lib/move-sync/move-sync.js
+var require_move_sync = __commonJS({
+  "../node_modules/fs-extra/lib/move-sync/move-sync.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var copySync = require_copy_sync2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat } = stat.checkPathsSync(src, dest, "move");
+      stat.checkParentPathsSync(src, srcStat, dest, "move");
+      mkdirpSync(path2.dirname(dest));
+      return doRename(src, dest, overwrite);
+    }
+    function doRename(src, dest, overwrite) {
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs2.existsSync(dest)) throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs2.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module2.exports = moveSync;
+  }
+});
+
+// ../node_modules/fs-extra/lib/move-sync/index.js
+var require_move_sync2 = __commonJS({
+  "../node_modules/fs-extra/lib/move-sync/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = require("path");
+    var copy = require_copy2().copy;
+    var remove = require_remove().remove;
+    var mkdirp = require_mkdirs().mkdirp;
+    var pathExists = require_path_exists().pathExists;
+    var stat = require_stat();
+    function move(src, dest, opts, cb) {
+      if (typeof opts === "function") {
+        cb = opts;
+        opts = {};
+      }
+      const overwrite = opts.overwrite || opts.clobber || false;
+      stat.checkPaths(src, dest, "move", (err, stats) => {
+        if (err) return cb(err);
+        const { srcStat } = stats;
+        stat.checkParentPaths(src, srcStat, dest, "move", (err2) => {
+          if (err2) return cb(err2);
+          mkdirp(path2.dirname(dest), (err3) => {
+            if (err3) return cb(err3);
+            return doRename(src, dest, overwrite, cb);
+          });
+        });
+      });
+    }
+    function doRename(src, dest, overwrite, cb) {
+      if (overwrite) {
+        return remove(dest, (err) => {
+          if (err) return cb(err);
+          return rename(src, dest, overwrite, cb);
+        });
+      }
+      pathExists(dest, (err, destExists) => {
+        if (err) return cb(err);
+        if (destExists) return cb(new Error("dest already exists."));
+        return rename(src, dest, overwrite, cb);
+      });
+    }
+    function rename(src, dest, overwrite, cb) {
+      fs2.rename(src, dest, (err) => {
+        if (!err) return cb();
+        if (err.code !== "EXDEV") return cb(err);
+        return moveAcrossDevice(src, dest, overwrite, cb);
+      });
+    }
+    function moveAcrossDevice(src, dest, overwrite, cb) {
+      const opts = {
+        overwrite,
+        errorOnExist: true
+      };
+      copy(src, dest, opts, (err) => {
+        if (err) return cb(err);
+        return remove(src, cb);
+      });
+    }
+    module2.exports = move;
+  }
+});
+
+// ../node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      move: u(require_move())
+    };
+  }
+});
+
+// ../node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy_sync2(),
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move_sync2(),
+      ...require_move2(),
+      ...require_output(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+    var fs2 = require("fs");
+    if (Object.getOwnPropertyDescriptor(fs2, "promises")) {
+      Object.defineProperty(module2.exports, "promises", {
+        get() {
+          return fs2.promises;
+        }
+      });
+    }
+  }
+});
+
+// scripts/check-locales.mts
+var check_locales_exports = {};
+__export(check_locales_exports, {
+  checkLocales: () => checkLocales,
+  compareLocales: () => compareLocales
+});
+module.exports = __toCommonJS(check_locales_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_fs_extra = __toESM(require_lib(), 1);
+
+// ../node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../node_modules/chalk/source/vendor/supports-color/index.js
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_tty = __toESM(require("node:tty"), 1);
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// ../node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// scripts/check-locales.mts
+var import_node_url = require("node:url");
+var import_meta = {};
+var __filename;
+var __dirname;
+try {
+  __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+  __dirname = (0, import_node_path.dirname)(__filename);
+} catch {
+}
+function getAllKeys(obj, prefix = "") {
+  return Object.entries(obj).reduce((keys, [key, value]) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return [...keys, ...getAllKeys(value, newKey)];
+    }
+    return [...keys, newKey];
+  }, []);
+}
+function compareLocales(baseLocale, compareLocale) {
+  const base = JSON.parse(import_fs_extra.default.readFileSync(baseLocale, "utf-8"));
+  const compare = JSON.parse(import_fs_extra.default.readFileSync(compareLocale, "utf-8"));
+  const baseKeys = new Set(getAllKeys(base));
+  const compareKeys = new Set(getAllKeys(compare));
+  const missing = [...baseKeys].filter((key) => !compareKeys.has(key));
+  const extra = [...compareKeys].filter((key) => !baseKeys.has(key));
+  return { missing, extra };
+}
+async function checkLocales() {
+  const localesDir = import_node_path.default.join(__dirname, "../locales");
+  const files = import_fs_extra.default.readdirSync(localesDir).filter((file) => file.endsWith(".json"));
+  const baseLocale = import_node_path.default.join(localesDir, "en.json");
+  if (!files.includes("en.json")) {
+    console.log(source_default.red("\n\u274C Base locale (en.json) not found!"));
+    return false;
+  }
+  const results = [];
+  let hasErrors = false;
+  console.log(source_default.cyan("Checking localizations against en.json...\n"));
+  for (const file of files) {
+    if (file === "en.json") continue;
+    const compareLocale = import_node_path.default.join(localesDir, file);
+    const { missing, extra } = compareLocales(baseLocale, compareLocale);
+    if (missing.length > 0 || extra.length > 0) {
+      hasErrors = true;
+      results.push({
+        locale: file,
+        missing,
+        extra
+      });
+    }
+  }
+  if (results.length > 0) {
+    console.log(source_default.yellow("Found differences in localizations:\n"));
+    for (const result of results) {
+      console.log(source_default.bold(`
+${result.locale}:`));
+      if (result.missing.length > 0) {
+        console.log(source_default.red("\nMissing keys:"));
+        console.log(result.missing.join(", "));
+      }
+      if (result.extra.length > 0) {
+        console.log(source_default.yellow("\nExtra keys:"));
+        console.log(result.extra.join(", "));
+      }
+      console.log();
+    }
+    console.log(source_default.red("\n\u274C Localization check failed. Please fix the issues above.\n"));
+    return false;
+  }
+  console.log(source_default.green("\u2713 All localizations are in sync with en.json!\n"));
+  return true;
+}
+async function cli() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    const success = await checkLocales();
+    process.exit(success ? 0 : 1);
+  }
+  const userFile = args[0];
+  if (!import_fs_extra.default.existsSync(userFile)) {
+    console.log(source_default.red(`
+File not found: ${userFile}`));
+    process.exit(1);
+  }
+  const candidates = [
+    import_node_path.default.join(__dirname, "../locales/en.json"),
+    // source (when running via tsx in dev)
+    import_node_path.default.join(__dirname, "../dist/locales/en.json"),
+    // fallback
+    import_node_path.default.join(__dirname, "../locales/en.json")
+    // when bundled as dist/scripts/ → ../locales/
+  ];
+  const resolvedBaseline = candidates.find((p) => import_fs_extra.default.existsSync(p));
+  if (!resolvedBaseline) {
+    console.log(source_default.red("\nCould not find framework baseline locale (en.json)"));
+    process.exit(1);
+  }
+  console.log(source_default.cyan(`Checking ${import_node_path.default.basename(userFile)} against framework baseline...
+`));
+  const { missing, extra } = compareLocales(resolvedBaseline, import_node_path.default.resolve(userFile));
+  if (missing.length > 0) {
+    console.log(source_default.red(`Missing keys (${missing.length}):`));
+    console.log(missing.join("\n"));
+    console.log();
+  }
+  if (extra.length > 0) {
+    console.log(source_default.yellow(`Extra keys (${extra.length}):`));
+    console.log(extra.join("\n"));
+    console.log();
+  }
+  if (missing.length === 0 && extra.length === 0) {
+    console.log(source_default.green(`\u2713 ${import_node_path.default.basename(userFile)} is complete \u2014 all keys match the framework baseline.`));
+    process.exit(0);
+  } else {
+    console.log(source_default.red(`\u2717 Found ${missing.length} missing and ${extra.length} extra keys.`));
+    process.exit(1);
+  }
+}
+if (process.argv[1] === __filename || process.argv[1]?.endsWith("/vc-check-locales")) {
+  cli();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkLocales,
+  compareLocales
+});