@prisma/migrate 7.1.0-integration-fix-fix-missing-cockroach-wasm.1 → 7.1.0

package/dist/chunk-AFQKSVOE.js

@@ -0,0 +1,3448 @@
+"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 __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);
+var chunk_AFQKSVOE_exports = {};
+__export(chunk_AFQKSVOE_exports, {
+  MigrateDiff: () => MigrateDiff,
+  getRemovedTargetParameterHint: () => getRemovedTargetParameterHint
+});
+module.exports = __toCommonJS(chunk_AFQKSVOE_exports);
+var import_chunk_VAJ4VX67 = require("./chunk-VAJ4VX67.js");
+var import_chunk_WRBJ3RMF = require("./chunk-WRBJ3RMF.js");
+var import_chunk_GGA2F64G = require("./chunk-GGA2F64G.js");
+var import_chunk_SKRR5WT4 = require("./chunk-SKRR5WT4.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+var import_debug = __toESM(require("@prisma/debug"));
+var import_internals = require("@prisma/internals");
+var import_path = __toESM(require("path"));
+var require_promisify = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/promisify.js"(exports, module2) {
+    "use strict";
+    module2.exports = (fn) => {
+      return function() {
+        const length = arguments.length;
+        const args = new Array(length);
+        for (let i = 0; i < length; i += 1) {
+          args[i] = arguments[i];
+        }
+        return new Promise((resolve, reject) => {
+          args.push((err, data) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(data);
+            }
+          });
+          fn.apply(null, args);
+        });
+      };
+    };
+  }
+});
+var require_fs = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/fs.js"(exports, module2) {
+    "use strict";
+    var fs2 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    var promisify = require_promisify();
+    var isCallbackMethod = (key) => {
+      return [
+        typeof fs2[key] === "function",
+        !key.match(/Sync$/),
+        !key.match(/^[A-Z]/),
+        !key.match(/^create/),
+        !key.match(/^(un)?watch/)
+      ].every(Boolean);
+    };
+    var adaptMethod = (name) => {
+      const original = fs2[name];
+      return promisify(original);
+    };
+    var adaptAllMethods = () => {
+      const adapted = {};
+      Object.keys(fs2).forEach((key) => {
+        if (isCallbackMethod(key)) {
+          if (key === "exists") {
+            adapted.exists = () => {
+              throw new Error("fs.exists() is deprecated");
+            };
+          } else {
+            adapted[key] = adaptMethod(key);
+          }
+        } else {
+          adapted[key] = fs2[key];
+        }
+      });
+      return adapted;
+    };
+    module2.exports = adaptAllMethods();
+  }
+});
+var require_validate = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/validate.js"(exports, module2) {
+    "use strict";
+    var prettyPrintTypes = (types) => {
+      const addArticle = (str) => {
+        const vowels = ["a", "e", "i", "o", "u"];
+        if (vowels.indexOf(str[0]) !== -1) {
+          return `an ${str}`;
+        }
+        return `a ${str}`;
+      };
+      return types.map(addArticle).join(" or ");
+    };
+    var isArrayOfNotation = (typeDefinition) => {
+      return /array of /.test(typeDefinition);
+    };
+    var extractTypeFromArrayOfNotation = (typeDefinition) => {
+      return typeDefinition.split(" of ")[1];
+    };
+    var isValidTypeDefinition = (typeStr) => {
+      if (isArrayOfNotation(typeStr)) {
+        return isValidTypeDefinition(extractTypeFromArrayOfNotation(typeStr));
+      }
+      return [
+        "string",
+        "number",
+        "boolean",
+        "array",
+        "object",
+        "buffer",
+        "null",
+        "undefined",
+        "function"
+      ].some((validType) => {
+        return validType === typeStr;
+      });
+    };
+    var detectType = (value) => {
+      if (value === null) {
+        return "null";
+      }
+      if (Array.isArray(value)) {
+        return "array";
+      }
+      if (Buffer.isBuffer(value)) {
+        return "buffer";
+      }
+      return typeof value;
+    };
+    var onlyUniqueValuesInArrayFilter = (value, index, self) => {
+      return self.indexOf(value) === index;
+    };
+    var detectTypeDeep = (value) => {
+      let type = detectType(value);
+      let typesInArray;
+      if (type === "array") {
+        typesInArray = value.map((element) => {
+          return detectType(element);
+        }).filter(onlyUniqueValuesInArrayFilter);
+        type += ` of ${typesInArray.join(", ")}`;
+      }
+      return type;
+    };
+    var validateArray = (argumentValue, typeToCheck) => {
+      const allowedTypeInArray = extractTypeFromArrayOfNotation(typeToCheck);
+      if (detectType(argumentValue) !== "array") {
+        return false;
+      }
+      return argumentValue.every((element) => {
+        return detectType(element) === allowedTypeInArray;
+      });
+    };
+    var validateArgument = (methodName, argumentName, argumentValue, argumentMustBe) => {
+      const isOneOfAllowedTypes = argumentMustBe.some((type) => {
+        if (!isValidTypeDefinition(type)) {
+          throw new Error(`Unknown type "${type}"`);
+        }
+        if (isArrayOfNotation(type)) {
+          return validateArray(argumentValue, type);
+        }
+        return type === detectType(argumentValue);
+      });
+      if (!isOneOfAllowedTypes) {
+        throw new Error(
+          `Argument "${argumentName}" passed to ${methodName} must be ${prettyPrintTypes(
+            argumentMustBe
+          )}. Received ${detectTypeDeep(argumentValue)}`
+        );
+      }
+    };
+    var validateOptions = (methodName, optionsObjName, obj, allowedOptions) => {
+      if (obj !== void 0) {
+        validateArgument(methodName, optionsObjName, obj, ["object"]);
+        Object.keys(obj).forEach((key) => {
+          const argName = `${optionsObjName}.${key}`;
+          if (allowedOptions[key] !== void 0) {
+            validateArgument(methodName, argName, obj[key], allowedOptions[key]);
+          } else {
+            throw new Error(
+              `Unknown argument "${argName}" passed to ${methodName}`
+            );
+          }
+        });
+      }
+    };
+    module2.exports = {
+      argument: validateArgument,
+      options: validateOptions
+    };
+  }
+});
+var require_mode = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/mode.js"(exports) {
+    "use strict";
+    exports.normalizeFileMode = (mode) => {
+      let modeAsString;
+      if (typeof mode === "number") {
+        modeAsString = mode.toString(8);
+      } else {
+        modeAsString = mode;
+      }
+      return modeAsString.substring(modeAsString.length - 3);
+    };
+  }
+});
+var require_remove = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/remove.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var validateInput = (methodName, path2) => {
+      const methodSignature = `${methodName}([path])`;
+      validate.argument(methodSignature, "path", path2, ["string", "undefined"]);
+    };
+    var removeSync = (path2) => {
+      fs2.rmSync(path2, {
+        recursive: true,
+        force: true,
+        maxRetries: 3
+      });
+    };
+    var removeAsync = (path2) => {
+      return fs2.rm(path2, {
+        recursive: true,
+        force: true,
+        maxRetries: 3
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = removeSync;
+    exports.async = removeAsync;
+  }
+});
+var require_dir = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/dir.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var modeUtil = require_mode();
+    var validate = require_validate();
+    var remove = require_remove();
+    var validateInput = (methodName, path2, criteria) => {
+      const methodSignature = `${methodName}(path, [criteria])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.options(methodSignature, "criteria", criteria, {
+        empty: ["boolean"],
+        mode: ["string", "number"]
+      });
+    };
+    var getCriteriaDefaults = (passedCriteria) => {
+      const criteria = passedCriteria || {};
+      if (typeof criteria.empty !== "boolean") {
+        criteria.empty = false;
+      }
+      if (criteria.mode !== void 0) {
+        criteria.mode = modeUtil.normalizeFileMode(criteria.mode);
+      }
+      return criteria;
+    };
+    var generatePathOccupiedByNotDirectoryError = (path2) => {
+      return new Error(
+        `Path ${path2} exists but is not a directory. Halting jetpack.dir() call for safety reasons.`
+      );
+    };
+    var checkWhatAlreadyOccupiesPathSync = (path2) => {
+      let stat;
+      try {
+        stat = fs2.statSync(path2);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      if (stat && !stat.isDirectory()) {
+        throw generatePathOccupiedByNotDirectoryError(path2);
+      }
+      return stat;
+    };
+    var createBrandNewDirectorySync = (path2, opts) => {
+      const options = opts || {};
+      try {
+        fs2.mkdirSync(path2, options.mode);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          createBrandNewDirectorySync(pathUtil.dirname(path2), options);
+          fs2.mkdirSync(path2, options.mode);
+        } else if (err.code === "EEXIST") {
+        } else {
+          throw err;
+        }
+      }
+    };
+    var checkExistingDirectoryFulfillsCriteriaSync = (path2, stat, criteria) => {
+      const checkMode = () => {
+        const mode = modeUtil.normalizeFileMode(stat.mode);
+        if (criteria.mode !== void 0 && criteria.mode !== mode) {
+          fs2.chmodSync(path2, criteria.mode);
+        }
+      };
+      const checkEmptiness = () => {
+        if (criteria.empty) {
+          const list = fs2.readdirSync(path2);
+          list.forEach((filename) => {
+            remove.sync(pathUtil.resolve(path2, filename));
+          });
+        }
+      };
+      checkMode();
+      checkEmptiness();
+    };
+    var dirSync = (path2, passedCriteria) => {
+      const criteria = getCriteriaDefaults(passedCriteria);
+      const stat = checkWhatAlreadyOccupiesPathSync(path2);
+      if (stat) {
+        checkExistingDirectoryFulfillsCriteriaSync(path2, stat, criteria);
+      } else {
+        createBrandNewDirectorySync(path2, criteria);
+      }
+    };
+    var checkWhatAlreadyOccupiesPathAsync = (path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.stat(path2).then((stat) => {
+          if (stat.isDirectory()) {
+            resolve(stat);
+          } else {
+            reject(generatePathOccupiedByNotDirectoryError(path2));
+          }
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(void 0);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    var emptyAsync = (path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.readdir(path2).then((list) => {
+          const doOne = (index) => {
+            if (index === list.length) {
+              resolve();
+            } else {
+              const subPath = pathUtil.resolve(path2, list[index]);
+              remove.async(subPath).then(() => {
+                doOne(index + 1);
+              });
+            }
+          };
+          doOne(0);
+        }).catch(reject);
+      });
+    };
+    var checkExistingDirectoryFulfillsCriteriaAsync = (path2, stat, criteria) => {
+      return new Promise((resolve, reject) => {
+        const checkMode = () => {
+          const mode = modeUtil.normalizeFileMode(stat.mode);
+          if (criteria.mode !== void 0 && criteria.mode !== mode) {
+            return fs2.chmod(path2, criteria.mode);
+          }
+          return Promise.resolve();
+        };
+        const checkEmptiness = () => {
+          if (criteria.empty) {
+            return emptyAsync(path2);
+          }
+          return Promise.resolve();
+        };
+        checkMode().then(checkEmptiness).then(resolve, reject);
+      });
+    };
+    var createBrandNewDirectoryAsync = (path2, opts) => {
+      const options = opts || {};
+      return new Promise((resolve, reject) => {
+        fs2.mkdir(path2, options.mode).then(resolve).catch((err) => {
+          if (err.code === "ENOENT") {
+            createBrandNewDirectoryAsync(pathUtil.dirname(path2), options).then(() => {
+              return fs2.mkdir(path2, options.mode);
+            }).then(resolve).catch((err2) => {
+              if (err2.code === "EEXIST") {
+                resolve();
+              } else {
+                reject(err2);
+              }
+            });
+          } else if (err.code === "EEXIST") {
+            resolve();
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    var dirAsync = (path2, passedCriteria) => {
+      return new Promise((resolve, reject) => {
+        const criteria = getCriteriaDefaults(passedCriteria);
+        checkWhatAlreadyOccupiesPathAsync(path2).then((stat) => {
+          if (stat !== void 0) {
+            return checkExistingDirectoryFulfillsCriteriaAsync(
+              path2,
+              stat,
+              criteria
+            );
+          }
+          return createBrandNewDirectoryAsync(path2, criteria);
+        }).then(resolve, reject);
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = dirSync;
+    exports.createSync = createBrandNewDirectorySync;
+    exports.async = dirAsync;
+    exports.createAsync = createBrandNewDirectoryAsync;
+  }
+});
+var require_write = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/write.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var dir = require_dir();
+    var validateInput = (methodName, path2, data, options) => {
+      const methodSignature = `${methodName}(path, data, [options])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.argument(methodSignature, "data", data, [
+        "string",
+        "buffer",
+        "object",
+        "array"
+      ]);
+      validate.options(methodSignature, "options", options, {
+        mode: ["string", "number"],
+        atomic: ["boolean"],
+        jsonIndent: ["number"]
+      });
+    };
+    var newExt = ".__new__";
+    var serializeToJsonMaybe = (data, jsonIndent) => {
+      let indent = jsonIndent;
+      if (typeof indent !== "number") {
+        indent = 2;
+      }
+      if (typeof data === "object" && !Buffer.isBuffer(data) && data !== null) {
+        return JSON.stringify(data, null, indent);
+      }
+      return data;
+    };
+    var writeFileSync = (path2, data, options) => {
+      try {
+        fs2.writeFileSync(path2, data, options);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          dir.createSync(pathUtil.dirname(path2));
+          fs2.writeFileSync(path2, data, options);
+        } else {
+          throw err;
+        }
+      }
+    };
+    var writeAtomicSync = (path2, data, options) => {
+      writeFileSync(path2 + newExt, data, options);
+      fs2.renameSync(path2 + newExt, path2);
+    };
+    var writeSync = (path2, data, options) => {
+      const opts = options || {};
+      const processedData = serializeToJsonMaybe(data, opts.jsonIndent);
+      let writeStrategy = writeFileSync;
+      if (opts.atomic) {
+        writeStrategy = writeAtomicSync;
+      }
+      writeStrategy(path2, processedData, { mode: opts.mode });
+    };
+    var writeFileAsync = (path2, data, options) => {
+      return new Promise((resolve, reject) => {
+        fs2.writeFile(path2, data, options).then(resolve).catch((err) => {
+          if (err.code === "ENOENT") {
+            dir.createAsync(pathUtil.dirname(path2)).then(() => {
+              return fs2.writeFile(path2, data, options);
+            }).then(resolve, reject);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    var writeAtomicAsync = (path2, data, options) => {
+      return new Promise((resolve, reject) => {
+        writeFileAsync(path2 + newExt, data, options).then(() => {
+          return fs2.rename(path2 + newExt, path2);
+        }).then(resolve, reject);
+      });
+    };
+    var writeAsync = (path2, data, options) => {
+      const opts = options || {};
+      const processedData = serializeToJsonMaybe(data, opts.jsonIndent);
+      let writeStrategy = writeFileAsync;
+      if (opts.atomic) {
+        writeStrategy = writeAtomicAsync;
+      }
+      return writeStrategy(path2, processedData, { mode: opts.mode });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = writeSync;
+    exports.async = writeAsync;
+  }
+});
+var require_append = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/append.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var write = require_write();
+    var validate = require_validate();
+    var validateInput = (methodName, path2, data, options) => {
+      const methodSignature = `${methodName}(path, data, [options])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.argument(methodSignature, "data", data, ["string", "buffer"]);
+      validate.options(methodSignature, "options", options, {
+        mode: ["string", "number"]
+      });
+    };
+    var appendSync = (path2, data, options) => {
+      try {
+        fs2.appendFileSync(path2, data, options);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          write.sync(path2, data, options);
+        } else {
+          throw err;
+        }
+      }
+    };
+    var appendAsync = (path2, data, options) => {
+      return new Promise((resolve, reject) => {
+        fs2.appendFile(path2, data, options).then(resolve).catch((err) => {
+          if (err.code === "ENOENT") {
+            write.async(path2, data, options).then(resolve, reject);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = appendSync;
+    exports.async = appendAsync;
+  }
+});
+var require_file = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/file.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var modeUtil = require_mode();
+    var validate = require_validate();
+    var write = require_write();
+    var validateInput = (methodName, path2, criteria) => {
+      const methodSignature = `${methodName}(path, [criteria])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.options(methodSignature, "criteria", criteria, {
+        content: ["string", "buffer", "object", "array"],
+        jsonIndent: ["number"],
+        mode: ["string", "number"]
+      });
+    };
+    var getCriteriaDefaults = (passedCriteria) => {
+      const criteria = passedCriteria || {};
+      if (criteria.mode !== void 0) {
+        criteria.mode = modeUtil.normalizeFileMode(criteria.mode);
+      }
+      return criteria;
+    };
+    var generatePathOccupiedByNotFileError = (path2) => {
+      return new Error(
+        `Path ${path2} exists but is not a file. Halting jetpack.file() call for safety reasons.`
+      );
+    };
+    var checkWhatAlreadyOccupiesPathSync = (path2) => {
+      let stat;
+      try {
+        stat = fs2.statSync(path2);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      if (stat && !stat.isFile()) {
+        throw generatePathOccupiedByNotFileError(path2);
+      }
+      return stat;
+    };
+    var checkExistingFileFulfillsCriteriaSync = (path2, stat, criteria) => {
+      const mode = modeUtil.normalizeFileMode(stat.mode);
+      const checkContent = () => {
+        if (criteria.content !== void 0) {
+          write.sync(path2, criteria.content, {
+            mode,
+            jsonIndent: criteria.jsonIndent
+          });
+          return true;
+        }
+        return false;
+      };
+      const checkMode = () => {
+        if (criteria.mode !== void 0 && criteria.mode !== mode) {
+          fs2.chmodSync(path2, criteria.mode);
+        }
+      };
+      const contentReplaced = checkContent();
+      if (!contentReplaced) {
+        checkMode();
+      }
+    };
+    var createBrandNewFileSync = (path2, criteria) => {
+      let content = "";
+      if (criteria.content !== void 0) {
+        content = criteria.content;
+      }
+      write.sync(path2, content, {
+        mode: criteria.mode,
+        jsonIndent: criteria.jsonIndent
+      });
+    };
+    var fileSync = (path2, passedCriteria) => {
+      const criteria = getCriteriaDefaults(passedCriteria);
+      const stat = checkWhatAlreadyOccupiesPathSync(path2);
+      if (stat !== void 0) {
+        checkExistingFileFulfillsCriteriaSync(path2, stat, criteria);
+      } else {
+        createBrandNewFileSync(path2, criteria);
+      }
+    };
+    var checkWhatAlreadyOccupiesPathAsync = (path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.stat(path2).then((stat) => {
+          if (stat.isFile()) {
+            resolve(stat);
+          } else {
+            reject(generatePathOccupiedByNotFileError(path2));
+          }
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(void 0);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    var checkExistingFileFulfillsCriteriaAsync = (path2, stat, criteria) => {
+      const mode = modeUtil.normalizeFileMode(stat.mode);
+      const checkContent = () => {
+        return new Promise((resolve, reject) => {
+          if (criteria.content !== void 0) {
+            write.async(path2, criteria.content, {
+              mode,
+              jsonIndent: criteria.jsonIndent
+            }).then(() => {
+              resolve(true);
+            }).catch(reject);
+          } else {
+            resolve(false);
+          }
+        });
+      };
+      const checkMode = () => {
+        if (criteria.mode !== void 0 && criteria.mode !== mode) {
+          return fs2.chmod(path2, criteria.mode);
+        }
+        return void 0;
+      };
+      return checkContent().then((contentReplaced) => {
+        if (!contentReplaced) {
+          return checkMode();
+        }
+        return void 0;
+      });
+    };
+    var createBrandNewFileAsync = (path2, criteria) => {
+      let content = "";
+      if (criteria.content !== void 0) {
+        content = criteria.content;
+      }
+      return write.async(path2, content, {
+        mode: criteria.mode,
+        jsonIndent: criteria.jsonIndent
+      });
+    };
+    var fileAsync = (path2, passedCriteria) => {
+      return new Promise((resolve, reject) => {
+        const criteria = getCriteriaDefaults(passedCriteria);
+        checkWhatAlreadyOccupiesPathAsync(path2).then((stat) => {
+          if (stat !== void 0) {
+            return checkExistingFileFulfillsCriteriaAsync(path2, stat, criteria);
+          }
+          return createBrandNewFileAsync(path2, criteria);
+        }).then(resolve, reject);
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = fileSync;
+    exports.async = fileAsync;
+  }
+});
+var require_inspect = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/inspect.js"(exports) {
+    "use strict";
+    var crypto = (0, import_chunk_2ESYSVXG.__require)("crypto");
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var supportedChecksumAlgorithms = ["md5", "sha1", "sha256", "sha512"];
+    var symlinkOptions = ["report", "follow"];
+    var validateInput = (methodName, path2, options) => {
+      const methodSignature = `${methodName}(path, [options])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        checksum: ["string"],
+        mode: ["boolean"],
+        times: ["boolean"],
+        absolutePath: ["boolean"],
+        symlinks: ["string"]
+      });
+      if (options && options.checksum !== void 0 && supportedChecksumAlgorithms.indexOf(options.checksum) === -1) {
+        throw new Error(
+          `Argument "options.checksum" passed to ${methodSignature} must have one of values: ${supportedChecksumAlgorithms.join(
+            ", "
+          )}`
+        );
+      }
+      if (options && options.symlinks !== void 0 && symlinkOptions.indexOf(options.symlinks) === -1) {
+        throw new Error(
+          `Argument "options.symlinks" passed to ${methodSignature} must have one of values: ${symlinkOptions.join(
+            ", "
+          )}`
+        );
+      }
+    };
+    var createInspectObj = (path2, options, stat) => {
+      const obj = {};
+      obj.name = pathUtil.basename(path2);
+      if (stat.isFile()) {
+        obj.type = "file";
+        obj.size = stat.size;
+      } else if (stat.isDirectory()) {
+        obj.type = "dir";
+      } else if (stat.isSymbolicLink()) {
+        obj.type = "symlink";
+      } else {
+        obj.type = "other";
+      }
+      if (options.mode) {
+        obj.mode = stat.mode;
+      }
+      if (options.times) {
+        obj.accessTime = stat.atime;
+        obj.modifyTime = stat.mtime;
+        obj.changeTime = stat.ctime;
+        obj.birthTime = stat.birthtime;
+      }
+      if (options.absolutePath) {
+        obj.absolutePath = path2;
+      }
+      return obj;
+    };
+    var fileChecksum = (path2, algo) => {
+      const hash = crypto.createHash(algo);
+      const data = fs2.readFileSync(path2);
+      hash.update(data);
+      return hash.digest("hex");
+    };
+    var addExtraFieldsSync = (path2, inspectObj, options) => {
+      if (inspectObj.type === "file" && options.checksum) {
+        inspectObj[options.checksum] = fileChecksum(path2, options.checksum);
+      } else if (inspectObj.type === "symlink") {
+        inspectObj.pointsAt = fs2.readlinkSync(path2);
+      }
+    };
+    var inspectSync = (path2, options) => {
+      let statOperation = fs2.lstatSync;
+      let stat;
+      const opts = options || {};
+      if (opts.symlinks === "follow") {
+        statOperation = fs2.statSync;
+      }
+      try {
+        stat = statOperation(path2);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return void 0;
+        }
+        throw err;
+      }
+      const inspectObj = createInspectObj(path2, opts, stat);
+      addExtraFieldsSync(path2, inspectObj, opts);
+      return inspectObj;
+    };
+    var fileChecksumAsync = (path2, algo) => {
+      return new Promise((resolve, reject) => {
+        const hash = crypto.createHash(algo);
+        const s = fs2.createReadStream(path2);
+        s.on("data", (data) => {
+          hash.update(data);
+        });
+        s.on("end", () => {
+          resolve(hash.digest("hex"));
+        });
+        s.on("error", reject);
+      });
+    };
+    var addExtraFieldsAsync = (path2, inspectObj, options) => {
+      if (inspectObj.type === "file" && options.checksum) {
+        return fileChecksumAsync(path2, options.checksum).then((checksum) => {
+          inspectObj[options.checksum] = checksum;
+          return inspectObj;
+        });
+      } else if (inspectObj.type === "symlink") {
+        return fs2.readlink(path2).then((linkPath) => {
+          inspectObj.pointsAt = linkPath;
+          return inspectObj;
+        });
+      }
+      return Promise.resolve(inspectObj);
+    };
+    var inspectAsync = (path2, options) => {
+      return new Promise((resolve, reject) => {
+        let statOperation = fs2.lstat;
+        const opts = options || {};
+        if (opts.symlinks === "follow") {
+          statOperation = fs2.stat;
+        }
+        statOperation(path2).then((stat) => {
+          const inspectObj = createInspectObj(path2, opts, stat);
+          addExtraFieldsAsync(path2, inspectObj, opts).then(resolve, reject);
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(void 0);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.supportedChecksumAlgorithms = supportedChecksumAlgorithms;
+    exports.symlinkOptions = symlinkOptions;
+    exports.validateInput = validateInput;
+    exports.sync = inspectSync;
+    exports.async = inspectAsync;
+  }
+});
+var require_list = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/list.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var validateInput = (methodName, path2) => {
+      const methodSignature = `${methodName}(path)`;
+      validate.argument(methodSignature, "path", path2, ["string", "undefined"]);
+    };
+    var listSync = (path2) => {
+      try {
+        return fs2.readdirSync(path2);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return void 0;
+        }
+        throw err;
+      }
+    };
+    var listAsync = (path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.readdir(path2).then((list) => {
+          resolve(list);
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(void 0);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = listSync;
+    exports.async = listAsync;
+  }
+});
+var require_tree_walker = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/tree_walker.js"(exports) {
+    "use strict";
+    var fs2 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var inspect = require_inspect();
+    var list = require_list();
+    var fileType = (dirent) => {
+      if (dirent.isDirectory()) {
+        return "dir";
+      }
+      if (dirent.isFile()) {
+        return "file";
+      }
+      if (dirent.isSymbolicLink()) {
+        return "symlink";
+      }
+      return "other";
+    };
+    var initialWalkSync = (path2, options, callback) => {
+      if (options.maxLevelsDeep === void 0) {
+        options.maxLevelsDeep = Infinity;
+      }
+      const performInspectOnEachNode = options.inspectOptions !== void 0;
+      if (options.symlinks) {
+        if (options.inspectOptions === void 0) {
+          options.inspectOptions = { symlinks: options.symlinks };
+        } else {
+          options.inspectOptions.symlinks = options.symlinks;
+        }
+      }
+      const walkSync = (path3, currentLevel) => {
+        fs2.readdirSync(path3, { withFileTypes: true }).forEach((direntItem) => {
+          const withFileTypesNotSupported = typeof direntItem === "string";
+          let fileItemPath;
+          if (withFileTypesNotSupported) {
+            fileItemPath = pathUtil.join(path3, direntItem);
+          } else {
+            fileItemPath = pathUtil.join(path3, direntItem.name);
+          }
+          let fileItem;
+          if (performInspectOnEachNode) {
+            fileItem = inspect.sync(fileItemPath, options.inspectOptions);
+          } else if (withFileTypesNotSupported) {
+            const inspectObject = inspect.sync(
+              fileItemPath,
+              options.inspectOptions
+            );
+            fileItem = { name: inspectObject.name, type: inspectObject.type };
+          } else {
+            const type = fileType(direntItem);
+            if (type === "symlink" && options.symlinks === "follow") {
+              const symlinkPointsTo = fs2.statSync(fileItemPath);
+              fileItem = { name: direntItem.name, type: fileType(symlinkPointsTo) };
+            } else {
+              fileItem = { name: direntItem.name, type };
+            }
+          }
+          if (fileItem !== void 0) {
+            callback(fileItemPath, fileItem);
+            if (fileItem.type === "dir" && currentLevel < options.maxLevelsDeep) {
+              walkSync(fileItemPath, currentLevel + 1);
+            }
+          }
+        });
+      };
+      const item = inspect.sync(path2, options.inspectOptions);
+      if (item) {
+        if (performInspectOnEachNode) {
+          callback(path2, item);
+        } else {
+          callback(path2, { name: item.name, type: item.type });
+        }
+        if (item.type === "dir") {
+          walkSync(path2, 1);
+        }
+      } else {
+        callback(path2, void 0);
+      }
+    };
+    var maxConcurrentOperations = 5;
+    var initialWalkAsync = (path2, options, callback, doneCallback) => {
+      if (options.maxLevelsDeep === void 0) {
+        options.maxLevelsDeep = Infinity;
+      }
+      const performInspectOnEachNode = options.inspectOptions !== void 0;
+      if (options.symlinks) {
+        if (options.inspectOptions === void 0) {
+          options.inspectOptions = { symlinks: options.symlinks };
+        } else {
+          options.inspectOptions.symlinks = options.symlinks;
+        }
+      }
+      const concurrentOperationsQueue = [];
+      let nowDoingConcurrentOperations = 0;
+      const checkConcurrentOperations = () => {
+        if (concurrentOperationsQueue.length === 0 && nowDoingConcurrentOperations === 0) {
+          doneCallback();
+        } else if (concurrentOperationsQueue.length > 0 && nowDoingConcurrentOperations < maxConcurrentOperations) {
+          const operation = concurrentOperationsQueue.pop();
+          nowDoingConcurrentOperations += 1;
+          operation();
+        }
+      };
+      const whenConcurrencySlotAvailable = (operation) => {
+        concurrentOperationsQueue.push(operation);
+        checkConcurrentOperations();
+      };
+      const concurrentOperationDone = () => {
+        nowDoingConcurrentOperations -= 1;
+        checkConcurrentOperations();
+      };
+      const walkAsync = (path3, currentLevel) => {
+        const goDeeperIfDir = (fileItemPath, fileItem) => {
+          if (fileItem.type === "dir" && currentLevel < options.maxLevelsDeep) {
+            walkAsync(fileItemPath, currentLevel + 1);
+          }
+        };
+        whenConcurrencySlotAvailable(() => {
+          fs2.readdir(path3, { withFileTypes: true }, (err, files) => {
+            if (err) {
+              doneCallback(err);
+            } else {
+              files.forEach((direntItem) => {
+                const withFileTypesNotSupported = typeof direntItem === "string";
+                let fileItemPath;
+                if (withFileTypesNotSupported) {
+                  fileItemPath = pathUtil.join(path3, direntItem);
+                } else {
+                  fileItemPath = pathUtil.join(path3, direntItem.name);
+                }
+                if (performInspectOnEachNode || withFileTypesNotSupported) {
+                  whenConcurrencySlotAvailable(() => {
+                    inspect.async(fileItemPath, options.inspectOptions).then((fileItem) => {
+                      if (fileItem !== void 0) {
+                        if (performInspectOnEachNode) {
+                          callback(fileItemPath, fileItem);
+                        } else {
+                          callback(fileItemPath, {
+                            name: fileItem.name,
+                            type: fileItem.type
+                          });
+                        }
+                        goDeeperIfDir(fileItemPath, fileItem);
+                      }
+                      concurrentOperationDone();
+                    }).catch((err2) => {
+                      doneCallback(err2);
+                    });
+                  });
+                } else {
+                  const type = fileType(direntItem);
+                  if (type === "symlink" && options.symlinks === "follow") {
+                    whenConcurrencySlotAvailable(() => {
+                      fs2.stat(fileItemPath, (err2, symlinkPointsTo) => {
+                        if (err2) {
+                          doneCallback(err2);
+                        } else {
+                          const fileItem = {
+                            name: direntItem.name,
+                            type: fileType(symlinkPointsTo)
+                          };
+                          callback(fileItemPath, fileItem);
+                          goDeeperIfDir(fileItemPath, fileItem);
+                          concurrentOperationDone();
+                        }
+                      });
+                    });
+                  } else {
+                    const fileItem = { name: direntItem.name, type };
+                    callback(fileItemPath, fileItem);
+                    goDeeperIfDir(fileItemPath, fileItem);
+                  }
+                }
+              });
+              concurrentOperationDone();
+            }
+          });
+        });
+      };
+      inspect.async(path2, options.inspectOptions).then((item) => {
+        if (item) {
+          if (performInspectOnEachNode) {
+            callback(path2, item);
+          } else {
+            callback(path2, { name: item.name, type: item.type });
+          }
+          if (item.type === "dir") {
+            walkAsync(path2, 1);
+          } else {
+            doneCallback();
+          }
+        } else {
+          callback(path2, void 0);
+          doneCallback();
+        }
+      }).catch((err) => {
+        doneCallback(err);
+      });
+    };
+    exports.sync = initialWalkSync;
+    exports.async = initialWalkAsync;
+  }
+});
+var require_path = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.js"(exports, module2) {
+    "use strict";
+    var isWindows = typeof process === "object" && process && process.platform === "win32";
+    module2.exports = isWindows ? { sep: "\\" } : { sep: "/" };
+  }
+});
+var require_balanced_match = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch(a, str);
+      if (b instanceof RegExp) b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+var require_brace_expansion = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports, module2) {
+    "use strict";
+    var balanced = require_balanced_match();
+    module2.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand(escapeBraces(str), true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m) return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
+        }
+      } else {
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,.*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
+        } else {
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand(n[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
+        }
+      }
+      return expansions;
+    }
+  }
+});
+var require_minimatch = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.js"(exports, module2) {
+    "use strict";
+    var minimatch = module2.exports = (p, pattern, options = {}) => {
+      assertValidPattern(pattern);
+      if (!options.nocomment && pattern.charAt(0) === "#") {
+        return false;
+      }
+      return new Minimatch(pattern, options).match(p);
+    };
+    module2.exports = minimatch;
+    var path2 = require_path();
+    minimatch.sep = path2.sep;
+    var GLOBSTAR = Symbol("globstar **");
+    minimatch.GLOBSTAR = GLOBSTAR;
+    var expand = require_brace_expansion();
+    var plTypes = {
+      "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+      "?": { open: "(?:", close: ")?" },
+      "+": { open: "(?:", close: ")+" },
+      "*": { open: "(?:", close: ")*" },
+      "@": { open: "(?:", close: ")" }
+    };
+    var qmark = "[^/]";
+    var star = qmark + "*?";
+    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+    var charSet = (s) => s.split("").reduce((set, c) => {
+      set[c] = true;
+      return set;
+    }, {});
+    var reSpecials = charSet("().*{}+?[]^$\\!");
+    var addPatternStartSet = charSet("[.(");
+    var slashSplit = /\/+/;
+    minimatch.filter = (pattern, options = {}) => (p, i, list) => minimatch(p, pattern, options);
+    var ext = (a, b = {}) => {
+      const t = {};
+      Object.keys(a).forEach((k) => t[k] = a[k]);
+      Object.keys(b).forEach((k) => t[k] = b[k]);
+      return t;
+    };
+    minimatch.defaults = (def) => {
+      if (!def || typeof def !== "object" || !Object.keys(def).length) {
+        return minimatch;
+      }
+      const orig = minimatch;
+      const m = (p, pattern, options) => orig(p, pattern, ext(def, options));
+      m.Minimatch = class Minimatch extends orig.Minimatch {
+        constructor(pattern, options) {
+          super(pattern, ext(def, options));
+        }
+      };
+      m.Minimatch.defaults = (options) => orig.defaults(ext(def, options)).Minimatch;
+      m.filter = (pattern, options) => orig.filter(pattern, ext(def, options));
+      m.defaults = (options) => orig.defaults(ext(def, options));
+      m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options));
+      m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options));
+      m.match = (list, pattern, options) => orig.match(list, pattern, ext(def, options));
+      return m;
+    };
+    minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
+    var braceExpand = (pattern, options = {}) => {
+      assertValidPattern(pattern);
+      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+        return [pattern];
+      }
+      return expand(pattern);
+    };
+    var MAX_PATTERN_LENGTH = 1024 * 64;
+    var assertValidPattern = (pattern) => {
+      if (typeof pattern !== "string") {
+        throw new TypeError("invalid pattern");
+      }
+      if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError("pattern is too long");
+      }
+    };
+    var SUBPARSE = Symbol("subparse");
+    minimatch.makeRe = (pattern, options) => new Minimatch(pattern, options || {}).makeRe();
+    minimatch.match = (list, pattern, options = {}) => {
+      const mm = new Minimatch(pattern, options);
+      list = list.filter((f) => mm.match(f));
+      if (mm.options.nonull && !list.length) {
+        list.push(pattern);
+      }
+      return list;
+    };
+    var globUnescape = (s) => s.replace(/\\(.)/g, "$1");
+    var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var Minimatch = class {
+      constructor(pattern, options) {
+        assertValidPattern(pattern);
+        if (!options) options = {};
+        this.options = options;
+        this.set = [];
+        this.pattern = pattern;
+        this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+        if (this.windowsPathsNoEscape) {
+          this.pattern = this.pattern.replace(/\\/g, "/");
+        }
+        this.regexp = null;
+        this.negate = false;
+        this.comment = false;
+        this.empty = false;
+        this.partial = !!options.partial;
+        this.make();
+      }
+      debug() {
+      }
+      make() {
+        const pattern = this.pattern;
+        const options = this.options;
+        if (!options.nocomment && pattern.charAt(0) === "#") {
+          this.comment = true;
+          return;
+        }
+        if (!pattern) {
+          this.empty = true;
+          return;
+        }
+        this.parseNegate();
+        let set = this.globSet = this.braceExpand();
+        if (options.debug) this.debug = (...args) => console.error(...args);
+        this.debug(this.pattern, set);
+        set = this.globParts = set.map((s) => s.split(slashSplit));
+        this.debug(this.pattern, set);
+        set = set.map((s, si, set2) => s.map(this.parse, this));
+        this.debug(this.pattern, set);
+        set = set.filter((s) => s.indexOf(false) === -1);
+        this.debug(this.pattern, set);
+        this.set = set;
+      }
+      parseNegate() {
+        if (this.options.nonegate) return;
+        const pattern = this.pattern;
+        let negate = false;
+        let negateOffset = 0;
+        for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+          negate = !negate;
+          negateOffset++;
+        }
+        if (negateOffset) this.pattern = pattern.substr(negateOffset);
+        this.negate = negate;
+      }
+      // set partial to true to test if, for example,
+      // "/a/b" matches the start of "/*/b/*/d"
+      // Partial means, if you run out of file before you run
+      // out of pattern, then that's fine, as long as all
+      // the parts match.
+      matchOne(file, pattern, partial) {
+        var options = this.options;
+        this.debug(
+          "matchOne",
+          { "this": this, file, pattern }
+        );
+        this.debug("matchOne", file.length, pattern.length);
+        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+          this.debug("matchOne loop");
+          var p = pattern[pi];
+          var f = file[fi];
+          this.debug(pattern, p, f);
+          if (p === false) return false;
+          if (p === GLOBSTAR) {
+            this.debug("GLOBSTAR", [pattern, p, f]);
+            var fr = fi;
+            var pr = pi + 1;
+            if (pr === pl) {
+              this.debug("** at the end");
+              for (; fi < fl; fi++) {
+                if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".") return false;
+              }
+              return true;
+            }
+            while (fr < fl) {
+              var swallowee = file[fr];
+              this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+              if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+                this.debug("globstar found match!", fr, fl, swallowee);
+                return true;
+              } else {
+                if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+                  this.debug("dot detected!", file, fr, pattern, pr);
+                  break;
+                }
+                this.debug("globstar swallow a segment, and continue");
+                fr++;
+              }
+            }
+            if (partial) {
+              this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+              if (fr === fl) return true;
+            }
+            return false;
+          }
+          var hit;
+          if (typeof p === "string") {
+            hit = f === p;
+            this.debug("string match", p, f, hit);
+          } else {
+            hit = f.match(p);
+            this.debug("pattern match", p, f, hit);
+          }
+          if (!hit) return false;
+        }
+        if (fi === fl && pi === pl) {
+          return true;
+        } else if (fi === fl) {
+          return partial;
+        } else if (pi === pl) {
+          return fi === fl - 1 && file[fi] === "";
+        }
+        throw new Error("wtf?");
+      }
+      braceExpand() {
+        return braceExpand(this.pattern, this.options);
+      }
+      parse(pattern, isSub) {
+        assertValidPattern(pattern);
+        const options = this.options;
+        if (pattern === "**") {
+          if (!options.noglobstar)
+            return GLOBSTAR;
+          else
+            pattern = "*";
+        }
+        if (pattern === "") return "";
+        let re = "";
+        let hasMagic = !!options.nocase;
+        let escaping = false;
+        const patternListStack = [];
+        const negativeLists = [];
+        let stateChar;
+        let inClass = false;
+        let reClassStart = -1;
+        let classStart = -1;
+        let cs;
+        let pl;
+        let sp;
+        const patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+        const clearStateChar = () => {
+          if (stateChar) {
+            switch (stateChar) {
+              case "*":
+                re += star;
+                hasMagic = true;
+                break;
+              case "?":
+                re += qmark;
+                hasMagic = true;
+                break;
+              default:
+                re += "\\" + stateChar;
+                break;
+            }
+            this.debug("clearStateChar %j %j", stateChar, re);
+            stateChar = false;
+          }
+        };
+        for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
+          this.debug("%s	%s %s %j", pattern, i, re, c);
+          if (escaping) {
+            if (c === "/") {
+              return false;
+            }
+            if (reSpecials[c]) {
+              re += "\\";
+            }
+            re += c;
+            escaping = false;
+            continue;
+          }
+          switch (c) {
+            /* istanbul ignore next */
+            case "/": {
+              return false;
+            }
+            case "\\":
+              clearStateChar();
+              escaping = true;
+              continue;
+            // the various stateChar values
+            // for the "extglob" stuff.
+            case "?":
+            case "*":
+            case "+":
+            case "@":
+            case "!":
+              this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
+              if (inClass) {
+                this.debug("  in class");
+                if (c === "!" && i === classStart + 1) c = "^";
+                re += c;
+                continue;
+              }
+              this.debug("call clearStateChar %j", stateChar);
+              clearStateChar();
+              stateChar = c;
+              if (options.noext) clearStateChar();
+              continue;
+            case "(":
+              if (inClass) {
+                re += "(";
+                continue;
+              }
+              if (!stateChar) {
+                re += "\\(";
+                continue;
+              }
+              patternListStack.push({
+                type: stateChar,
+                start: i - 1,
+                reStart: re.length,
+                open: plTypes[stateChar].open,
+                close: plTypes[stateChar].close
+              });
+              re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+              this.debug("plType %j %j", stateChar, re);
+              stateChar = false;
+              continue;
+            case ")":
+              if (inClass || !patternListStack.length) {
+                re += "\\)";
+                continue;
+              }
+              clearStateChar();
+              hasMagic = true;
+              pl = patternListStack.pop();
+              re += pl.close;
+              if (pl.type === "!") {
+                negativeLists.push(pl);
+              }
+              pl.reEnd = re.length;
+              continue;
+            case "|":
+              if (inClass || !patternListStack.length) {
+                re += "\\|";
+                continue;
+              }
+              clearStateChar();
+              re += "|";
+              continue;
+            // these are mostly the same in regexp and glob
+            case "[":
+              clearStateChar();
+              if (inClass) {
+                re += "\\" + c;
+                continue;
+              }
+              inClass = true;
+              classStart = i;
+              reClassStart = re.length;
+              re += c;
+              continue;
+            case "]":
+              if (i === classStart + 1 || !inClass) {
+                re += "\\" + c;
+                continue;
+              }
+              cs = pattern.substring(classStart + 1, i);
+              try {
+                RegExp("[" + cs + "]");
+              } catch (er) {
+                sp = this.parse(cs, SUBPARSE);
+                re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+                hasMagic = hasMagic || sp[1];
+                inClass = false;
+                continue;
+              }
+              hasMagic = true;
+              inClass = false;
+              re += c;
+              continue;
+            default:
+              clearStateChar();
+              if (reSpecials[c] && !(c === "^" && inClass)) {
+                re += "\\";
+              }
+              re += c;
+              break;
+          }
+        }
+        if (inClass) {
+          cs = pattern.substr(classStart + 1);
+          sp = this.parse(cs, SUBPARSE);
+          re = re.substr(0, reClassStart) + "\\[" + sp[0];
+          hasMagic = hasMagic || sp[1];
+        }
+        for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+          let tail;
+          tail = re.slice(pl.reStart + pl.open.length);
+          this.debug("setting tail", re, pl);
+          tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+            if (!$2) {
+              $2 = "\\";
+            }
+            return $1 + $1 + $2 + "|";
+          });
+          this.debug("tail=%j\n   %s", tail, tail, pl, re);
+          const t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+          hasMagic = true;
+          re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+        }
+        clearStateChar();
+        if (escaping) {
+          re += "\\\\";
+        }
+        const addPatternStart = addPatternStartSet[re.charAt(0)];
+        for (let n = negativeLists.length - 1; n > -1; n--) {
+          const nl = negativeLists[n];
+          const nlBefore = re.slice(0, nl.reStart);
+          const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+          let nlAfter = re.slice(nl.reEnd);
+          const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+          const openParensBefore = nlBefore.split("(").length - 1;
+          let cleanAfter = nlAfter;
+          for (let i = 0; i < openParensBefore; i++) {
+            cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+          }
+          nlAfter = cleanAfter;
+          const dollar = nlAfter === "" && isSub !== SUBPARSE ? "$" : "";
+          re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+        }
+        if (re !== "" && hasMagic) {
+          re = "(?=.)" + re;
+        }
+        if (addPatternStart) {
+          re = patternStart + re;
+        }
+        if (isSub === SUBPARSE) {
+          return [re, hasMagic];
+        }
+        if (!hasMagic) {
+          return globUnescape(pattern);
+        }
+        const flags = options.nocase ? "i" : "";
+        try {
+          return Object.assign(new RegExp("^" + re + "$", flags), {
+            _glob: pattern,
+            _src: re
+          });
+        } catch (er) {
+          return new RegExp("$.");
+        }
+      }
+      makeRe() {
+        if (this.regexp || this.regexp === false) return this.regexp;
+        const set = this.set;
+        if (!set.length) {
+          this.regexp = false;
+          return this.regexp;
+        }
+        const options = this.options;
+        const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+        const flags = options.nocase ? "i" : "";
+        let re = set.map((pattern) => {
+          pattern = pattern.map(
+            (p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
+          ).reduce((set2, p) => {
+            if (!(set2[set2.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+              set2.push(p);
+            }
+            return set2;
+          }, []);
+          pattern.forEach((p, i) => {
+            if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
+              return;
+            }
+            if (i === 0) {
+              if (pattern.length > 1) {
+                pattern[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i + 1];
+              } else {
+                pattern[i] = twoStar;
+              }
+            } else if (i === pattern.length - 1) {
+              pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
+            } else {
+              pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
+              pattern[i + 1] = GLOBSTAR;
+            }
+          });
+          return pattern.filter((p) => p !== GLOBSTAR).join("/");
+        }).join("|");
+        re = "^(?:" + re + ")$";
+        if (this.negate) re = "^(?!" + re + ").*$";
+        try {
+          this.regexp = new RegExp(re, flags);
+        } catch (ex) {
+          this.regexp = false;
+        }
+        return this.regexp;
+      }
+      match(f, partial = this.partial) {
+        this.debug("match", f, this.pattern);
+        if (this.comment) return false;
+        if (this.empty) return f === "";
+        if (f === "/" && partial) return true;
+        const options = this.options;
+        if (path2.sep !== "/") {
+          f = f.split(path2.sep).join("/");
+        }
+        f = f.split(slashSplit);
+        this.debug(this.pattern, "split", f);
+        const set = this.set;
+        this.debug(this.pattern, "set", set);
+        let filename;
+        for (let i = f.length - 1; i >= 0; i--) {
+          filename = f[i];
+          if (filename) break;
+        }
+        for (let i = 0; i < set.length; i++) {
+          const pattern = set[i];
+          let file = f;
+          if (options.matchBase && pattern.length === 1) {
+            file = [filename];
+          }
+          const hit = this.matchOne(file, pattern, partial);
+          if (hit) {
+            if (options.flipNegate) return true;
+            return !this.negate;
+          }
+        }
+        if (options.flipNegate) return false;
+        return this.negate;
+      }
+      static defaults(def) {
+        return minimatch.defaults(def).Minimatch;
+      }
+    };
+    minimatch.Minimatch = Minimatch;
+  }
+});
+var require_matcher = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/utils/matcher.js"(exports) {
+    "use strict";
+    var Minimatch = require_minimatch().Minimatch;
+    var convertPatternToAbsolutePath = (basePath, pattern) => {
+      const hasSlash = pattern.indexOf("/") !== -1;
+      const isAbsolute = /^!?\//.test(pattern);
+      const isNegated = /^!/.test(pattern);
+      let separator;
+      if (!isAbsolute && hasSlash) {
+        const patternWithoutFirstCharacters = pattern.replace(/^!/, "").replace(/^\.\//, "");
+        if (/\/$/.test(basePath)) {
+          separator = "";
+        } else {
+          separator = "/";
+        }
+        if (isNegated) {
+          return `!${basePath}${separator}${patternWithoutFirstCharacters}`;
+        }
+        return `${basePath}${separator}${patternWithoutFirstCharacters}`;
+      }
+      return pattern;
+    };
+    exports.create = (basePath, patterns, ignoreCase) => {
+      let normalizedPatterns;
+      if (typeof patterns === "string") {
+        normalizedPatterns = [patterns];
+      } else {
+        normalizedPatterns = patterns;
+      }
+      const matchers = normalizedPatterns.map((pattern) => {
+        return convertPatternToAbsolutePath(basePath, pattern);
+      }).map((pattern) => {
+        return new Minimatch(pattern, {
+          matchBase: true,
+          nocomment: true,
+          nocase: ignoreCase || false,
+          dot: true,
+          windowsPathsNoEscape: true
+        });
+      });
+      const performMatch = (absolutePath) => {
+        let mode = "matching";
+        let weHaveMatch = false;
+        let currentMatcher;
+        let i;
+        for (i = 0; i < matchers.length; i += 1) {
+          currentMatcher = matchers[i];
+          if (currentMatcher.negate) {
+            mode = "negation";
+            if (i === 0) {
+              weHaveMatch = true;
+            }
+          }
+          if (mode === "negation" && weHaveMatch && !currentMatcher.match(absolutePath)) {
+            return false;
+          }
+          if (mode === "matching" && !weHaveMatch) {
+            weHaveMatch = currentMatcher.match(absolutePath);
+          }
+        }
+        return weHaveMatch;
+      };
+      return performMatch;
+    };
+  }
+});
+var require_find = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/find.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var treeWalker = require_tree_walker();
+    var inspect = require_inspect();
+    var matcher = require_matcher();
+    var validate = require_validate();
+    var validateInput = (methodName, path2, options) => {
+      const methodSignature = `${methodName}([path], options)`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        matching: ["string", "array of string"],
+        filter: ["function"],
+        files: ["boolean"],
+        directories: ["boolean"],
+        recursive: ["boolean"],
+        ignoreCase: ["boolean"]
+      });
+    };
+    var normalizeOptions = (options) => {
+      const opts = options || {};
+      if (opts.matching === void 0) {
+        opts.matching = "*";
+      }
+      if (opts.files === void 0) {
+        opts.files = true;
+      }
+      if (opts.ignoreCase === void 0) {
+        opts.ignoreCase = false;
+      }
+      if (opts.directories === void 0) {
+        opts.directories = false;
+      }
+      if (opts.recursive === void 0) {
+        opts.recursive = true;
+      }
+      return opts;
+    };
+    var processFoundPaths = (foundPaths, cwd) => {
+      return foundPaths.map((path2) => {
+        return pathUtil.relative(cwd, path2);
+      });
+    };
+    var generatePathDoesntExistError = (path2) => {
+      const err = new Error(`Path you want to find stuff in doesn't exist ${path2}`);
+      err.code = "ENOENT";
+      return err;
+    };
+    var generatePathNotDirectoryError = (path2) => {
+      const err = new Error(
+        `Path you want to find stuff in must be a directory ${path2}`
+      );
+      err.code = "ENOTDIR";
+      return err;
+    };
+    var findSync = (path2, options) => {
+      const foundAbsolutePaths = [];
+      const matchesAnyOfGlobs = matcher.create(
+        path2,
+        options.matching,
+        options.ignoreCase
+      );
+      let maxLevelsDeep = Infinity;
+      if (options.recursive === false) {
+        maxLevelsDeep = 1;
+      }
+      treeWalker.sync(
+        path2,
+        {
+          maxLevelsDeep,
+          symlinks: "follow",
+          inspectOptions: { times: true, absolutePath: true }
+        },
+        (itemPath, item) => {
+          if (item && itemPath !== path2 && matchesAnyOfGlobs(itemPath)) {
+            const weHaveMatch = item.type === "file" && options.files === true || item.type === "dir" && options.directories === true;
+            if (weHaveMatch) {
+              if (options.filter) {
+                const passedThroughFilter = options.filter(item);
+                if (passedThroughFilter) {
+                  foundAbsolutePaths.push(itemPath);
+                }
+              } else {
+                foundAbsolutePaths.push(itemPath);
+              }
+            }
+          }
+        }
+      );
+      foundAbsolutePaths.sort();
+      return processFoundPaths(foundAbsolutePaths, options.cwd);
+    };
+    var findSyncInit = (path2, options) => {
+      const entryPointInspect = inspect.sync(path2, { symlinks: "follow" });
+      if (entryPointInspect === void 0) {
+        throw generatePathDoesntExistError(path2);
+      } else if (entryPointInspect.type !== "dir") {
+        throw generatePathNotDirectoryError(path2);
+      }
+      return findSync(path2, normalizeOptions(options));
+    };
+    var findAsync = (path2, options) => {
+      return new Promise((resolve, reject) => {
+        const foundAbsolutePaths = [];
+        const matchesAnyOfGlobs = matcher.create(
+          path2,
+          options.matching,
+          options.ignoreCase
+        );
+        let maxLevelsDeep = Infinity;
+        if (options.recursive === false) {
+          maxLevelsDeep = 1;
+        }
+        let waitingForFiltersToFinish = 0;
+        let treeWalkerDone = false;
+        const maybeDone = () => {
+          if (treeWalkerDone && waitingForFiltersToFinish === 0) {
+            foundAbsolutePaths.sort();
+            resolve(processFoundPaths(foundAbsolutePaths, options.cwd));
+          }
+        };
+        treeWalker.async(
+          path2,
+          {
+            maxLevelsDeep,
+            symlinks: "follow",
+            inspectOptions: { times: true, absolutePath: true }
+          },
+          (itemPath, item) => {
+            if (item && itemPath !== path2 && matchesAnyOfGlobs(itemPath)) {
+              const weHaveMatch = item.type === "file" && options.files === true || item.type === "dir" && options.directories === true;
+              if (weHaveMatch) {
+                if (options.filter) {
+                  const passedThroughFilter = options.filter(item);
+                  const isPromise = typeof passedThroughFilter.then === "function";
+                  if (isPromise) {
+                    waitingForFiltersToFinish += 1;
+                    passedThroughFilter.then((passedThroughFilterResult) => {
+                      if (passedThroughFilterResult) {
+                        foundAbsolutePaths.push(itemPath);
+                      }
+                      waitingForFiltersToFinish -= 1;
+                      maybeDone();
+                    }).catch((err) => {
+                      reject(err);
+                    });
+                  } else if (passedThroughFilter) {
+                    foundAbsolutePaths.push(itemPath);
+                  }
+                } else {
+                  foundAbsolutePaths.push(itemPath);
+                }
+              }
+            }
+          },
+          (err) => {
+            if (err) {
+              reject(err);
+            } else {
+              treeWalkerDone = true;
+              maybeDone();
+            }
+          }
+        );
+      });
+    };
+    var findAsyncInit = (path2, options) => {
+      return inspect.async(path2, { symlinks: "follow" }).then((entryPointInspect) => {
+        if (entryPointInspect === void 0) {
+          throw generatePathDoesntExistError(path2);
+        } else if (entryPointInspect.type !== "dir") {
+          throw generatePathNotDirectoryError(path2);
+        }
+        return findAsync(path2, normalizeOptions(options));
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = findSyncInit;
+    exports.async = findAsyncInit;
+  }
+});
+var require_inspect_tree = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/inspect_tree.js"(exports) {
+    "use strict";
+    var crypto = (0, import_chunk_2ESYSVXG.__require)("crypto");
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var inspect = require_inspect();
+    var list = require_list();
+    var validate = require_validate();
+    var treeWalker = require_tree_walker();
+    var validateInput = (methodName, path2, options) => {
+      const methodSignature = `${methodName}(path, [options])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        checksum: ["string"],
+        relativePath: ["boolean"],
+        times: ["boolean"],
+        symlinks: ["string"]
+      });
+      if (options && options.checksum !== void 0 && inspect.supportedChecksumAlgorithms.indexOf(options.checksum) === -1) {
+        throw new Error(
+          `Argument "options.checksum" passed to ${methodSignature} must have one of values: ${inspect.supportedChecksumAlgorithms.join(
+            ", "
+          )}`
+        );
+      }
+      if (options && options.symlinks !== void 0 && inspect.symlinkOptions.indexOf(options.symlinks) === -1) {
+        throw new Error(
+          `Argument "options.symlinks" passed to ${methodSignature} must have one of values: ${inspect.symlinkOptions.join(
+            ", "
+          )}`
+        );
+      }
+    };
+    var relativePathInTree = (parentInspectObj, inspectObj) => {
+      if (parentInspectObj === void 0) {
+        return ".";
+      }
+      return parentInspectObj.relativePath + "/" + inspectObj.name;
+    };
+    var checksumOfDir = (inspectList, algo) => {
+      const hash = crypto.createHash(algo);
+      inspectList.forEach((inspectObj) => {
+        hash.update(inspectObj.name + inspectObj[algo]);
+      });
+      return hash.digest("hex");
+    };
+    var calculateTreeDependentProperties = (parentInspectObj, inspectObj, options) => {
+      if (options.relativePath) {
+        inspectObj.relativePath = relativePathInTree(parentInspectObj, inspectObj);
+      }
+      if (inspectObj.type === "dir") {
+        inspectObj.children.forEach((childInspectObj) => {
+          calculateTreeDependentProperties(inspectObj, childInspectObj, options);
+        });
+        inspectObj.size = 0;
+        inspectObj.children.sort((a, b) => {
+          if (a.type === "dir" && b.type === "file") {
+            return -1;
+          }
+          if (a.type === "file" && b.type === "dir") {
+            return 1;
+          }
+          return a.name.localeCompare(b.name);
+        });
+        inspectObj.children.forEach((child) => {
+          inspectObj.size += child.size || 0;
+        });
+        if (options.checksum) {
+          inspectObj[options.checksum] = checksumOfDir(
+            inspectObj.children,
+            options.checksum
+          );
+        }
+      }
+    };
+    var findParentInTree = (treeNode, pathChain, item) => {
+      const name = pathChain[0];
+      if (pathChain.length > 1) {
+        const itemInTreeForPathChain = treeNode.children.find((child) => {
+          return child.name === name;
+        });
+        return findParentInTree(itemInTreeForPathChain, pathChain.slice(1), item);
+      }
+      return treeNode;
+    };
+    var inspectTreeSync = (path2, opts) => {
+      const options = opts || {};
+      let tree;
+      treeWalker.sync(path2, { inspectOptions: options }, (itemPath, item) => {
+        if (item) {
+          if (item.type === "dir") {
+            item.children = [];
+          }
+          const relativePath = pathUtil.relative(path2, itemPath);
+          if (relativePath === "") {
+            tree = item;
+          } else {
+            const parentItem = findParentInTree(
+              tree,
+              relativePath.split(pathUtil.sep),
+              item
+            );
+            parentItem.children.push(item);
+          }
+        }
+      });
+      if (tree) {
+        calculateTreeDependentProperties(void 0, tree, options);
+      }
+      return tree;
+    };
+    var inspectTreeAsync = (path2, opts) => {
+      const options = opts || {};
+      let tree;
+      return new Promise((resolve, reject) => {
+        treeWalker.async(
+          path2,
+          { inspectOptions: options },
+          (itemPath, item) => {
+            if (item) {
+              if (item.type === "dir") {
+                item.children = [];
+              }
+              const relativePath = pathUtil.relative(path2, itemPath);
+              if (relativePath === "") {
+                tree = item;
+              } else {
+                const parentItem = findParentInTree(
+                  tree,
+                  relativePath.split(pathUtil.sep),
+                  item
+                );
+                parentItem.children.push(item);
+              }
+            }
+          },
+          (err) => {
+            if (err) {
+              reject(err);
+            } else {
+              if (tree) {
+                calculateTreeDependentProperties(void 0, tree, options);
+              }
+              resolve(tree);
+            }
+          }
+        );
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = inspectTreeSync;
+    exports.async = inspectTreeAsync;
+  }
+});
+var require_exists = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/exists.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var validateInput = (methodName, path2) => {
+      const methodSignature = `${methodName}(path)`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+    };
+    var existsSync = (path2) => {
+      try {
+        const stat = fs2.statSync(path2);
+        if (stat.isDirectory()) {
+          return "dir";
+        } else if (stat.isFile()) {
+          return "file";
+        }
+        return "other";
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      return false;
+    };
+    var existsAsync = (path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.stat(path2).then((stat) => {
+          if (stat.isDirectory()) {
+            resolve("dir");
+          } else if (stat.isFile()) {
+            resolve("file");
+          } else {
+            resolve("other");
+          }
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(false);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = existsSync;
+    exports.async = existsAsync;
+  }
+});
+var require_copy = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/copy.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var dir = require_dir();
+    var exists = require_exists();
+    var inspect = require_inspect();
+    var write = require_write();
+    var matcher = require_matcher();
+    var fileMode = require_mode();
+    var treeWalker = require_tree_walker();
+    var validate = require_validate();
+    var validateInput = (methodName, from, to, options) => {
+      const methodSignature = `${methodName}(from, to, [options])`;
+      validate.argument(methodSignature, "from", from, ["string"]);
+      validate.argument(methodSignature, "to", to, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        overwrite: ["boolean", "function"],
+        matching: ["string", "array of string"],
+        ignoreCase: ["boolean"]
+      });
+    };
+    var parseOptions = (options, from) => {
+      const opts = options || {};
+      const parsedOptions = {};
+      if (opts.ignoreCase === void 0) {
+        opts.ignoreCase = false;
+      }
+      parsedOptions.overwrite = opts.overwrite;
+      if (opts.matching) {
+        parsedOptions.allowedToCopy = matcher.create(
+          from,
+          opts.matching,
+          opts.ignoreCase
+        );
+      } else {
+        parsedOptions.allowedToCopy = () => {
+          return true;
+        };
+      }
+      return parsedOptions;
+    };
+    var generateNoSourceError = (path2) => {
+      const err = new Error(`Path to copy doesn't exist ${path2}`);
+      err.code = "ENOENT";
+      return err;
+    };
+    var generateDestinationExistsError = (path2) => {
+      const err = new Error(`Destination path already exists ${path2}`);
+      err.code = "EEXIST";
+      return err;
+    };
+    var inspectOptions = {
+      mode: true,
+      symlinks: "report",
+      times: true,
+      absolutePath: true
+    };
+    var shouldThrowDestinationExistsError = (context) => {
+      return typeof context.opts.overwrite !== "function" && context.opts.overwrite !== true;
+    };
+    var checksBeforeCopyingSync = (from, to, opts) => {
+      if (!exists.sync(from)) {
+        throw generateNoSourceError(from);
+      }
+      if (exists.sync(to) && !opts.overwrite) {
+        throw generateDestinationExistsError(to);
+      }
+    };
+    var canOverwriteItSync = (context) => {
+      if (typeof context.opts.overwrite === "function") {
+        const destInspectData = inspect.sync(context.destPath, inspectOptions);
+        return context.opts.overwrite(context.srcInspectData, destInspectData);
+      }
+      return context.opts.overwrite === true;
+    };
+    var copyFileSync = (srcPath, destPath, mode, context) => {
+      const data = fs2.readFileSync(srcPath);
+      try {
+        fs2.writeFileSync(destPath, data, { mode, flag: "wx" });
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          write.sync(destPath, data, { mode });
+        } else if (err.code === "EEXIST") {
+          if (canOverwriteItSync(context)) {
+            fs2.writeFileSync(destPath, data, { mode });
+          } else if (shouldThrowDestinationExistsError(context)) {
+            throw generateDestinationExistsError(context.destPath);
+          }
+        } else {
+          throw err;
+        }
+      }
+    };
+    var copySymlinkSync = (from, to) => {
+      const symlinkPointsAt = fs2.readlinkSync(from);
+      try {
+        fs2.symlinkSync(symlinkPointsAt, to);
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          fs2.unlinkSync(to);
+          fs2.symlinkSync(symlinkPointsAt, to);
+        } else {
+          throw err;
+        }
+      }
+    };
+    var copyItemSync = (srcPath, srcInspectData, destPath, opts) => {
+      const context = { srcPath, destPath, srcInspectData, opts };
+      const mode = fileMode.normalizeFileMode(srcInspectData.mode);
+      if (srcInspectData.type === "dir") {
+        dir.createSync(destPath, { mode });
+      } else if (srcInspectData.type === "file") {
+        copyFileSync(srcPath, destPath, mode, context);
+      } else if (srcInspectData.type === "symlink") {
+        copySymlinkSync(srcPath, destPath);
+      }
+    };
+    var copySync = (from, to, options) => {
+      const opts = parseOptions(options, from);
+      checksBeforeCopyingSync(from, to, opts);
+      treeWalker.sync(from, { inspectOptions }, (srcPath, srcInspectData) => {
+        const rel = pathUtil.relative(from, srcPath);
+        const destPath = pathUtil.resolve(to, rel);
+        if (opts.allowedToCopy(srcPath, destPath, srcInspectData)) {
+          copyItemSync(srcPath, srcInspectData, destPath, opts);
+        }
+      });
+    };
+    var checksBeforeCopyingAsync = (from, to, opts) => {
+      return exists.async(from).then((srcPathExists) => {
+        if (!srcPathExists) {
+          throw generateNoSourceError(from);
+        } else {
+          return exists.async(to);
+        }
+      }).then((destPathExists) => {
+        if (destPathExists && !opts.overwrite) {
+          throw generateDestinationExistsError(to);
+        }
+      });
+    };
+    var canOverwriteItAsync = (context) => {
+      return new Promise((resolve, reject) => {
+        if (typeof context.opts.overwrite === "function") {
+          inspect.async(context.destPath, inspectOptions).then((destInspectData) => {
+            resolve(
+              context.opts.overwrite(context.srcInspectData, destInspectData)
+            );
+          }).catch(reject);
+        } else {
+          resolve(context.opts.overwrite === true);
+        }
+      });
+    };
+    var copyFileAsync = (srcPath, destPath, mode, context, runOptions) => {
+      return new Promise((resolve, reject) => {
+        const runOpts = runOptions || {};
+        let flags = "wx";
+        if (runOpts.overwrite) {
+          flags = "w";
+        }
+        const readStream = fs2.createReadStream(srcPath);
+        const writeStream = fs2.createWriteStream(destPath, { mode, flags });
+        readStream.on("error", reject);
+        writeStream.on("error", (err) => {
+          readStream.resume();
+          if (err.code === "ENOENT") {
+            dir.createAsync(pathUtil.dirname(destPath)).then(() => {
+              copyFileAsync(srcPath, destPath, mode, context).then(
+                resolve,
+                reject
+              );
+            }).catch(reject);
+          } else if (err.code === "EEXIST") {
+            canOverwriteItAsync(context).then((canOverwite) => {
+              if (canOverwite) {
+                copyFileAsync(srcPath, destPath, mode, context, {
+                  overwrite: true
+                }).then(resolve, reject);
+              } else if (shouldThrowDestinationExistsError(context)) {
+                reject(generateDestinationExistsError(destPath));
+              } else {
+                resolve();
+              }
+            }).catch(reject);
+          } else {
+            reject(err);
+          }
+        });
+        writeStream.on("finish", resolve);
+        readStream.pipe(writeStream);
+      });
+    };
+    var copySymlinkAsync = (from, to) => {
+      return fs2.readlink(from).then((symlinkPointsAt) => {
+        return new Promise((resolve, reject) => {
+          fs2.symlink(symlinkPointsAt, to).then(resolve).catch((err) => {
+            if (err.code === "EEXIST") {
+              fs2.unlink(to).then(() => {
+                return fs2.symlink(symlinkPointsAt, to);
+              }).then(resolve, reject);
+            } else {
+              reject(err);
+            }
+          });
+        });
+      });
+    };
+    var copyItemAsync = (srcPath, srcInspectData, destPath, opts) => {
+      const context = { srcPath, destPath, srcInspectData, opts };
+      const mode = fileMode.normalizeFileMode(srcInspectData.mode);
+      if (srcInspectData.type === "dir") {
+        return dir.createAsync(destPath, { mode });
+      } else if (srcInspectData.type === "file") {
+        return copyFileAsync(srcPath, destPath, mode, context);
+      } else if (srcInspectData.type === "symlink") {
+        return copySymlinkAsync(srcPath, destPath);
+      }
+      return Promise.resolve();
+    };
+    var copyAsync = (from, to, options) => {
+      return new Promise((resolve, reject) => {
+        const opts = parseOptions(options, from);
+        checksBeforeCopyingAsync(from, to, opts).then(() => {
+          let allFilesDelivered = false;
+          let filesInProgress = 0;
+          treeWalker.async(
+            from,
+            { inspectOptions },
+            (srcPath, item) => {
+              if (item) {
+                const rel = pathUtil.relative(from, srcPath);
+                const destPath = pathUtil.resolve(to, rel);
+                if (opts.allowedToCopy(srcPath, item, destPath)) {
+                  filesInProgress += 1;
+                  copyItemAsync(srcPath, item, destPath, opts).then(() => {
+                    filesInProgress -= 1;
+                    if (allFilesDelivered && filesInProgress === 0) {
+                      resolve();
+                    }
+                  }).catch(reject);
+                }
+              }
+            },
+            (err) => {
+              if (err) {
+                reject(err);
+              } else {
+                allFilesDelivered = true;
+                if (allFilesDelivered && filesInProgress === 0) {
+                  resolve();
+                }
+              }
+            }
+          );
+        }).catch(reject);
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = copySync;
+    exports.async = copyAsync;
+  }
+});
+var require_move = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/move.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var copy = require_copy();
+    var dir = require_dir();
+    var exists = require_exists();
+    var remove = require_remove();
+    var validateInput = (methodName, from, to, options) => {
+      const methodSignature = `${methodName}(from, to, [options])`;
+      validate.argument(methodSignature, "from", from, ["string"]);
+      validate.argument(methodSignature, "to", to, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        overwrite: ["boolean"]
+      });
+    };
+    var parseOptions = (options) => {
+      const opts = options || {};
+      return opts;
+    };
+    var generateDestinationExistsError = (path2) => {
+      const err = new Error(`Destination path already exists ${path2}`);
+      err.code = "EEXIST";
+      return err;
+    };
+    var generateSourceDoesntExistError = (path2) => {
+      const err = new Error(`Path to move doesn't exist ${path2}`);
+      err.code = "ENOENT";
+      return err;
+    };
+    var moveSync = (from, to, options) => {
+      const opts = parseOptions(options);
+      if (exists.sync(to) !== false && opts.overwrite !== true) {
+        throw generateDestinationExistsError(to);
+      }
+      try {
+        fs2.renameSync(from, to);
+      } catch (err) {
+        if (err.code === "EISDIR" || err.code === "EPERM") {
+          remove.sync(to);
+          fs2.renameSync(from, to);
+        } else if (err.code === "EXDEV") {
+          copy.sync(from, to, { overwrite: true });
+          remove.sync(from);
+        } else if (err.code === "ENOENT") {
+          if (!exists.sync(from)) {
+            throw generateSourceDoesntExistError(from);
+          }
+          dir.createSync(pathUtil.dirname(to));
+          fs2.renameSync(from, to);
+        } else {
+          throw err;
+        }
+      }
+    };
+    var ensureDestinationPathExistsAsync = (to) => {
+      return new Promise((resolve, reject) => {
+        const destDir = pathUtil.dirname(to);
+        exists.async(destDir).then((dstExists) => {
+          if (!dstExists) {
+            dir.createAsync(destDir).then(resolve, reject);
+          } else {
+            reject();
+          }
+        }).catch(reject);
+      });
+    };
+    var moveAsync = (from, to, options) => {
+      const opts = parseOptions(options);
+      return new Promise((resolve, reject) => {
+        exists.async(to).then((destinationExists) => {
+          if (destinationExists !== false && opts.overwrite !== true) {
+            reject(generateDestinationExistsError(to));
+          } else {
+            fs2.rename(from, to).then(resolve).catch((err) => {
+              if (err.code === "EISDIR" || err.code === "EPERM") {
+                remove.async(to).then(() => fs2.rename(from, to)).then(resolve, reject);
+              } else if (err.code === "EXDEV") {
+                copy.async(from, to, { overwrite: true }).then(() => remove.async(from)).then(resolve, reject);
+              } else if (err.code === "ENOENT") {
+                exists.async(from).then((srcExists) => {
+                  if (!srcExists) {
+                    reject(generateSourceDoesntExistError(from));
+                  } else {
+                    ensureDestinationPathExistsAsync(to).then(() => {
+                      return fs2.rename(from, to);
+                    }).then(resolve, reject);
+                  }
+                }).catch(reject);
+              } else {
+                reject(err);
+              }
+            });
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = moveSync;
+    exports.async = moveAsync;
+  }
+});
+var require_read = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/read.js"(exports) {
+    "use strict";
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var supportedReturnAs = ["utf8", "buffer", "json", "jsonWithDates"];
+    var validateInput = (methodName, path2, returnAs) => {
+      const methodSignature = `${methodName}(path, returnAs)`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.argument(methodSignature, "returnAs", returnAs, [
+        "string",
+        "undefined"
+      ]);
+      if (returnAs && supportedReturnAs.indexOf(returnAs) === -1) {
+        throw new Error(
+          `Argument "returnAs" passed to ${methodSignature} must have one of values: ${supportedReturnAs.join(
+            ", "
+          )}`
+        );
+      }
+    };
+    var jsonDateParser = (key, value) => {
+      const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
+      if (typeof value === "string") {
+        if (reISO.exec(value)) {
+          return new Date(value);
+        }
+      }
+      return value;
+    };
+    var makeNicerJsonParsingError = (path2, err) => {
+      const nicerError = new Error(
+        `JSON parsing failed while reading ${path2} [${err}]`
+      );
+      nicerError.originalError = err;
+      return nicerError;
+    };
+    var readSync = (path2, returnAs) => {
+      const retAs = returnAs || "utf8";
+      let data;
+      let encoding = "utf8";
+      if (retAs === "buffer") {
+        encoding = null;
+      }
+      try {
+        data = fs2.readFileSync(path2, { encoding });
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return void 0;
+        }
+        throw err;
+      }
+      try {
+        if (retAs === "json") {
+          data = JSON.parse(data);
+        } else if (retAs === "jsonWithDates") {
+          data = JSON.parse(data, jsonDateParser);
+        }
+      } catch (err) {
+        throw makeNicerJsonParsingError(path2, err);
+      }
+      return data;
+    };
+    var readAsync = (path2, returnAs) => {
+      return new Promise((resolve, reject) => {
+        const retAs = returnAs || "utf8";
+        let encoding = "utf8";
+        if (retAs === "buffer") {
+          encoding = null;
+        }
+        fs2.readFile(path2, { encoding }).then((data) => {
+          try {
+            if (retAs === "json") {
+              resolve(JSON.parse(data));
+            } else if (retAs === "jsonWithDates") {
+              resolve(JSON.parse(data, jsonDateParser));
+            } else {
+              resolve(data);
+            }
+          } catch (err) {
+            reject(makeNicerJsonParsingError(path2, err));
+          }
+        }).catch((err) => {
+          if (err.code === "ENOENT") {
+            resolve(void 0);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = readSync;
+    exports.async = readAsync;
+  }
+});
+var require_rename = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/rename.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var move = require_move();
+    var validate = require_validate();
+    var validateInput = (methodName, path2, newName, options) => {
+      const methodSignature = `${methodName}(path, newName, [options])`;
+      validate.argument(methodSignature, "path", path2, ["string"]);
+      validate.argument(methodSignature, "newName", newName, ["string"]);
+      validate.options(methodSignature, "options", options, {
+        overwrite: ["boolean"]
+      });
+      if (pathUtil.basename(newName) !== newName) {
+        throw new Error(
+          `Argument "newName" passed to ${methodSignature} should be a filename, not a path. Received "${newName}"`
+        );
+      }
+    };
+    var renameSync = (path2, newName, options) => {
+      const newPath = pathUtil.join(pathUtil.dirname(path2), newName);
+      move.sync(path2, newPath, options);
+    };
+    var renameAsync = (path2, newName, options) => {
+      const newPath = pathUtil.join(pathUtil.dirname(path2), newName);
+      return move.async(path2, newPath, options);
+    };
+    exports.validateInput = validateInput;
+    exports.sync = renameSync;
+    exports.async = renameAsync;
+  }
+});
+var require_symlink = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/symlink.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var dir = require_dir();
+    var validateInput = (methodName, symlinkValue, path2) => {
+      const methodSignature = `${methodName}(symlinkValue, path)`;
+      validate.argument(methodSignature, "symlinkValue", symlinkValue, ["string"]);
+      validate.argument(methodSignature, "path", path2, ["string"]);
+    };
+    var symlinkSync = (symlinkValue, path2) => {
+      try {
+        fs2.symlinkSync(symlinkValue, path2);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          dir.createSync(pathUtil.dirname(path2));
+          fs2.symlinkSync(symlinkValue, path2);
+        } else {
+          throw err;
+        }
+      }
+    };
+    var symlinkAsync = (symlinkValue, path2) => {
+      return new Promise((resolve, reject) => {
+        fs2.symlink(symlinkValue, path2).then(resolve).catch((err) => {
+          if (err.code === "ENOENT") {
+            dir.createAsync(pathUtil.dirname(path2)).then(() => {
+              return fs2.symlink(symlinkValue, path2);
+            }).then(resolve, reject);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = symlinkSync;
+    exports.async = symlinkAsync;
+  }
+});
+var require_streams = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/streams.js"(exports) {
+    "use strict";
+    var fs2 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    exports.createWriteStream = fs2.createWriteStream;
+    exports.createReadStream = fs2.createReadStream;
+  }
+});
+var require_tmp_dir = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/tmp_dir.js"(exports) {
+    "use strict";
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var os = (0, import_chunk_2ESYSVXG.__require)("os");
+    var crypto = (0, import_chunk_2ESYSVXG.__require)("crypto");
+    var dir = require_dir();
+    var fs2 = require_fs();
+    var validate = require_validate();
+    var validateInput = (methodName, options) => {
+      const methodSignature = `${methodName}([options])`;
+      validate.options(methodSignature, "options", options, {
+        prefix: ["string"],
+        basePath: ["string"]
+      });
+    };
+    var getOptionsDefaults = (passedOptions, cwdPath) => {
+      passedOptions = passedOptions || {};
+      const options = {};
+      if (typeof passedOptions.prefix !== "string") {
+        options.prefix = "";
+      } else {
+        options.prefix = passedOptions.prefix;
+      }
+      if (typeof passedOptions.basePath === "string") {
+        options.basePath = pathUtil.resolve(cwdPath, passedOptions.basePath);
+      } else {
+        options.basePath = os.tmpdir();
+      }
+      return options;
+    };
+    var randomStringLength = 32;
+    var tmpDirSync = (cwdPath, passedOptions) => {
+      const options = getOptionsDefaults(passedOptions, cwdPath);
+      const randomString = crypto.randomBytes(randomStringLength / 2).toString("hex");
+      const dirPath = pathUtil.join(
+        options.basePath,
+        options.prefix + randomString
+      );
+      try {
+        fs2.mkdirSync(dirPath);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          dir.sync(dirPath);
+        } else {
+          throw err;
+        }
+      }
+      return dirPath;
+    };
+    var tmpDirAsync = (cwdPath, passedOptions) => {
+      return new Promise((resolve, reject) => {
+        const options = getOptionsDefaults(passedOptions, cwdPath);
+        crypto.randomBytes(randomStringLength / 2, (err, bytes) => {
+          if (err) {
+            reject(err);
+          } else {
+            const randomString = bytes.toString("hex");
+            const dirPath = pathUtil.join(
+              options.basePath,
+              options.prefix + randomString
+            );
+            fs2.mkdir(dirPath, (err2) => {
+              if (err2) {
+                if (err2.code === "ENOENT") {
+                  dir.async(dirPath).then(() => {
+                    resolve(dirPath);
+                  }, reject);
+                } else {
+                  reject(err2);
+                }
+              } else {
+                resolve(dirPath);
+              }
+            });
+          }
+        });
+      });
+    };
+    exports.validateInput = validateInput;
+    exports.sync = tmpDirSync;
+    exports.async = tmpDirAsync;
+  }
+});
+var require_jetpack = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/lib/jetpack.js"(exports, module2) {
+    "use strict";
+    var util = (0, import_chunk_2ESYSVXG.__require)("util");
+    var pathUtil = (0, import_chunk_2ESYSVXG.__require)("path");
+    var append = require_append();
+    var dir = require_dir();
+    var file = require_file();
+    var find = require_find();
+    var inspect = require_inspect();
+    var inspectTree = require_inspect_tree();
+    var copy = require_copy();
+    var exists = require_exists();
+    var list = require_list();
+    var move = require_move();
+    var read = require_read();
+    var remove = require_remove();
+    var rename = require_rename();
+    var symlink = require_symlink();
+    var streams = require_streams();
+    var tmpDir = require_tmp_dir();
+    var write = require_write();
+    var jetpackContext = (cwdPath) => {
+      const getCwdPath = () => {
+        return cwdPath || process.cwd();
+      };
+      const cwd = function() {
+        if (arguments.length === 0) {
+          return getCwdPath();
+        }
+        const args = Array.prototype.slice.call(arguments);
+        const pathParts = [getCwdPath()].concat(args);
+        return jetpackContext(pathUtil.resolve.apply(null, pathParts));
+      };
+      const resolvePath = (path2) => {
+        return pathUtil.resolve(getCwdPath(), path2);
+      };
+      const getPath = function() {
+        Array.prototype.unshift.call(arguments, getCwdPath());
+        return pathUtil.resolve.apply(null, arguments);
+      };
+      const normalizeOptions = (options) => {
+        const opts = options || {};
+        opts.cwd = getCwdPath();
+        return opts;
+      };
+      const api = {
+        cwd,
+        path: getPath,
+        append: (path2, data, options) => {
+          append.validateInput("append", path2, data, options);
+          append.sync(resolvePath(path2), data, options);
+        },
+        appendAsync: (path2, data, options) => {
+          append.validateInput("appendAsync", path2, data, options);
+          return append.async(resolvePath(path2), data, options);
+        },
+        copy: (from, to, options) => {
+          copy.validateInput("copy", from, to, options);
+          copy.sync(resolvePath(from), resolvePath(to), options);
+        },
+        copyAsync: (from, to, options) => {
+          copy.validateInput("copyAsync", from, to, options);
+          return copy.async(resolvePath(from), resolvePath(to), options);
+        },
+        createWriteStream: (path2, options) => {
+          return streams.createWriteStream(resolvePath(path2), options);
+        },
+        createReadStream: (path2, options) => {
+          return streams.createReadStream(resolvePath(path2), options);
+        },
+        dir: (path2, criteria) => {
+          dir.validateInput("dir", path2, criteria);
+          const normalizedPath = resolvePath(path2);
+          dir.sync(normalizedPath, criteria);
+          return cwd(normalizedPath);
+        },
+        dirAsync: (path2, criteria) => {
+          dir.validateInput("dirAsync", path2, criteria);
+          return new Promise((resolve, reject) => {
+            const normalizedPath = resolvePath(path2);
+            dir.async(normalizedPath, criteria).then(() => {
+              resolve(cwd(normalizedPath));
+            }, reject);
+          });
+        },
+        exists: (path2) => {
+          exists.validateInput("exists", path2);
+          return exists.sync(resolvePath(path2));
+        },
+        existsAsync: (path2) => {
+          exists.validateInput("existsAsync", path2);
+          return exists.async(resolvePath(path2));
+        },
+        file: (path2, criteria) => {
+          file.validateInput("file", path2, criteria);
+          file.sync(resolvePath(path2), criteria);
+          return api;
+        },
+        fileAsync: (path2, criteria) => {
+          file.validateInput("fileAsync", path2, criteria);
+          return new Promise((resolve, reject) => {
+            file.async(resolvePath(path2), criteria).then(() => {
+              resolve(api);
+            }, reject);
+          });
+        },
+        find: (startPath, options) => {
+          if (typeof options === "undefined" && typeof startPath === "object") {
+            options = startPath;
+            startPath = ".";
+          }
+          find.validateInput("find", startPath, options);
+          return find.sync(resolvePath(startPath), normalizeOptions(options));
+        },
+        findAsync: (startPath, options) => {
+          if (typeof options === "undefined" && typeof startPath === "object") {
+            options = startPath;
+            startPath = ".";
+          }
+          find.validateInput("findAsync", startPath, options);
+          return find.async(resolvePath(startPath), normalizeOptions(options));
+        },
+        inspect: (path2, fieldsToInclude) => {
+          inspect.validateInput("inspect", path2, fieldsToInclude);
+          return inspect.sync(resolvePath(path2), fieldsToInclude);
+        },
+        inspectAsync: (path2, fieldsToInclude) => {
+          inspect.validateInput("inspectAsync", path2, fieldsToInclude);
+          return inspect.async(resolvePath(path2), fieldsToInclude);
+        },
+        inspectTree: (path2, options) => {
+          inspectTree.validateInput("inspectTree", path2, options);
+          return inspectTree.sync(resolvePath(path2), options);
+        },
+        inspectTreeAsync: (path2, options) => {
+          inspectTree.validateInput("inspectTreeAsync", path2, options);
+          return inspectTree.async(resolvePath(path2), options);
+        },
+        list: (path2) => {
+          list.validateInput("list", path2);
+          return list.sync(resolvePath(path2 || "."));
+        },
+        listAsync: (path2) => {
+          list.validateInput("listAsync", path2);
+          return list.async(resolvePath(path2 || "."));
+        },
+        move: (from, to, options) => {
+          move.validateInput("move", from, to, options);
+          move.sync(resolvePath(from), resolvePath(to), options);
+        },
+        moveAsync: (from, to, options) => {
+          move.validateInput("moveAsync", from, to, options);
+          return move.async(resolvePath(from), resolvePath(to), options);
+        },
+        read: (path2, returnAs) => {
+          read.validateInput("read", path2, returnAs);
+          return read.sync(resolvePath(path2), returnAs);
+        },
+        readAsync: (path2, returnAs) => {
+          read.validateInput("readAsync", path2, returnAs);
+          return read.async(resolvePath(path2), returnAs);
+        },
+        remove: (path2) => {
+          remove.validateInput("remove", path2);
+          remove.sync(resolvePath(path2 || "."));
+        },
+        removeAsync: (path2) => {
+          remove.validateInput("removeAsync", path2);
+          return remove.async(resolvePath(path2 || "."));
+        },
+        rename: (path2, newName, options) => {
+          rename.validateInput("rename", path2, newName, options);
+          rename.sync(resolvePath(path2), newName, options);
+        },
+        renameAsync: (path2, newName, options) => {
+          rename.validateInput("renameAsync", path2, newName, options);
+          return rename.async(resolvePath(path2), newName, options);
+        },
+        symlink: (symlinkValue, path2) => {
+          symlink.validateInput("symlink", symlinkValue, path2);
+          symlink.sync(symlinkValue, resolvePath(path2));
+        },
+        symlinkAsync: (symlinkValue, path2) => {
+          symlink.validateInput("symlinkAsync", symlinkValue, path2);
+          return symlink.async(symlinkValue, resolvePath(path2));
+        },
+        tmpDir: (options) => {
+          tmpDir.validateInput("tmpDir", options);
+          const pathOfCreatedDirectory = tmpDir.sync(getCwdPath(), options);
+          return cwd(pathOfCreatedDirectory);
+        },
+        tmpDirAsync: (options) => {
+          tmpDir.validateInput("tmpDirAsync", options);
+          return new Promise((resolve, reject) => {
+            tmpDir.async(getCwdPath(), options).then((pathOfCreatedDirectory) => {
+              resolve(cwd(pathOfCreatedDirectory));
+            }, reject);
+          });
+        },
+        write: (path2, data, options) => {
+          write.validateInput("write", path2, data, options);
+          write.sync(resolvePath(path2), data, options);
+        },
+        writeAsync: (path2, data, options) => {
+          write.validateInput("writeAsync", path2, data, options);
+          return write.async(resolvePath(path2), data, options);
+        }
+      };
+      if (util.inspect.custom !== void 0) {
+        api[util.inspect.custom] = () => {
+          return `[fs-jetpack CWD: ${getCwdPath()}]`;
+        };
+      }
+      return api;
+    };
+    module2.exports = jetpackContext;
+  }
+});
+var require_main = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../../node_modules/.pnpm/fs-jetpack@5.1.0/node_modules/fs-jetpack/main.js"(exports, module2) {
+    "use strict";
+    var jetpack = require_jetpack();
+    module2.exports = jetpack();
+  }
+});
+var import_fs_jetpack = (0, import_chunk_2ESYSVXG.__toESM)(require_main());
+var debug = (0, import_debug.default)("prisma:migrate:diff");
+var helpOptions = (0, import_internals.format)(
+  `${(0, import_chunk_SKRR5WT4.bold)("Usage")}
+
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff [options]
+
+${(0, import_chunk_SKRR5WT4.bold)("Options")}
+
+  -h, --help               Display this help message
+  --config                 Custom path to your Prisma config file
+  -o, --output             Writes to a file instead of stdout
+
+${(0, import_chunk_SKRR5WT4.italic)("From and To inputs (1 `--from-...` and 1 `--to-...` must be provided):")}
+  --from-empty             Flag to assume from or to is an empty datamodel
+  --to-empty
+
+  --from-schema            Path to a Prisma schema file, uses the ${(0, import_chunk_SKRR5WT4.italic)("datamodel")} for the diff
+  --to-schema
+
+  --from-migrations        Path to the Prisma Migrate migrations directory
+  --to-migrations
+
+  --from-config-datasource Flag to use the datasource from the Prisma config file
+  --to-config-datasource
+
+${(0, import_chunk_SKRR5WT4.bold)("Flags")}
+
+  --script                 Render a SQL script to stdout instead of the default human readable summary (not supported on MongoDB)
+  --exit-code              Change the exit code behavior to signal if the diff is empty or not (Empty: 0, Error: 1, Not empty: 2). Default behavior is Success: 0, Error: 1.`
+);
+var MigrateDiff = class _MigrateDiff {
+  static new() {
+    return new _MigrateDiff();
+  }
+  static help = (0, import_internals.format)(`
+${process.platform === "win32" ? "" : "\u{1F50D} "}Compares the database schema from two arbitrary sources, and outputs the differences either as a human-readable summary (by default) or an executable script.
+
+${(0, import_chunk_SKRR5WT4.green)(`prisma migrate diff`)} is a read-only command that does not write to your datasource(s).
+${(0, import_chunk_SKRR5WT4.green)(`prisma db execute`)} can be used to execute its ${(0, import_chunk_SKRR5WT4.green)(`--script`)} output.
+
+The command takes a source ${(0, import_chunk_SKRR5WT4.green)(`--from-...`)} and a destination ${(0, import_chunk_SKRR5WT4.green)(`--to-...`)}.
+The source and destination must use the same provider,
+e.g. a diff using 2 different providers like PostgreSQL and SQLite is not supported.
+
+It compares the source with the destination to generate a diff.
+The diff can be interpreted as generating a migration that brings the source schema (from) to the shape of the destination schema (to).
+The default output is a human readable diff, it can be rendered as SQL using \`--script\` on SQL databases.
+
+See the documentation for more information ${(0, import_internals.link)("https://pris.ly/d/migrate-diff")}
+
+${helpOptions}
+${(0, import_chunk_SKRR5WT4.bold)("Examples")}
+
+  From the configured database to a Prisma datamodel
+    e.g. roll forward after a migration failed in the middle
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff \\
+    --from-config-datasource \\
+    --to-schema=next_datamodel.prisma \\
+    --script
+
+  From a peisma datamodel to the configured database
+    e.g. roll forward after a migration failed in the middle
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff \\
+    --from-schema=next_datamodel.prisma \\
+    --to-config-datasource \\
+    --script
+
+  From a Prisma Migrate \`migrations\` directory to the configured database
+    e.g. generate a migration for a hotfix already applied on production
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff \\
+    --from-migrations ./migrations \\
+    --to-config-datasource \\
+    --script
+
+  Execute the --script output with \`prisma db execute\` using bash pipe \`|\`
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff \\
+    --from-[...] \\
+    --to-[...] \\
+    --script | prisma db execute --stdin --url="$DATABASE_URL"
+
+  Detect if both sources are in sync, it will exit with exit code 2 if changes are detected
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate diff \\
+    --exit-code \\
+    --from-[...] \\
+    --to-[...]
+`);
+  async parse(argv, config, baseDir) {
+    const args = (0, import_internals.arg)(
+      argv,
+      {
+        "--help": Boolean,
+        "-h": "--help",
+        "--output": String,
+        "-o": "--output",
+        // From
+        "--from-empty": Boolean,
+        "--from-config-datasource": Boolean,
+        "--from-schema": String,
+        "--from-migrations": String,
+        // To
+        "--to-empty": Boolean,
+        "--to-config-datasource": Boolean,
+        "--to-schema": String,
+        "--to-migrations": String,
+        // Others
+        "--script": Boolean,
+        "--exit-code": Boolean,
+        "--telemetry-information": String,
+        "--config": String,
+        // Removed, but parsed to show help error
+        "--from-url": String,
+        "--to-url": String,
+        "--from-schema-datasource": String,
+        "--to-schema-datasource": String,
+        "--from-schema-datamodel": String,
+        "--to-schema-datamodel": String,
+        "--from-local-d1": Boolean,
+        "--to-local-d1": Boolean
+      },
+      false
+    );
+    if ((0, import_internals.isError)(args)) {
+      return this.help(args.message);
+    }
+    if (args["--help"]) {
+      return this.help();
+    }
+    const removedTargetParameterHint = Object.keys(args).map(getRemovedTargetParameterHint).find((msg) => msg !== void 0);
+    if (removedTargetParameterHint) {
+      return this.help(removedTargetParameterHint);
+    }
+    const numberOfFromParameterProvided = Number(Boolean(args["--from-empty"])) + Number(Boolean(args["--from-config-datasource"])) + Number(Boolean(args["--from-schema"])) + Number(Boolean(args["--from-migrations"]));
+    const numberOfToParameterProvided = Number(Boolean(args["--to-empty"])) + Number(Boolean(args["--to-config-datasource"])) + Number(Boolean(args["--to-schema"])) + Number(Boolean(args["--to-migrations"]));
+    if (numberOfFromParameterProvided !== 1 || numberOfToParameterProvided !== 1) {
+      const errorMessages = [];
+      if (numberOfFromParameterProvided !== 1) {
+        errorMessages.push(`${numberOfFromParameterProvided} \`--from-...\` parameter(s) provided. 1 must be provided.`);
+      }
+      if (numberOfToParameterProvided !== 1) {
+        errorMessages.push(`${numberOfToParameterProvided} \`--to-...\` parameter(s) provided. 1 must be provided.`);
+      }
+      return this.help(`${errorMessages.join("\n")}`);
+    }
+    let from;
+    if (args["--from-empty"]) {
+      from = {
+        tag: "empty"
+      };
+    } else if (args["--from-schema"]) {
+      const schema = await (0, import_internals.getSchemaWithPath)({
+        schemaPath: (0, import_internals.createSchemaPathInput)({
+          schemaPathFromArgs: import_path.default.resolve(args["--from-schema"]),
+          schemaPathFromConfig: config.schema,
+          baseDir
+        }),
+        argumentName: "--from-schema"
+      });
+      from = {
+        tag: "schemaDatamodel",
+        ...(0, import_internals.toSchemasContainer)(schema.schemas)
+      };
+    } else if (args["--from-migrations"]) {
+      from = {
+        tag: "migrations",
+        ...await (0, import_chunk_GGA2F64G.listMigrations)(args["--from-migrations"], config.migrations?.initShadowDb ?? "")
+      };
+    } else if (args["--from-config-datasource"]) {
+      const schemaContext = await (0, import_internals.loadSchemaContext)({
+        schemaPath: (0, import_internals.createSchemaPathInput)({ schemaPathFromConfig: config.schema, baseDir }),
+        printLoadMessage: false
+      });
+      from = {
+        tag: "schemaDatasource",
+        ...(0, import_internals.toSchemasWithConfigDir)(schemaContext, baseDir)
+      };
+    }
+    let to;
+    if (args["--to-empty"]) {
+      to = {
+        tag: "empty"
+      };
+    } else if (args["--to-schema"]) {
+      const schema = await (0, import_internals.getSchemaWithPath)({
+        schemaPath: (0, import_internals.createSchemaPathInput)({
+          schemaPathFromArgs: import_path.default.resolve(args["--to-schema"]),
+          schemaPathFromConfig: config.schema,
+          baseDir
+        }),
+        argumentName: "--to-schema"
+      });
+      to = {
+        tag: "schemaDatamodel",
+        ...(0, import_internals.toSchemasContainer)(schema.schemas)
+      };
+    } else if (args["--to-migrations"]) {
+      to = {
+        tag: "migrations",
+        ...await (0, import_chunk_GGA2F64G.listMigrations)(args["--to-migrations"], config.migrations?.initShadowDb ?? "")
+      };
+    } else if (args["--to-config-datasource"]) {
+      const schemaContext = await (0, import_internals.loadSchemaContext)({
+        schemaPath: (0, import_internals.createSchemaPathInput)({ schemaPathFromConfig: config.schema, baseDir }),
+        printLoadMessage: false
+      });
+      to = {
+        tag: "schemaDatasource",
+        ...(0, import_internals.toSchemasWithConfigDir)(schemaContext, baseDir)
+      };
+    }
+    const schemaFilter = {
+      externalTables: config.tables?.external ?? [],
+      externalEnums: config.enums?.external ?? []
+    };
+    const migrate = await import_chunk_WRBJ3RMF.Migrate.setup({
+      schemaEngineConfig: config,
+      baseDir,
+      schemaFilter,
+      extensions: config["extensions"]
+    });
+    const captureStdout = new import_chunk_VAJ4VX67.CaptureStdout();
+    const outputPath = args["--output"];
+    const isOutputDefined = Boolean(outputPath);
+    if (isOutputDefined) {
+      captureStdout.startCapture();
+    }
+    let result;
+    try {
+      result = await migrate.engine.migrateDiff({
+        from,
+        to,
+        script: args["--script"] || false,
+        // default is false
+        shadowDatabaseUrl: args["--shadow-database-url"] ?? null,
+        exitCode: args["--exit-code"] ?? null,
+        filters: {
+          externalTables: config.tables?.external ?? [],
+          externalEnums: config.enums?.external ?? []
+        }
+      });
+    } finally {
+      await migrate.stop();
+    }
+    if (isOutputDefined) {
+      captureStdout.stopCapture();
+      const diffOutput = captureStdout.getCapturedText();
+      captureStdout.clearCaptureText();
+      await import_fs_jetpack.default.writeAsync(outputPath, diffOutput.join("\n"));
+    }
+    debug({ migrateDiffOutput: result });
+    if (args["--exit-code"] && result.exitCode) {
+      process.exit(result.exitCode);
+    }
+    return ``;
+  }
+  help(error) {
+    if (error) {
+      throw new import_internals.HelpError(`
+${error}
+
+${helpOptions}`);
+    }
+    return _MigrateDiff.help;
+  }
+};
+function getRemovedTargetParameterHint(parameter) {
+  switch (parameter) {
+    case "--from-url":
+    case "--to-url":
+    case "--from-schema-datasource":
+    case "--to-schema-datasource":
+      return `\`${parameter}\` was removed. Please use \`--[from/to]-config-datasource\` in combination with a Prisma config file that contains the appropriate datasource instead.`;
+    case "--from-schema-datamodel":
+    case "--to-schema-datamodel":
+      return `\`${parameter}\` was removed. Please use \`--[from/to]-schema\` instead.`;
+    case "--from-local-d1":
+    case "--to-local-d1":
+      return `\`${parameter}\` was removed. Please use \`--[from/to]-config-datasource\` in combination with a Prisma config file that contains the appropriate datasource instead. The \`@prisma/adapter-d1\` package exposes a \`listLocalDatabases()\` helper function to help you locate your local D1 databases. You can use the paths returned from that function to construct your datasource URL(s).`;
+    default:
+      return;
+  }
+}