drizzle-kit 0.16.9-19c6550 → 0.16.9-1f064f4

package/index.js

@@ -6338,7 +6338,8 @@ var init_mysqlSchema = __esm({
       primaryKey: booleanType(),
       notNull: booleanType(),
       autoincrement: booleanType().optional(),
-      default: anyType().optional()
+      default: anyType().optional(),
+      onUpdate: anyType().optional()
     }).strict();
     tableV3 = objectType({
       name: stringType(),
@@ -13204,6 +13205,32 @@ var init_jsonDiffer = __esm({
           return { ...others, notNull: { type: "deleted", value: it.notNull__deleted } };
         }
         return it;
+      }).map((it) => {
+        if ("onUpdate" in it) {
+          return { ...it, onUpdate: { type: "changed", old: it.onUpdate.__old, new: it.onUpdate.__new } };
+        }
+        if ("onUpdate__added" in it) {
+          const { onUpdate__added, ...others } = it;
+          return { ...others, onUpdate: { type: "added", value: it.onUpdate__added } };
+        }
+        if ("onUpdate__deleted" in it) {
+          const { onUpdate__deleted, ...others } = it;
+          return { ...others, onUpdate: { type: "deleted", value: it.onUpdate__deleted } };
+        }
+        return it;
+      }).map((it) => {
+        if ("autoincrement" in it) {
+          return { ...it, autoincrement: { type: "changed", old: it.autoincrement.__old, new: it.autoincrement.__new } };
+        }
+        if ("autoincrement__added" in it) {
+          const { autoincrement__added, ...others } = it;
+          return { ...others, autoincrement: { type: "added", value: it.autoincrement__added } };
+        }
+        if ("autoincrement__deleted" in it) {
+          const { autoincrement__deleted, ...others } = it;
+          return { ...others, autoincrement: { type: "deleted", value: it.autoincrement__deleted } };
+        }
+        return it;
       });
       return result[0];
     };
@@ -13211,7 +13238,7 @@ var init_jsonDiffer = __esm({
 });
 
 // src/sqlgenerator.ts
-var pgNativeTypes, isPgNativeType, Convertor, PgCreateTableConvertor, MySqlCreateTableConvertor, SQLiteCreateTableConvertor, CreateTypeEnumConvertor, AlterTypeAddValueConvertor, DropTableConvertor, PgRenameTableConvertor, SqliteRenameTableConvertor, MySqlRenameTableConvertor, PgAlterTableRenameColumnConvertor, MySqlAlterTableRenameColumnConvertor, SQLiteAlterTableRenameColumnConvertor, PgAlterTableDropColumnConvertor, MySqlAlterTableDropColumnConvertor, SQLiteAlterTableDropColumnConvertor, PgAlterTableAddColumnConvertor, MySqlAlterTableAddColumnConvertor, SQLiteAlterTableAddColumnConvertor, PgAlterTableAlterColumnSetTypeConvertor, SQLiteAlterTableAlterColumnSetTypeConvertor, PgAlterTableAlterColumnSetDefaultConvertor, SqliteAlterTableAlterColumnSetDefaultConvertor, PgAlterTableAlterColumnDropDefaultConvertor, SqliteAlterTableAlterColumnDropDefaultConvertor, SqliteAlterTableCreateCompositePrimaryKeyConvertor, SqliteAlterTableDeleteCompositePrimaryKeyConvertor, SqliteAlterTableAlterCompositePrimaryKeyConvertor, PgAlterTableAlterColumnSetNotNullConvertor, SqliteAlterTableAlterColumnSetNotNullConvertor, PgAlterTableAlterColumnDropNotNullConvertor, SqliteAlterTableAlterColumnDropNotNullConvertor, PgCreateForeignKeyConvertor, SqliteCreateForeignKeyConvertor, MySqlCreateForeignKeyConvertor, PgAlterForeignKeyConvertor, SqliteAlterForeignKeyConvertor, PgDeleteForeignKeyConvertor, SqliteDeleteForeignKeyConvertor, MySqlDeleteForeignKeyConvertor, CreatePgIndexConvertor, CreateMySqlIndexConvertor, CreateSqliteIndexConvertor, PgDropIndexConvertor, PgCreateSchemaConvertor, PgRenameSchemaConvertor, PgDropSchemaConvertor, PgAlterTableSetSchemaConvertor, PgAlterTableSetNewSchemaConvertor, PgAlterTableRemoveFromSchemaConvertor, SqliteDropIndexConvertor, MysqlCreateSchemaConvertor, MysqlDropSchemaConvertor, MysqlAlterTableSetSchemaConvertor, MysqlAlterTableSetNewSchemaConvertor, MysqlAlterTableRemoveFromSchemaConvertor, convertors, fromJson;
+var pgNativeTypes, isPgNativeType, Convertor, PgCreateTableConvertor, MySqlCreateTableConvertor, SQLiteCreateTableConvertor, CreateTypeEnumConvertor, AlterTypeAddValueConvertor, DropTableConvertor, PgRenameTableConvertor, SqliteRenameTableConvertor, MySqlRenameTableConvertor, PgAlterTableRenameColumnConvertor, MySqlAlterTableRenameColumnConvertor, SQLiteAlterTableRenameColumnConvertor, PgAlterTableDropColumnConvertor, MySqlAlterTableDropColumnConvertor, SQLiteAlterTableDropColumnConvertor, PgAlterTableAddColumnConvertor, MySqlAlterTableAddColumnConvertor, SQLiteAlterTableAddColumnConvertor, PgAlterTableAlterColumnSetTypeConvertor, SQLiteAlterTableAlterColumnSetTypeConvertor, PgAlterTableAlterColumnSetDefaultConvertor, SqliteAlterTableAlterColumnSetDefaultConvertor, PgAlterTableAlterColumnDropDefaultConvertor, MySqlAlterTableAlterColumnSetDefaultConvertor, MySqlAlterTableAlterColumnDropDefaultConvertor, MySqlModifyColumn, SqliteAlterTableAlterColumnDropDefaultConvertor, SqliteAlterTableCreateCompositePrimaryKeyConvertor, SqliteAlterTableDeleteCompositePrimaryKeyConvertor, SqliteAlterTableAlterCompositePrimaryKeyConvertor, PgAlterTableAlterColumnSetNotNullConvertor, SqliteAlterTableAlterColumnSetNotNullConvertor, PgAlterTableAlterColumnDropNotNullConvertor, SqliteAlterTableAlterColumnDropNotNullConvertor, PgCreateForeignKeyConvertor, SqliteCreateForeignKeyConvertor, MySqlCreateForeignKeyConvertor, PgAlterForeignKeyConvertor, SqliteAlterForeignKeyConvertor, PgDeleteForeignKeyConvertor, SqliteDeleteForeignKeyConvertor, MySqlDeleteForeignKeyConvertor, CreatePgIndexConvertor, CreateMySqlIndexConvertor, CreateSqliteIndexConvertor, PgDropIndexConvertor, PgCreateSchemaConvertor, PgRenameSchemaConvertor, PgDropSchemaConvertor, PgAlterTableSetSchemaConvertor, PgAlterTableSetNewSchemaConvertor, PgAlterTableRemoveFromSchemaConvertor, SqliteDropIndexConvertor, MysqlCreateSchemaConvertor, MysqlDropSchemaConvertor, MysqlAlterTableSetSchemaConvertor, MysqlAlterTableSetNewSchemaConvertor, MysqlAlterTableRemoveFromSchemaConvertor, MySqlDropIndexConvertor, convertors, fromJson;
 var init_sqlgenerator = __esm({
   "src/sqlgenerator.ts"() {
     init_mysqlSchema();
@@ -13293,8 +13320,9 @@ var init_sqlgenerator = __esm({
           const primaryKeyStatement = column6.primaryKey ? "PRIMARY KEY" : "";
           const notNullStatement = column6.notNull ? "NOT NULL" : "";
           const defaultStatement = column6.default !== void 0 ? `DEFAULT ${column6.default}` : "";
+          const onUpdateStatement = column6.onUpdate ? `ON UPDATE CURRENT_TIMESTAMP` : "";
           const autoincrementStatement = column6.autoincrement ? "AUTO_INCREMENT" : "";
-          statement += "	" + `\`${column6.name}\` ${column6.type} ${autoincrementStatement} ${primaryKeyStatement} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, " ").trim();
+          statement += "	" + `\`${column6.name}\` ${column6.type} ${autoincrementStatement} ${primaryKeyStatement} ${notNullStatement} ${defaultStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
           statement += (i === columns.length - 1 ? "" : ",") + "\n";
         }
         statement += `);`;
@@ -13578,6 +13606,82 @@ var init_sqlgenerator = __esm({
         return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" DROP DEFAULT;`;
       }
     };
+    MySqlAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
+      can(statement, dialect6) {
+        return statement.type === "alter_table_alter_column_set_default" && dialect6 === "mysql";
+      }
+      convert(statement) {
+        const { tableName, columnName } = statement;
+        return `ALTER TABLE ${tableName} ALTER COLUMN \`${columnName}\` SET DEFAULT ${statement.newDefaultValue};`;
+      }
+    };
+    MySqlAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
+      can(statement, dialect6) {
+        return statement.type === "alter_table_alter_column_drop_default" && dialect6 === "mysql";
+      }
+      convert(statement) {
+        const { tableName, columnName } = statement;
+        return `ALTER TABLE ${tableName} ALTER COLUMN \`${columnName}\` DROP DEFAULT;`;
+      }
+    };
+    MySqlModifyColumn = class extends Convertor {
+      can(statement, dialect6) {
+        return (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_on_update" || statement.type === "alter_table_alter_column_set_on_update" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_autoincrement") && dialect6 === "mysql";
+      }
+      convert(statement) {
+        const { tableName, columnName } = statement;
+        let columnType = ``;
+        let columnDefault = "";
+        let columnNotNull = "";
+        let columnOnUpdate = "";
+        let columnAutoincrement = "";
+        if (statement.type === "alter_table_alter_column_drop_notnull") {
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
+          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
+        } else if (statement.type === "alter_table_alter_column_set_notnull") {
+          columnNotNull = ` NOT NULL`;
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
+          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
+        } else if (statement.type === "alter_table_alter_column_drop_on_update") {
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnOnUpdate = "";
+          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
+        } else if (statement.type === "alter_table_alter_column_set_on_update") {
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
+        } else if (statement.type === "alter_table_alter_column_set_autoincrement") {
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnAutoincrement = "AUTO_INCREMENT";
+        } else if (statement.type === "alter_table_alter_column_drop_autoincrement") {
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
+          columnType = ` ${statement.newDataType}`;
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnAutoincrement = "";
+        } else {
+          columnType = ` ${statement.newDataType}`;
+          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
+          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
+          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
+          columnAutoincrement = statement.columnAutoIncrement ? "AUTO_INCREMENT" : "";
+        }
+        columnDefault = columnDefault instanceof Date ? columnDefault.toISOString() : columnDefault;
+        return `ALTER TABLE ${tableName} MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnNotNull}${columnDefault}${columnOnUpdate};`;
+      }
+    };
     SqliteAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
       can(statement, dialect6) {
         return statement.type === "alter_table_alter_column_drop_default" && dialect6 === "sqlite";
@@ -14029,6 +14133,16 @@ var init_sqlgenerator = __esm({
 `;
       }
     };
+    MySqlDropIndexConvertor = class extends Convertor {
+      can(statement, dialect6) {
+        return statement.type === "drop_index" && dialect6 === "mysql";
+      }
+      convert(statement) {
+        const tableName = typeof statement.schema === "undefined" ? `\`${statement.tableName}\`` : `\`${statement.schema}\`.\`${statement.tableName}\``;
+        const { name } = MySqlSquasher.unsquashIdx(statement.data);
+        return `DROP INDEX ${name} ON ${tableName};`;
+      }
+    };
     convertors = [];
     convertors.push(new PgCreateTableConvertor());
     convertors.push(new MySqlCreateTableConvertor());
@@ -14053,11 +14167,15 @@ var init_sqlgenerator = __esm({
     convertors.push(new CreateSqliteIndexConvertor());
     convertors.push(new PgDropIndexConvertor());
     convertors.push(new SqliteDropIndexConvertor());
+    convertors.push(new MySqlDropIndexConvertor());
     convertors.push(new AlterTypeAddValueConvertor());
     convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
     convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
     convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
     convertors.push(new PgAlterTableAlterColumnDropDefaultConvertor());
+    convertors.push(new MySqlModifyColumn());
+    convertors.push(new MySqlAlterTableAlterColumnSetDefaultConvertor());
+    convertors.push(new MySqlAlterTableAlterColumnDropDefaultConvertor());
     convertors.push(new PgCreateForeignKeyConvertor());
     convertors.push(new MySqlCreateForeignKeyConvertor());
     convertors.push(new PgAlterForeignKeyConvertor());
@@ -14092,7 +14210,7 @@ var init_sqlgenerator = __esm({
         });
         const convertor = filtered.length === 1 ? filtered[0] : void 0;
         if (!convertor) {
-          console.log("no convertor:", statement.type);
+          console.log("no convertor:", statement.type, dialect6);
           return "dry run";
         }
         return convertor.convert(statement);
@@ -14222,10 +14340,10 @@ var init_jsonStatements = __esm({
         };
       });
     };
-    prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, dialect6) => {
+    prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, json2, dialect6) => {
       const addColumns = [];
       const dropColumns = _prepareDropColumns(tableName, schema4, deleted);
-      const alterColumns = _prepareAlterColumns(tableName, schema4, altered);
+      const alterColumns = _prepareAlterColumns(tableName, schema4, altered, json2);
       if (dialect6 === "sqlite") {
         let jsonCreateFKStatements = Object.values(addedFk);
         const sqliteAddColumns = _prepareSQLiteAddColumns(
@@ -14275,11 +14393,16 @@ var init_jsonStatements = __esm({
         };
       });
     };
-    _prepareAlterColumns = (tableName, schema4, columns) => {
-      var _a, _b, _c, _d, _e, _f, _g;
+    _prepareAlterColumns = (tableName, schema4, columns, json2) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
       let statements = [];
       for (const column6 of columns) {
         const columnName = typeof column6.name !== "string" ? column6.name.new : column6.name;
+        const columnType = json2.tables[tableName].columns[columnName].type;
+        const columnDefault = json2.tables[tableName].columns[columnName].default;
+        const columnOnUpdate = json2.tables[tableName].columns[columnName].onUpdate;
+        const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
+        const columnAutoIncrement = json2.tables[tableName].columns[columnName].autoincrement;
         if (typeof column6.name !== "string") {
           statements.push({
             type: "alter_table_rename_column",
@@ -14295,7 +14418,11 @@ var init_jsonStatements = __esm({
             tableName,
             columnName,
             newDataType: column6.type.new,
-            schema: schema4
+            schema: schema4,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
           });
         }
         if (((_b = column6.default) == null ? void 0 : _b.type) === "added") {
@@ -14329,7 +14456,12 @@ var init_jsonStatements = __esm({
             type: "alter_table_alter_column_set_notnull",
             tableName,
             columnName,
-            schema: schema4
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
           });
         }
         if (((_f = column6.notNull) == null ? void 0 : _f.type) === "changed") {
@@ -14338,7 +14470,12 @@ var init_jsonStatements = __esm({
             type,
             tableName,
             columnName,
-            schema: schema4
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
           });
         }
         if (((_g = column6.notNull) == null ? void 0 : _g.type) === "deleted") {
@@ -14346,7 +14483,78 @@ var init_jsonStatements = __esm({
             type: "alter_table_alter_column_drop_notnull",
             tableName,
             columnName,
-            schema: schema4
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
+          });
+        }
+        if (((_h = column6.autoincrement) == null ? void 0 : _h.type) === "added") {
+          statements.push({
+            type: "alter_table_alter_column_set_autoincrement",
+            tableName,
+            columnName,
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
+          });
+        }
+        if (((_i = column6.autoincrement) == null ? void 0 : _i.type) === "changed") {
+          const type = column6.autoincrement.new ? "alter_table_alter_column_set_notnull" : "alter_table_alter_column_drop_notnull";
+          statements.push({
+            type,
+            tableName,
+            columnName,
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
+          });
+        }
+        if (((_j = column6.autoincrement) == null ? void 0 : _j.type) === "deleted") {
+          statements.push({
+            type: "alter_table_alter_column_drop_autoincrement",
+            tableName,
+            columnName,
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
+          });
+        }
+        if (((_k = column6.onUpdate) == null ? void 0 : _k.type) === "added") {
+          statements.push({
+            type: "alter_table_alter_column_set_on_update",
+            tableName,
+            columnName,
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
+          });
+        }
+        if (((_l = column6.onUpdate) == null ? void 0 : _l.type) === "deleted") {
+          statements.push({
+            type: "alter_table_alter_column_drop_on_update",
+            tableName,
+            columnName,
+            schema: schema4,
+            newDataType: columnType,
+            columnDefault,
+            columnOnUpdate,
+            columnNotNull,
+            columnAutoIncrement
           });
         }
       }
@@ -14517,13 +14725,16 @@ var init_snapshotsDiffer = __esm({
       unique: booleanType().optional(),
       default: anyType().optional(),
       notNull: booleanType().optional(),
-      autoincrement: booleanType().optional()
+      autoincrement: booleanType().optional(),
+      onUpdate: booleanType().optional()
     }).strict();
     alteredColumnSchema = objectType({
       name: makeSelfOrChanged(stringType()),
       type: makeChanged(stringType()).optional(),
       default: makePatched(anyType()).optional(),
-      notNull: makePatched(booleanType()).optional()
+      notNull: makePatched(booleanType()).optional(),
+      onUpdate: makePatched(booleanType()).optional(),
+      autoincrement: makePatched(booleanType()).optional()
     }).strict();
     enumSchema2 = objectType({
       name: stringType(),
@@ -14731,6 +14942,7 @@ var init_snapshotsDiffer = __esm({
           it.added,
           it.altered,
           it.addedForeignKeys,
+          json2,
           dialect6
         );
       }).flat().reduce(
@@ -14825,8 +15037,14 @@ var init_snapshotsDiffer = __esm({
       jsonStatements.push(...jsonRemoveTableFromSchemas);
       jsonStatements.push(...dropSchemas);
       const sqlStatements = fromJson(jsonStatements, dialect6);
+      const uniqueSqlStatements = [];
+      sqlStatements.forEach((ss) => {
+        if (!uniqueSqlStatements.includes(ss)) {
+          uniqueSqlStatements.push(ss);
+        }
+      });
       const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
-      return { statements: jsonStatements, sqlStatements, _meta };
+      return { statements: jsonStatements, sqlStatements: uniqueSqlStatements, _meta };
     };
   }
 });
@@ -22337,6 +22555,2337 @@ var require_node2 = __commonJS({
   }
 });
 
+// node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
+var require_old = __commonJS({
+  "node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
+    var pathModule = require("path");
+    var isWindows = process.platform === "win32";
+    var fs7 = require("fs");
+    var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+    function rethrow() {
+      var callback;
+      if (DEBUG) {
+        var backtrace = new Error();
+        callback = debugCallback;
+      } else
+        callback = missingCallback;
+      return callback;
+      function debugCallback(err2) {
+        if (err2) {
+          backtrace.message = err2.message;
+          err2 = backtrace;
+          missingCallback(err2);
+        }
+      }
+      function missingCallback(err2) {
+        if (err2) {
+          if (process.throwDeprecation)
+            throw err2;
+          else if (!process.noDeprecation) {
+            var msg = "fs: missing callback " + (err2.stack || err2.message);
+            if (process.traceDeprecation)
+              console.trace(msg);
+            else
+              console.error(msg);
+          }
+        }
+      }
+    }
+    function maybeCallback(cb) {
+      return typeof cb === "function" ? cb : rethrow();
+    }
+    var normalize = pathModule.normalize;
+    if (isWindows) {
+      nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+    } else {
+      nextPartRe = /(.*?)(?:[\/]+|$)/g;
+    }
+    var nextPartRe;
+    if (isWindows) {
+      splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+    } else {
+      splitRootRe = /^[\/]*/;
+    }
+    var splitRootRe;
+    exports.realpathSync = function realpathSync(p, cache) {
+      p = pathModule.resolve(p);
+      if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+        return cache[p];
+      }
+      var original = p, seenLinks = {}, knownHard = {};
+      var pos;
+      var current;
+      var base;
+      var previous;
+      start();
+      function start() {
+        var m = splitRootRe.exec(p);
+        pos = m[0].length;
+        current = m[0];
+        base = m[0];
+        previous = "";
+        if (isWindows && !knownHard[base]) {
+          fs7.lstatSync(base);
+          knownHard[base] = true;
+        }
+      }
+      while (pos < p.length) {
+        nextPartRe.lastIndex = pos;
+        var result = nextPartRe.exec(p);
+        previous = current;
+        current += result[0];
+        base = previous + result[1];
+        pos = nextPartRe.lastIndex;
+        if (knownHard[base] || cache && cache[base] === base) {
+          continue;
+        }
+        var resolvedLink;
+        if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+          resolvedLink = cache[base];
+        } else {
+          var stat = fs7.lstatSync(base);
+          if (!stat.isSymbolicLink()) {
+            knownHard[base] = true;
+            if (cache)
+              cache[base] = base;
+            continue;
+          }
+          var linkTarget = null;
+          if (!isWindows) {
+            var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+            if (seenLinks.hasOwnProperty(id)) {
+              linkTarget = seenLinks[id];
+            }
+          }
+          if (linkTarget === null) {
+            fs7.statSync(base);
+            linkTarget = fs7.readlinkSync(base);
+          }
+          resolvedLink = pathModule.resolve(previous, linkTarget);
+          if (cache)
+            cache[base] = resolvedLink;
+          if (!isWindows)
+            seenLinks[id] = linkTarget;
+        }
+        p = pathModule.resolve(resolvedLink, p.slice(pos));
+        start();
+      }
+      if (cache)
+        cache[original] = p;
+      return p;
+    };
+    exports.realpath = function realpath(p, cache, cb) {
+      if (typeof cb !== "function") {
+        cb = maybeCallback(cache);
+        cache = null;
+      }
+      p = pathModule.resolve(p);
+      if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+        return process.nextTick(cb.bind(null, null, cache[p]));
+      }
+      var original = p, seenLinks = {}, knownHard = {};
+      var pos;
+      var current;
+      var base;
+      var previous;
+      start();
+      function start() {
+        var m = splitRootRe.exec(p);
+        pos = m[0].length;
+        current = m[0];
+        base = m[0];
+        previous = "";
+        if (isWindows && !knownHard[base]) {
+          fs7.lstat(base, function(err2) {
+            if (err2)
+              return cb(err2);
+            knownHard[base] = true;
+            LOOP();
+          });
+        } else {
+          process.nextTick(LOOP);
+        }
+      }
+      function LOOP() {
+        if (pos >= p.length) {
+          if (cache)
+            cache[original] = p;
+          return cb(null, p);
+        }
+        nextPartRe.lastIndex = pos;
+        var result = nextPartRe.exec(p);
+        previous = current;
+        current += result[0];
+        base = previous + result[1];
+        pos = nextPartRe.lastIndex;
+        if (knownHard[base] || cache && cache[base] === base) {
+          return process.nextTick(LOOP);
+        }
+        if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+          return gotResolvedLink(cache[base]);
+        }
+        return fs7.lstat(base, gotStat);
+      }
+      function gotStat(err2, stat) {
+        if (err2)
+          return cb(err2);
+        if (!stat.isSymbolicLink()) {
+          knownHard[base] = true;
+          if (cache)
+            cache[base] = base;
+          return process.nextTick(LOOP);
+        }
+        if (!isWindows) {
+          var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+          if (seenLinks.hasOwnProperty(id)) {
+            return gotTarget(null, seenLinks[id], base);
+          }
+        }
+        fs7.stat(base, function(err3) {
+          if (err3)
+            return cb(err3);
+          fs7.readlink(base, function(err4, target) {
+            if (!isWindows)
+              seenLinks[id] = target;
+            gotTarget(err4, target);
+          });
+        });
+      }
+      function gotTarget(err2, target, base2) {
+        if (err2)
+          return cb(err2);
+        var resolvedLink = pathModule.resolve(previous, target);
+        if (cache)
+          cache[base2] = resolvedLink;
+        gotResolvedLink(resolvedLink);
+      }
+      function gotResolvedLink(resolvedLink) {
+        p = pathModule.resolve(resolvedLink, p.slice(pos));
+        start();
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
+var require_fs = __commonJS({
+  "node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js"(exports, module2) {
+    module2.exports = realpath;
+    realpath.realpath = realpath;
+    realpath.sync = realpathSync;
+    realpath.realpathSync = realpathSync;
+    realpath.monkeypatch = monkeypatch;
+    realpath.unmonkeypatch = unmonkeypatch;
+    var fs7 = require("fs");
+    var origRealpath = fs7.realpath;
+    var origRealpathSync = fs7.realpathSync;
+    var version = process.version;
+    var ok = /^v[0-5]\./.test(version);
+    var old = require_old();
+    function newError(er) {
+      return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+    }
+    function realpath(p, cache, cb) {
+      if (ok) {
+        return origRealpath(p, cache, cb);
+      }
+      if (typeof cache === "function") {
+        cb = cache;
+        cache = null;
+      }
+      origRealpath(p, cache, function(er, result) {
+        if (newError(er)) {
+          old.realpath(p, cache, cb);
+        } else {
+          cb(er, result);
+        }
+      });
+    }
+    function realpathSync(p, cache) {
+      if (ok) {
+        return origRealpathSync(p, cache);
+      }
+      try {
+        return origRealpathSync(p, cache);
+      } catch (er) {
+        if (newError(er)) {
+          return old.realpathSync(p, cache);
+        } else {
+          throw er;
+        }
+      }
+    }
+    function monkeypatch() {
+      fs7.realpath = realpath;
+      fs7.realpathSync = realpathSync;
+    }
+    function unmonkeypatch() {
+      fs7.realpath = origRealpath;
+      fs7.realpathSync = origRealpathSync;
+    }
+  }
+});
+
+// node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js
+var require_path = __commonJS({
+  "node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js"(exports, module2) {
+    var isWindows = typeof process === "object" && process && process.platform === "win32";
+    module2.exports = isWindows ? { sep: "\\" } : { sep: "/" };
+  }
+});
+
+// node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __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;
+    }
+  }
+});
+
+// node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports, module2) {
+    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 z2 = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z2 + c.slice(1);
+                  else
+                    c = z2 + 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;
+    }
+  }
+});
+
+// node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+  "node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js"(exports, module2) {
+    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 path4 = require_path();
+    minimatch.sep = path4.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 charUnescape = (s) => s.replace(/\\([^-\]])/g, "$1");
+    var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var braExpEscape = (s) => s.replace(/[[\]\\]/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.slice(negateOffset);
+        this.negate = negate;
+      }
+      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 = false;
+        let escaping = false;
+        const patternListStack = [];
+        const negativeLists = [];
+        let stateChar;
+        let inClass = false;
+        let reClassStart = -1;
+        let classStart = -1;
+        let cs;
+        let pl;
+        let sp;
+        let dotTravAllowed = pattern.charAt(0) === ".";
+        let dotFileAllowed = options.dot || dotTravAllowed;
+        const patternStart = () => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+        const subPatternStart = (p) => p.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) {
+            case "/": {
+              return false;
+            }
+            case "\\":
+              if (inClass && pattern.charAt(i + 1) === "-") {
+                re += c;
+                continue;
+              }
+              clearStateChar();
+              escaping = true;
+              continue;
+            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;
+              }
+              const plEntry = {
+                type: stateChar,
+                start: i - 1,
+                reStart: re.length,
+                open: plTypes[stateChar].open,
+                close: plTypes[stateChar].close
+              };
+              this.debug(this.pattern, "	", plEntry);
+              patternListStack.push(plEntry);
+              re += plEntry.open;
+              if (plEntry.start === 0 && plEntry.type !== "!") {
+                dotTravAllowed = true;
+                re += subPatternStart(pattern.slice(i + 1));
+              }
+              this.debug("plType %j %j", stateChar, re);
+              stateChar = false;
+              continue;
+            }
+            case ")": {
+              const plEntry = patternListStack[patternListStack.length - 1];
+              if (inClass || !plEntry) {
+                re += "\\)";
+                continue;
+              }
+              patternListStack.pop();
+              clearStateChar();
+              hasMagic = true;
+              pl = plEntry;
+              re += pl.close;
+              if (pl.type === "!") {
+                negativeLists.push(Object.assign(pl, { reEnd: re.length }));
+              }
+              continue;
+            }
+            case "|": {
+              const plEntry = patternListStack[patternListStack.length - 1];
+              if (inClass || !plEntry) {
+                re += "\\|";
+                continue;
+              }
+              clearStateChar();
+              re += "|";
+              if (plEntry.start === 0 && plEntry.type !== "!") {
+                dotTravAllowed = true;
+                re += subPatternStart(pattern.slice(i + 1));
+              }
+              continue;
+            }
+            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("[" + braExpEscape(charUnescape(cs)) + "]");
+                re += c;
+              } catch (er) {
+                re = re.substring(0, reClassStart) + "(?:$.)";
+              }
+              hasMagic = true;
+              inClass = false;
+              continue;
+            default:
+              clearStateChar();
+              if (reSpecials[c] && !(c === "^" && inClass)) {
+                re += "\\";
+              }
+              re += c;
+              break;
+          }
+        }
+        if (inClass) {
+          cs = pattern.slice(classStart + 1);
+          sp = this.parse(cs, SUBPARSE);
+          re = re.substring(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 closeParensBefore = nlBefore.split(")").length;
+          const openParensBefore = nlBefore.split("(").length - closeParensBefore;
+          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 (options.nocase && !hasMagic) {
+          hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
+        }
+        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 (path4.sep !== "/") {
+          f = f.split(path4.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;
+  }
+});
+
+// node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports, module2) {
+    if (typeof Object.create === "function") {
+      module2.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module2.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports, module2) {
+    try {
+      util2 = require("util");
+      if (typeof util2.inherits !== "function")
+        throw "";
+      module2.exports = util2.inherits;
+    } catch (e) {
+      module2.exports = require_inherits_browser();
+    }
+    var util2;
+  }
+});
+
+// node_modules/.pnpm/glob@8.1.0/node_modules/glob/common.js
+var require_common2 = __commonJS({
+  "node_modules/.pnpm/glob@8.1.0/node_modules/glob/common.js"(exports) {
+    exports.setopts = setopts;
+    exports.ownProp = ownProp;
+    exports.makeAbs = makeAbs;
+    exports.finish = finish;
+    exports.mark = mark;
+    exports.isIgnored = isIgnored;
+    exports.childrenIgnored = childrenIgnored;
+    function ownProp(obj, field) {
+      return Object.prototype.hasOwnProperty.call(obj, field);
+    }
+    var fs7 = require("fs");
+    var path4 = require("path");
+    var minimatch = require_minimatch();
+    var isAbsolute = require("path").isAbsolute;
+    var Minimatch = minimatch.Minimatch;
+    function alphasort(a, b) {
+      return a.localeCompare(b, "en");
+    }
+    function setupIgnores(self2, options) {
+      self2.ignore = options.ignore || [];
+      if (!Array.isArray(self2.ignore))
+        self2.ignore = [self2.ignore];
+      if (self2.ignore.length) {
+        self2.ignore = self2.ignore.map(ignoreMap);
+      }
+    }
+    function ignoreMap(pattern) {
+      var gmatcher = null;
+      if (pattern.slice(-3) === "/**") {
+        var gpattern = pattern.replace(/(\/\*\*)+$/, "");
+        gmatcher = new Minimatch(gpattern, { dot: true });
+      }
+      return {
+        matcher: new Minimatch(pattern, { dot: true }),
+        gmatcher
+      };
+    }
+    function setopts(self2, pattern, options) {
+      if (!options)
+        options = {};
+      if (options.matchBase && -1 === pattern.indexOf("/")) {
+        if (options.noglobstar) {
+          throw new Error("base matching requires globstar");
+        }
+        pattern = "**/" + pattern;
+      }
+      self2.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+      if (self2.windowsPathsNoEscape) {
+        pattern = pattern.replace(/\\/g, "/");
+      }
+      self2.silent = !!options.silent;
+      self2.pattern = pattern;
+      self2.strict = options.strict !== false;
+      self2.realpath = !!options.realpath;
+      self2.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
+      self2.follow = !!options.follow;
+      self2.dot = !!options.dot;
+      self2.mark = !!options.mark;
+      self2.nodir = !!options.nodir;
+      if (self2.nodir)
+        self2.mark = true;
+      self2.sync = !!options.sync;
+      self2.nounique = !!options.nounique;
+      self2.nonull = !!options.nonull;
+      self2.nosort = !!options.nosort;
+      self2.nocase = !!options.nocase;
+      self2.stat = !!options.stat;
+      self2.noprocess = !!options.noprocess;
+      self2.absolute = !!options.absolute;
+      self2.fs = options.fs || fs7;
+      self2.maxLength = options.maxLength || Infinity;
+      self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
+      self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
+      self2.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
+      setupIgnores(self2, options);
+      self2.changedCwd = false;
+      var cwd = process.cwd();
+      if (!ownProp(options, "cwd"))
+        self2.cwd = path4.resolve(cwd);
+      else {
+        self2.cwd = path4.resolve(options.cwd);
+        self2.changedCwd = self2.cwd !== cwd;
+      }
+      self2.root = options.root || path4.resolve(self2.cwd, "/");
+      self2.root = path4.resolve(self2.root);
+      self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
+      self2.nomount = !!options.nomount;
+      if (process.platform === "win32") {
+        self2.root = self2.root.replace(/\\/g, "/");
+        self2.cwd = self2.cwd.replace(/\\/g, "/");
+        self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
+      }
+      options.nonegate = true;
+      options.nocomment = true;
+      self2.minimatch = new Minimatch(pattern, options);
+      self2.options = self2.minimatch.options;
+    }
+    function finish(self2) {
+      var nou = self2.nounique;
+      var all = nou ? [] : /* @__PURE__ */ Object.create(null);
+      for (var i = 0, l = self2.matches.length; i < l; i++) {
+        var matches = self2.matches[i];
+        if (!matches || Object.keys(matches).length === 0) {
+          if (self2.nonull) {
+            var literal = self2.minimatch.globSet[i];
+            if (nou)
+              all.push(literal);
+            else
+              all[literal] = true;
+          }
+        } else {
+          var m = Object.keys(matches);
+          if (nou)
+            all.push.apply(all, m);
+          else
+            m.forEach(function(m2) {
+              all[m2] = true;
+            });
+        }
+      }
+      if (!nou)
+        all = Object.keys(all);
+      if (!self2.nosort)
+        all = all.sort(alphasort);
+      if (self2.mark) {
+        for (var i = 0; i < all.length; i++) {
+          all[i] = self2._mark(all[i]);
+        }
+        if (self2.nodir) {
+          all = all.filter(function(e) {
+            var notDir = !/\/$/.test(e);
+            var c = self2.cache[e] || self2.cache[makeAbs(self2, e)];
+            if (notDir && c)
+              notDir = c !== "DIR" && !Array.isArray(c);
+            return notDir;
+          });
+        }
+      }
+      if (self2.ignore.length)
+        all = all.filter(function(m2) {
+          return !isIgnored(self2, m2);
+        });
+      self2.found = all;
+    }
+    function mark(self2, p) {
+      var abs = makeAbs(self2, p);
+      var c = self2.cache[abs];
+      var m = p;
+      if (c) {
+        var isDir = c === "DIR" || Array.isArray(c);
+        var slash = p.slice(-1) === "/";
+        if (isDir && !slash)
+          m += "/";
+        else if (!isDir && slash)
+          m = m.slice(0, -1);
+        if (m !== p) {
+          var mabs = makeAbs(self2, m);
+          self2.statCache[mabs] = self2.statCache[abs];
+          self2.cache[mabs] = self2.cache[abs];
+        }
+      }
+      return m;
+    }
+    function makeAbs(self2, f) {
+      var abs = f;
+      if (f.charAt(0) === "/") {
+        abs = path4.join(self2.root, f);
+      } else if (isAbsolute(f) || f === "") {
+        abs = f;
+      } else if (self2.changedCwd) {
+        abs = path4.resolve(self2.cwd, f);
+      } else {
+        abs = path4.resolve(f);
+      }
+      if (process.platform === "win32")
+        abs = abs.replace(/\\/g, "/");
+      return abs;
+    }
+    function isIgnored(self2, path5) {
+      if (!self2.ignore.length)
+        return false;
+      return self2.ignore.some(function(item) {
+        return item.matcher.match(path5) || !!(item.gmatcher && item.gmatcher.match(path5));
+      });
+    }
+    function childrenIgnored(self2, path5) {
+      if (!self2.ignore.length)
+        return false;
+      return self2.ignore.some(function(item) {
+        return !!(item.gmatcher && item.gmatcher.match(path5));
+      });
+    }
+  }
+});
+
+// node_modules/.pnpm/glob@8.1.0/node_modules/glob/sync.js
+var require_sync = __commonJS({
+  "node_modules/.pnpm/glob@8.1.0/node_modules/glob/sync.js"(exports, module2) {
+    module2.exports = globSync;
+    globSync.GlobSync = GlobSync;
+    var rp = require_fs();
+    var minimatch = require_minimatch();
+    var Minimatch = minimatch.Minimatch;
+    var Glob = require_glob().Glob;
+    var util2 = require("util");
+    var path4 = require("path");
+    var assert = require("assert");
+    var isAbsolute = require("path").isAbsolute;
+    var common = require_common2();
+    var setopts = common.setopts;
+    var ownProp = common.ownProp;
+    var childrenIgnored = common.childrenIgnored;
+    var isIgnored = common.isIgnored;
+    function globSync(pattern, options) {
+      if (typeof options === "function" || arguments.length === 3)
+        throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+      return new GlobSync(pattern, options).found;
+    }
+    function GlobSync(pattern, options) {
+      if (!pattern)
+        throw new Error("must provide pattern");
+      if (typeof options === "function" || arguments.length === 3)
+        throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+      if (!(this instanceof GlobSync))
+        return new GlobSync(pattern, options);
+      setopts(this, pattern, options);
+      if (this.noprocess)
+        return this;
+      var n = this.minimatch.set.length;
+      this.matches = new Array(n);
+      for (var i = 0; i < n; i++) {
+        this._process(this.minimatch.set[i], i, false);
+      }
+      this._finish();
+    }
+    GlobSync.prototype._finish = function() {
+      assert.ok(this instanceof GlobSync);
+      if (this.realpath) {
+        var self2 = this;
+        this.matches.forEach(function(matchset, index4) {
+          var set = self2.matches[index4] = /* @__PURE__ */ Object.create(null);
+          for (var p in matchset) {
+            try {
+              p = self2._makeAbs(p);
+              var real = rp.realpathSync(p, self2.realpathCache);
+              set[real] = true;
+            } catch (er) {
+              if (er.syscall === "stat")
+                set[self2._makeAbs(p)] = true;
+              else
+                throw er;
+            }
+          }
+        });
+      }
+      common.finish(this);
+    };
+    GlobSync.prototype._process = function(pattern, index4, inGlobStar) {
+      assert.ok(this instanceof GlobSync);
+      var n = 0;
+      while (typeof pattern[n] === "string") {
+        n++;
+      }
+      var prefix;
+      switch (n) {
+        case pattern.length:
+          this._processSimple(pattern.join("/"), index4);
+          return;
+        case 0:
+          prefix = null;
+          break;
+        default:
+          prefix = pattern.slice(0, n).join("/");
+          break;
+      }
+      var remain = pattern.slice(n);
+      var read;
+      if (prefix === null)
+        read = ".";
+      else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+        return typeof p === "string" ? p : "[*]";
+      }).join("/"))) {
+        if (!prefix || !isAbsolute(prefix))
+          prefix = "/" + prefix;
+        read = prefix;
+      } else
+        read = prefix;
+      var abs = this._makeAbs(read);
+      if (childrenIgnored(this, read))
+        return;
+      var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+      if (isGlobStar)
+        this._processGlobStar(prefix, read, abs, remain, index4, inGlobStar);
+      else
+        this._processReaddir(prefix, read, abs, remain, index4, inGlobStar);
+    };
+    GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index4, inGlobStar) {
+      var entries = this._readdir(abs, inGlobStar);
+      if (!entries)
+        return;
+      var pn = remain[0];
+      var negate = !!this.minimatch.negate;
+      var rawGlob = pn._glob;
+      var dotOk = this.dot || rawGlob.charAt(0) === ".";
+      var matchedEntries = [];
+      for (var i = 0; i < entries.length; i++) {
+        var e = entries[i];
+        if (e.charAt(0) !== "." || dotOk) {
+          var m;
+          if (negate && !prefix) {
+            m = !e.match(pn);
+          } else {
+            m = e.match(pn);
+          }
+          if (m)
+            matchedEntries.push(e);
+        }
+      }
+      var len = matchedEntries.length;
+      if (len === 0)
+        return;
+      if (remain.length === 1 && !this.mark && !this.stat) {
+        if (!this.matches[index4])
+          this.matches[index4] = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < len; i++) {
+          var e = matchedEntries[i];
+          if (prefix) {
+            if (prefix.slice(-1) !== "/")
+              e = prefix + "/" + e;
+            else
+              e = prefix + e;
+          }
+          if (e.charAt(0) === "/" && !this.nomount) {
+            e = path4.join(this.root, e);
+          }
+          this._emitMatch(index4, e);
+        }
+        return;
+      }
+      remain.shift();
+      for (var i = 0; i < len; i++) {
+        var e = matchedEntries[i];
+        var newPattern;
+        if (prefix)
+          newPattern = [prefix, e];
+        else
+          newPattern = [e];
+        this._process(newPattern.concat(remain), index4, inGlobStar);
+      }
+    };
+    GlobSync.prototype._emitMatch = function(index4, e) {
+      if (isIgnored(this, e))
+        return;
+      var abs = this._makeAbs(e);
+      if (this.mark)
+        e = this._mark(e);
+      if (this.absolute) {
+        e = abs;
+      }
+      if (this.matches[index4][e])
+        return;
+      if (this.nodir) {
+        var c = this.cache[abs];
+        if (c === "DIR" || Array.isArray(c))
+          return;
+      }
+      this.matches[index4][e] = true;
+      if (this.stat)
+        this._stat(e);
+    };
+    GlobSync.prototype._readdirInGlobStar = function(abs) {
+      if (this.follow)
+        return this._readdir(abs, false);
+      var entries;
+      var lstat;
+      var stat;
+      try {
+        lstat = this.fs.lstatSync(abs);
+      } catch (er) {
+        if (er.code === "ENOENT") {
+          return null;
+        }
+      }
+      var isSym = lstat && lstat.isSymbolicLink();
+      this.symlinks[abs] = isSym;
+      if (!isSym && lstat && !lstat.isDirectory())
+        this.cache[abs] = "FILE";
+      else
+        entries = this._readdir(abs, false);
+      return entries;
+    };
+    GlobSync.prototype._readdir = function(abs, inGlobStar) {
+      var entries;
+      if (inGlobStar && !ownProp(this.symlinks, abs))
+        return this._readdirInGlobStar(abs);
+      if (ownProp(this.cache, abs)) {
+        var c = this.cache[abs];
+        if (!c || c === "FILE")
+          return null;
+        if (Array.isArray(c))
+          return c;
+      }
+      try {
+        return this._readdirEntries(abs, this.fs.readdirSync(abs));
+      } catch (er) {
+        this._readdirError(abs, er);
+        return null;
+      }
+    };
+    GlobSync.prototype._readdirEntries = function(abs, entries) {
+      if (!this.mark && !this.stat) {
+        for (var i = 0; i < entries.length; i++) {
+          var e = entries[i];
+          if (abs === "/")
+            e = abs + e;
+          else
+            e = abs + "/" + e;
+          this.cache[e] = true;
+        }
+      }
+      this.cache[abs] = entries;
+      return entries;
+    };
+    GlobSync.prototype._readdirError = function(f, er) {
+      switch (er.code) {
+        case "ENOTSUP":
+        case "ENOTDIR":
+          var abs = this._makeAbs(f);
+          this.cache[abs] = "FILE";
+          if (abs === this.cwdAbs) {
+            var error2 = new Error(er.code + " invalid cwd " + this.cwd);
+            error2.path = this.cwd;
+            error2.code = er.code;
+            throw error2;
+          }
+          break;
+        case "ENOENT":
+        case "ELOOP":
+        case "ENAMETOOLONG":
+        case "UNKNOWN":
+          this.cache[this._makeAbs(f)] = false;
+          break;
+        default:
+          this.cache[this._makeAbs(f)] = false;
+          if (this.strict)
+            throw er;
+          if (!this.silent)
+            console.error("glob error", er);
+          break;
+      }
+    };
+    GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index4, inGlobStar) {
+      var entries = this._readdir(abs, inGlobStar);
+      if (!entries)
+        return;
+      var remainWithoutGlobStar = remain.slice(1);
+      var gspref = prefix ? [prefix] : [];
+      var noGlobStar = gspref.concat(remainWithoutGlobStar);
+      this._process(noGlobStar, index4, false);
+      var len = entries.length;
+      var isSym = this.symlinks[abs];
+      if (isSym && inGlobStar)
+        return;
+      for (var i = 0; i < len; i++) {
+        var e = entries[i];
+        if (e.charAt(0) === "." && !this.dot)
+          continue;
+        var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+        this._process(instead, index4, true);
+        var below = gspref.concat(entries[i], remain);
+        this._process(below, index4, true);
+      }
+    };
+    GlobSync.prototype._processSimple = function(prefix, index4) {
+      var exists = this._stat(prefix);
+      if (!this.matches[index4])
+        this.matches[index4] = /* @__PURE__ */ Object.create(null);
+      if (!exists)
+        return;
+      if (prefix && isAbsolute(prefix) && !this.nomount) {
+        var trail = /[\/\\]$/.test(prefix);
+        if (prefix.charAt(0) === "/") {
+          prefix = path4.join(this.root, prefix);
+        } else {
+          prefix = path4.resolve(this.root, prefix);
+          if (trail)
+            prefix += "/";
+        }
+      }
+      if (process.platform === "win32")
+        prefix = prefix.replace(/\\/g, "/");
+      this._emitMatch(index4, prefix);
+    };
+    GlobSync.prototype._stat = function(f) {
+      var abs = this._makeAbs(f);
+      var needDir = f.slice(-1) === "/";
+      if (f.length > this.maxLength)
+        return false;
+      if (!this.stat && ownProp(this.cache, abs)) {
+        var c = this.cache[abs];
+        if (Array.isArray(c))
+          c = "DIR";
+        if (!needDir || c === "DIR")
+          return c;
+        if (needDir && c === "FILE")
+          return false;
+      }
+      var exists;
+      var stat = this.statCache[abs];
+      if (!stat) {
+        var lstat;
+        try {
+          lstat = this.fs.lstatSync(abs);
+        } catch (er) {
+          if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+            this.statCache[abs] = false;
+            return false;
+          }
+        }
+        if (lstat && lstat.isSymbolicLink()) {
+          try {
+            stat = this.fs.statSync(abs);
+          } catch (er) {
+            stat = lstat;
+          }
+        } else {
+          stat = lstat;
+        }
+      }
+      this.statCache[abs] = stat;
+      var c = true;
+      if (stat)
+        c = stat.isDirectory() ? "DIR" : "FILE";
+      this.cache[abs] = this.cache[abs] || c;
+      if (needDir && c === "FILE")
+        return false;
+      return c;
+    };
+    GlobSync.prototype._mark = function(p) {
+      return common.mark(this, p);
+    };
+    GlobSync.prototype._makeAbs = function(f) {
+      return common.makeAbs(this, f);
+    };
+  }
+});
+
+// node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module2) {
+    module2.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb)
+        return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+  "node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module2) {
+    var wrappy = require_wrappy();
+    module2.exports = wrappy(once);
+    module2.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = function() {
+        if (f.called)
+          return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      f.called = false;
+      return f;
+    }
+    function onceStrict(fn) {
+      var f = function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+  }
+});
+
+// node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
+var require_inflight = __commonJS({
+  "node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js"(exports, module2) {
+    var wrappy = require_wrappy();
+    var reqs = /* @__PURE__ */ Object.create(null);
+    var once = require_once();
+    module2.exports = wrappy(inflight);
+    function inflight(key, cb) {
+      if (reqs[key]) {
+        reqs[key].push(cb);
+        return null;
+      } else {
+        reqs[key] = [cb];
+        return makeres(key);
+      }
+    }
+    function makeres(key) {
+      return once(function RES() {
+        var cbs = reqs[key];
+        var len = cbs.length;
+        var args = slice(arguments);
+        try {
+          for (var i = 0; i < len; i++) {
+            cbs[i].apply(null, args);
+          }
+        } finally {
+          if (cbs.length > len) {
+            cbs.splice(0, len);
+            process.nextTick(function() {
+              RES.apply(null, args);
+            });
+          } else {
+            delete reqs[key];
+          }
+        }
+      });
+    }
+    function slice(args) {
+      var length = args.length;
+      var array = [];
+      for (var i = 0; i < length; i++)
+        array[i] = args[i];
+      return array;
+    }
+  }
+});
+
+// node_modules/.pnpm/glob@8.1.0/node_modules/glob/glob.js
+var require_glob = __commonJS({
+  "node_modules/.pnpm/glob@8.1.0/node_modules/glob/glob.js"(exports, module2) {
+    module2.exports = glob2;
+    var rp = require_fs();
+    var minimatch = require_minimatch();
+    var Minimatch = minimatch.Minimatch;
+    var inherits = require_inherits();
+    var EE = require("events").EventEmitter;
+    var path4 = require("path");
+    var assert = require("assert");
+    var isAbsolute = require("path").isAbsolute;
+    var globSync = require_sync();
+    var common = require_common2();
+    var setopts = common.setopts;
+    var ownProp = common.ownProp;
+    var inflight = require_inflight();
+    var util2 = require("util");
+    var childrenIgnored = common.childrenIgnored;
+    var isIgnored = common.isIgnored;
+    var once = require_once();
+    function glob2(pattern, options, cb) {
+      if (typeof options === "function")
+        cb = options, options = {};
+      if (!options)
+        options = {};
+      if (options.sync) {
+        if (cb)
+          throw new TypeError("callback provided to sync glob");
+        return globSync(pattern, options);
+      }
+      return new Glob(pattern, options, cb);
+    }
+    glob2.sync = globSync;
+    var GlobSync = glob2.GlobSync = globSync.GlobSync;
+    glob2.glob = glob2;
+    function extend(origin, add) {
+      if (add === null || typeof add !== "object") {
+        return origin;
+      }
+      var keys = Object.keys(add);
+      var i = keys.length;
+      while (i--) {
+        origin[keys[i]] = add[keys[i]];
+      }
+      return origin;
+    }
+    glob2.hasMagic = function(pattern, options_) {
+      var options = extend({}, options_);
+      options.noprocess = true;
+      var g = new Glob(pattern, options);
+      var set = g.minimatch.set;
+      if (!pattern)
+        return false;
+      if (set.length > 1)
+        return true;
+      for (var j = 0; j < set[0].length; j++) {
+        if (typeof set[0][j] !== "string")
+          return true;
+      }
+      return false;
+    };
+    glob2.Glob = Glob;
+    inherits(Glob, EE);
+    function Glob(pattern, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = null;
+      }
+      if (options && options.sync) {
+        if (cb)
+          throw new TypeError("callback provided to sync glob");
+        return new GlobSync(pattern, options);
+      }
+      if (!(this instanceof Glob))
+        return new Glob(pattern, options, cb);
+      setopts(this, pattern, options);
+      this._didRealPath = false;
+      var n = this.minimatch.set.length;
+      this.matches = new Array(n);
+      if (typeof cb === "function") {
+        cb = once(cb);
+        this.on("error", cb);
+        this.on("end", function(matches) {
+          cb(null, matches);
+        });
+      }
+      var self2 = this;
+      this._processing = 0;
+      this._emitQueue = [];
+      this._processQueue = [];
+      this.paused = false;
+      if (this.noprocess)
+        return this;
+      if (n === 0)
+        return done();
+      var sync = true;
+      for (var i = 0; i < n; i++) {
+        this._process(this.minimatch.set[i], i, false, done);
+      }
+      sync = false;
+      function done() {
+        --self2._processing;
+        if (self2._processing <= 0) {
+          if (sync) {
+            process.nextTick(function() {
+              self2._finish();
+            });
+          } else {
+            self2._finish();
+          }
+        }
+      }
+    }
+    Glob.prototype._finish = function() {
+      assert(this instanceof Glob);
+      if (this.aborted)
+        return;
+      if (this.realpath && !this._didRealpath)
+        return this._realpath();
+      common.finish(this);
+      this.emit("end", this.found);
+    };
+    Glob.prototype._realpath = function() {
+      if (this._didRealpath)
+        return;
+      this._didRealpath = true;
+      var n = this.matches.length;
+      if (n === 0)
+        return this._finish();
+      var self2 = this;
+      for (var i = 0; i < this.matches.length; i++)
+        this._realpathSet(i, next);
+      function next() {
+        if (--n === 0)
+          self2._finish();
+      }
+    };
+    Glob.prototype._realpathSet = function(index4, cb) {
+      var matchset = this.matches[index4];
+      if (!matchset)
+        return cb();
+      var found = Object.keys(matchset);
+      var self2 = this;
+      var n = found.length;
+      if (n === 0)
+        return cb();
+      var set = this.matches[index4] = /* @__PURE__ */ Object.create(null);
+      found.forEach(function(p, i) {
+        p = self2._makeAbs(p);
+        rp.realpath(p, self2.realpathCache, function(er, real) {
+          if (!er)
+            set[real] = true;
+          else if (er.syscall === "stat")
+            set[p] = true;
+          else
+            self2.emit("error", er);
+          if (--n === 0) {
+            self2.matches[index4] = set;
+            cb();
+          }
+        });
+      });
+    };
+    Glob.prototype._mark = function(p) {
+      return common.mark(this, p);
+    };
+    Glob.prototype._makeAbs = function(f) {
+      return common.makeAbs(this, f);
+    };
+    Glob.prototype.abort = function() {
+      this.aborted = true;
+      this.emit("abort");
+    };
+    Glob.prototype.pause = function() {
+      if (!this.paused) {
+        this.paused = true;
+        this.emit("pause");
+      }
+    };
+    Glob.prototype.resume = function() {
+      if (this.paused) {
+        this.emit("resume");
+        this.paused = false;
+        if (this._emitQueue.length) {
+          var eq = this._emitQueue.slice(0);
+          this._emitQueue.length = 0;
+          for (var i = 0; i < eq.length; i++) {
+            var e = eq[i];
+            this._emitMatch(e[0], e[1]);
+          }
+        }
+        if (this._processQueue.length) {
+          var pq = this._processQueue.slice(0);
+          this._processQueue.length = 0;
+          for (var i = 0; i < pq.length; i++) {
+            var p = pq[i];
+            this._processing--;
+            this._process(p[0], p[1], p[2], p[3]);
+          }
+        }
+      }
+    };
+    Glob.prototype._process = function(pattern, index4, inGlobStar, cb) {
+      assert(this instanceof Glob);
+      assert(typeof cb === "function");
+      if (this.aborted)
+        return;
+      this._processing++;
+      if (this.paused) {
+        this._processQueue.push([pattern, index4, inGlobStar, cb]);
+        return;
+      }
+      var n = 0;
+      while (typeof pattern[n] === "string") {
+        n++;
+      }
+      var prefix;
+      switch (n) {
+        case pattern.length:
+          this._processSimple(pattern.join("/"), index4, cb);
+          return;
+        case 0:
+          prefix = null;
+          break;
+        default:
+          prefix = pattern.slice(0, n).join("/");
+          break;
+      }
+      var remain = pattern.slice(n);
+      var read;
+      if (prefix === null)
+        read = ".";
+      else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+        return typeof p === "string" ? p : "[*]";
+      }).join("/"))) {
+        if (!prefix || !isAbsolute(prefix))
+          prefix = "/" + prefix;
+        read = prefix;
+      } else
+        read = prefix;
+      var abs = this._makeAbs(read);
+      if (childrenIgnored(this, read))
+        return cb();
+      var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+      if (isGlobStar)
+        this._processGlobStar(prefix, read, abs, remain, index4, inGlobStar, cb);
+      else
+        this._processReaddir(prefix, read, abs, remain, index4, inGlobStar, cb);
+    };
+    Glob.prototype._processReaddir = function(prefix, read, abs, remain, index4, inGlobStar, cb) {
+      var self2 = this;
+      this._readdir(abs, inGlobStar, function(er, entries) {
+        return self2._processReaddir2(prefix, read, abs, remain, index4, inGlobStar, entries, cb);
+      });
+    };
+    Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index4, inGlobStar, entries, cb) {
+      if (!entries)
+        return cb();
+      var pn = remain[0];
+      var negate = !!this.minimatch.negate;
+      var rawGlob = pn._glob;
+      var dotOk = this.dot || rawGlob.charAt(0) === ".";
+      var matchedEntries = [];
+      for (var i = 0; i < entries.length; i++) {
+        var e = entries[i];
+        if (e.charAt(0) !== "." || dotOk) {
+          var m;
+          if (negate && !prefix) {
+            m = !e.match(pn);
+          } else {
+            m = e.match(pn);
+          }
+          if (m)
+            matchedEntries.push(e);
+        }
+      }
+      var len = matchedEntries.length;
+      if (len === 0)
+        return cb();
+      if (remain.length === 1 && !this.mark && !this.stat) {
+        if (!this.matches[index4])
+          this.matches[index4] = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < len; i++) {
+          var e = matchedEntries[i];
+          if (prefix) {
+            if (prefix !== "/")
+              e = prefix + "/" + e;
+            else
+              e = prefix + e;
+          }
+          if (e.charAt(0) === "/" && !this.nomount) {
+            e = path4.join(this.root, e);
+          }
+          this._emitMatch(index4, e);
+        }
+        return cb();
+      }
+      remain.shift();
+      for (var i = 0; i < len; i++) {
+        var e = matchedEntries[i];
+        var newPattern;
+        if (prefix) {
+          if (prefix !== "/")
+            e = prefix + "/" + e;
+          else
+            e = prefix + e;
+        }
+        this._process([e].concat(remain), index4, inGlobStar, cb);
+      }
+      cb();
+    };
+    Glob.prototype._emitMatch = function(index4, e) {
+      if (this.aborted)
+        return;
+      if (isIgnored(this, e))
+        return;
+      if (this.paused) {
+        this._emitQueue.push([index4, e]);
+        return;
+      }
+      var abs = isAbsolute(e) ? e : this._makeAbs(e);
+      if (this.mark)
+        e = this._mark(e);
+      if (this.absolute)
+        e = abs;
+      if (this.matches[index4][e])
+        return;
+      if (this.nodir) {
+        var c = this.cache[abs];
+        if (c === "DIR" || Array.isArray(c))
+          return;
+      }
+      this.matches[index4][e] = true;
+      var st = this.statCache[abs];
+      if (st)
+        this.emit("stat", e, st);
+      this.emit("match", e);
+    };
+    Glob.prototype._readdirInGlobStar = function(abs, cb) {
+      if (this.aborted)
+        return;
+      if (this.follow)
+        return this._readdir(abs, false, cb);
+      var lstatkey = "lstat\0" + abs;
+      var self2 = this;
+      var lstatcb = inflight(lstatkey, lstatcb_);
+      if (lstatcb)
+        self2.fs.lstat(abs, lstatcb);
+      function lstatcb_(er, lstat) {
+        if (er && er.code === "ENOENT")
+          return cb();
+        var isSym = lstat && lstat.isSymbolicLink();
+        self2.symlinks[abs] = isSym;
+        if (!isSym && lstat && !lstat.isDirectory()) {
+          self2.cache[abs] = "FILE";
+          cb();
+        } else
+          self2._readdir(abs, false, cb);
+      }
+    };
+    Glob.prototype._readdir = function(abs, inGlobStar, cb) {
+      if (this.aborted)
+        return;
+      cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+      if (!cb)
+        return;
+      if (inGlobStar && !ownProp(this.symlinks, abs))
+        return this._readdirInGlobStar(abs, cb);
+      if (ownProp(this.cache, abs)) {
+        var c = this.cache[abs];
+        if (!c || c === "FILE")
+          return cb();
+        if (Array.isArray(c))
+          return cb(null, c);
+      }
+      var self2 = this;
+      self2.fs.readdir(abs, readdirCb(this, abs, cb));
+    };
+    function readdirCb(self2, abs, cb) {
+      return function(er, entries) {
+        if (er)
+          self2._readdirError(abs, er, cb);
+        else
+          self2._readdirEntries(abs, entries, cb);
+      };
+    }
+    Glob.prototype._readdirEntries = function(abs, entries, cb) {
+      if (this.aborted)
+        return;
+      if (!this.mark && !this.stat) {
+        for (var i = 0; i < entries.length; i++) {
+          var e = entries[i];
+          if (abs === "/")
+            e = abs + e;
+          else
+            e = abs + "/" + e;
+          this.cache[e] = true;
+        }
+      }
+      this.cache[abs] = entries;
+      return cb(null, entries);
+    };
+    Glob.prototype._readdirError = function(f, er, cb) {
+      if (this.aborted)
+        return;
+      switch (er.code) {
+        case "ENOTSUP":
+        case "ENOTDIR":
+          var abs = this._makeAbs(f);
+          this.cache[abs] = "FILE";
+          if (abs === this.cwdAbs) {
+            var error2 = new Error(er.code + " invalid cwd " + this.cwd);
+            error2.path = this.cwd;
+            error2.code = er.code;
+            this.emit("error", error2);
+            this.abort();
+          }
+          break;
+        case "ENOENT":
+        case "ELOOP":
+        case "ENAMETOOLONG":
+        case "UNKNOWN":
+          this.cache[this._makeAbs(f)] = false;
+          break;
+        default:
+          this.cache[this._makeAbs(f)] = false;
+          if (this.strict) {
+            this.emit("error", er);
+            this.abort();
+          }
+          if (!this.silent)
+            console.error("glob error", er);
+          break;
+      }
+      return cb();
+    };
+    Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index4, inGlobStar, cb) {
+      var self2 = this;
+      this._readdir(abs, inGlobStar, function(er, entries) {
+        self2._processGlobStar2(prefix, read, abs, remain, index4, inGlobStar, entries, cb);
+      });
+    };
+    Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index4, inGlobStar, entries, cb) {
+      if (!entries)
+        return cb();
+      var remainWithoutGlobStar = remain.slice(1);
+      var gspref = prefix ? [prefix] : [];
+      var noGlobStar = gspref.concat(remainWithoutGlobStar);
+      this._process(noGlobStar, index4, false, cb);
+      var isSym = this.symlinks[abs];
+      var len = entries.length;
+      if (isSym && inGlobStar)
+        return cb();
+      for (var i = 0; i < len; i++) {
+        var e = entries[i];
+        if (e.charAt(0) === "." && !this.dot)
+          continue;
+        var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+        this._process(instead, index4, true, cb);
+        var below = gspref.concat(entries[i], remain);
+        this._process(below, index4, true, cb);
+      }
+      cb();
+    };
+    Glob.prototype._processSimple = function(prefix, index4, cb) {
+      var self2 = this;
+      this._stat(prefix, function(er, exists) {
+        self2._processSimple2(prefix, index4, er, exists, cb);
+      });
+    };
+    Glob.prototype._processSimple2 = function(prefix, index4, er, exists, cb) {
+      if (!this.matches[index4])
+        this.matches[index4] = /* @__PURE__ */ Object.create(null);
+      if (!exists)
+        return cb();
+      if (prefix && isAbsolute(prefix) && !this.nomount) {
+        var trail = /[\/\\]$/.test(prefix);
+        if (prefix.charAt(0) === "/") {
+          prefix = path4.join(this.root, prefix);
+        } else {
+          prefix = path4.resolve(this.root, prefix);
+          if (trail)
+            prefix += "/";
+        }
+      }
+      if (process.platform === "win32")
+        prefix = prefix.replace(/\\/g, "/");
+      this._emitMatch(index4, prefix);
+      cb();
+    };
+    Glob.prototype._stat = function(f, cb) {
+      var abs = this._makeAbs(f);
+      var needDir = f.slice(-1) === "/";
+      if (f.length > this.maxLength)
+        return cb();
+      if (!this.stat && ownProp(this.cache, abs)) {
+        var c = this.cache[abs];
+        if (Array.isArray(c))
+          c = "DIR";
+        if (!needDir || c === "DIR")
+          return cb(null, c);
+        if (needDir && c === "FILE")
+          return cb();
+      }
+      var exists;
+      var stat = this.statCache[abs];
+      if (stat !== void 0) {
+        if (stat === false)
+          return cb(null, stat);
+        else {
+          var type = stat.isDirectory() ? "DIR" : "FILE";
+          if (needDir && type === "FILE")
+            return cb();
+          else
+            return cb(null, type, stat);
+        }
+      }
+      var self2 = this;
+      var statcb = inflight("stat\0" + abs, lstatcb_);
+      if (statcb)
+        self2.fs.lstat(abs, statcb);
+      function lstatcb_(er, lstat) {
+        if (lstat && lstat.isSymbolicLink()) {
+          return self2.fs.stat(abs, function(er2, stat2) {
+            if (er2)
+              self2._stat2(f, abs, null, lstat, cb);
+            else
+              self2._stat2(f, abs, er2, stat2, cb);
+          });
+        } else {
+          self2._stat2(f, abs, er, lstat, cb);
+        }
+      }
+    };
+    Glob.prototype._stat2 = function(f, abs, er, stat, cb) {
+      if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+        this.statCache[abs] = false;
+        return cb();
+      }
+      var needDir = f.slice(-1) === "/";
+      this.statCache[abs] = stat;
+      if (abs.slice(-1) === "/" && stat && !stat.isDirectory())
+        return cb(null, false, stat);
+      var c = true;
+      if (stat)
+        c = stat.isDirectory() ? "DIR" : "FILE";
+      this.cache[abs] = this.cache[abs] || c;
+      if (needDir && c === "FILE")
+        return cb();
+      return cb(null, c, stat);
+    };
+  }
+});
+
 // src/serializer/mysqlImports.ts
 var mysqlImports_exports = {};
 __export(mysqlImports_exports, {
@@ -22393,7 +24942,7 @@ function clearDefaults(defaultValue, collate) {
     return `(${resultDefault})`;
   }
 }
-var import_mysql_core2, import_table, import_utils7, import_sql, import_common, dialect3, indexName, generateMySqlSnapshot, fromDatabase;
+var import_mysql_core2, import_table, import_utils7, import_sql, import_common, import_date, dialect3, indexName, generateMySqlSnapshot, fromDatabase;
 var init_mysqlSerializer = __esm({
   "src/serializer/mysqlSerializer.ts"() {
     import_mysql_core2 = require("drizzle-orm/mysql-core");
@@ -22401,6 +24950,7 @@ var init_mysqlSerializer = __esm({
     import_utils7 = require("drizzle-orm/mysql-core/utils");
     import_sql = require("drizzle-orm/sql");
     import_common = require("drizzle-orm/mysql-core/columns/common");
+    import_date = require("drizzle-orm/mysql-core/columns/date.common");
     dialect3 = new import_mysql_core2.MySqlDialect();
     indexName = (tableName, columns) => {
       return `${tableName}_${columns.join("_")}_index`;
@@ -22421,12 +24971,14 @@ var init_mysqlSerializer = __esm({
         columns.forEach((column6) => {
           const notNull = column6.notNull;
           const primaryKey = column6.primary;
+          const sqlTypeLowered = column6.getSQLType().toLowerCase();
           const columnToSet = {
             name: column6.name,
             type: column6.getSQLType(),
             primaryKey,
             notNull,
-            autoincrement: column6 instanceof import_common.MySqlColumnWithAutoIncrement ? column6.autoIncrement : false
+            autoincrement: column6 instanceof import_common.MySqlColumnWithAutoIncrement ? column6.autoIncrement : false,
+            onUpdate: column6 instanceof import_date.MySqlDateBaseColumn ? column6.hasOnUpdateNow : void 0
           };
           if (column6.default !== void 0) {
             if (column6.default instanceof import_sql.SQL) {
@@ -22437,7 +24989,17 @@ var init_mysqlSerializer = __esm({
                 throw new Error();
               }).join();
             } else {
-              columnToSet.default = typeof column6.default === "string" ? `'${column6.default}'` : column6.default;
+              if (typeof column6.default === "string") {
+                columnToSet.default = `"${column6.default}"`;
+              } else {
+                if (sqlTypeLowered === "json") {
+                  columnToSet.default = `'${JSON.stringify(column6.default)}'`;
+                } else if (column6.default instanceof Date) {
+                  columnToSet.default = `'${column6.default.toISOString()}'`;
+                } else {
+                  columnToSet.default = column6.default;
+                }
+              }
             }
             if (["blob", "text", "json"].includes(column6.getSQLType())) {
               columnToSet.default = `(${columnToSet.default})`;
@@ -22511,10 +25073,10 @@ var init_mysqlSerializer = __esm({
         }
       };
     };
-    fromDatabase = async (db, schema4, progressCallback) => {
+    fromDatabase = async (db, inputSchema, progressCallback) => {
       const result = {};
       const columns = await db.execute(`select * from information_schema.columns
-	where table_schema = '${schema4}'
+	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
 	order by table_name, ordinal_position;`);
       const response = columns[0];
       const schemas = [];
@@ -22525,9 +25087,9 @@ var init_mysqlSerializer = __esm({
       for (const column6 of response) {
         columnsCount += 1;
         progressCallback("columns", columnsCount, "fetching");
-        const schema5 = column6["TABLE_SCHEMA"];
+        const schema4 = column6["TABLE_SCHEMA"];
         const tableName = column6["TABLE_NAME"];
-        tablesCount.add(`${schema5}.${tableName}`);
+        tablesCount.add(`${schema4}.${tableName}`);
         progressCallback("columns", tablesCount.size, "fetching");
         const columnName = column6["COLUMN_NAME"];
         const isNullable = column6["IS_NULLABLE"] === "YES";
@@ -22538,7 +25100,9 @@ var init_mysqlSerializer = __esm({
         const isDefaultAnExpression = column6["EXTRA"] === "DEFAULT_GENERATED";
         const columnDefault = column6["COLUMN_DEFAULT"];
         const collation = column6["CHARACTER_SET_NAME"];
-        schemas.push(schema5);
+        if (schema4 !== inputSchema) {
+          schemas.push(schema4);
+        }
         const table4 = result[tableName];
         const newColumn = {
           default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : isDefaultAnExpression ? clearDefaults(columnDefault, collation) : `"${columnDefault}"`,
@@ -22551,7 +25115,7 @@ var init_mysqlSerializer = __esm({
         if (!table4) {
           result[tableName] = {
             name: tableName,
-            schema: schema5,
+            schema: schema4 !== inputSchema ? schema4 : void 0,
             columns: {
               [columnName]: newColumn
             },
@@ -22564,56 +25128,62 @@ var init_mysqlSerializer = __esm({
       }
       progressCallback("columns", columnsCount, "done");
       progressCallback("tables", tablesCount.size, "done");
-      const fks = await db.execute(
-        `SELECT INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.COLUMN_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME, INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_COLUMN_NAME,information_schema.referential_constraints.UPDATE_RULE, information_schema.referential_constraints.DELETE_RULE
+      try {
+        const fks = await db.execute(
+          `SELECT INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.COLUMN_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME, INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_COLUMN_NAME,information_schema.referential_constraints.UPDATE_RULE, information_schema.referential_constraints.DELETE_RULE
 		FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
 		LEFT JOIN information_schema.referential_constraints on information_schema.referential_constraints.constraint_name = information_schema.KEY_COLUMN_USAGE.CONSTRAINT_NAME
 		WHERE INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA = ? AND INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME != 'PRIMARY' and INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME is not null;
 		`,
-        [schema4]
-      );
-      const fkRows = fks[0];
-      for (const fkRow of fkRows) {
-        foreignKeysCount += 1;
-        progressCallback("fks", foreignKeysCount, "fetching");
-        const tableSchema = fkRow["TABLE_SCHEMA"];
-        const tableName = fkRow["TABLE_NAME"];
-        const constraintName = fkRow["CONSTRAINT_NAME"];
-        const columnName = fkRow["COLUMN_NAME"];
-        const refTableSchema = fkRow["REFERENCED_TABLE_SCHEMA"];
-        const refTableName = fkRow["REFERENCED_TABLE_NAME"];
-        const refColumnName = fkRow["REFERENCED_COLUMN_NAME"];
-        const updateRule = fkRow["UPDATE_RULE"];
-        const deleteRule = fkRow["DELETE_RULE"];
-        const tableInResult = result[tableName];
-        if (typeof tableInResult === "undefined")
-          continue;
-        if (typeof tableInResult.foreignKeys[constraintName] !== "undefined") {
-          tableInResult.foreignKeys[constraintName].columnsFrom.push(columnName);
-          tableInResult.foreignKeys[constraintName].columnsTo.push(refColumnName);
-        } else {
-          tableInResult.foreignKeys[constraintName] = {
-            name: constraintName,
-            tableFrom: tableName,
-            tableTo: refTableName,
-            columnsFrom: [columnName],
-            columnsTo: [refColumnName],
-            onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
-            onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
-          };
+          [inputSchema]
+        );
+        const fkRows = fks[0];
+        for (const fkRow of fkRows) {
+          foreignKeysCount += 1;
+          progressCallback("fks", foreignKeysCount, "fetching");
+          const tableSchema = fkRow["TABLE_SCHEMA"];
+          const tableName = fkRow["TABLE_NAME"];
+          const constraintName = fkRow["CONSTRAINT_NAME"];
+          const columnName = fkRow["COLUMN_NAME"];
+          const refTableSchema = fkRow["REFERENCED_TABLE_SCHEMA"];
+          const refTableName = fkRow["REFERENCED_TABLE_NAME"];
+          const refColumnName = fkRow["REFERENCED_COLUMN_NAME"];
+          const updateRule = fkRow["UPDATE_RULE"];
+          const deleteRule = fkRow["DELETE_RULE"];
+          const tableInResult = result[tableName];
+          if (typeof tableInResult === "undefined")
+            continue;
+          if (typeof tableInResult.foreignKeys[constraintName] !== "undefined") {
+            tableInResult.foreignKeys[constraintName].columnsFrom.push(columnName);
+            tableInResult.foreignKeys[constraintName].columnsTo.push(
+              refColumnName
+            );
+          } else {
+            tableInResult.foreignKeys[constraintName] = {
+              name: constraintName,
+              tableFrom: tableName,
+              tableTo: refTableName,
+              columnsFrom: [columnName],
+              columnsTo: [refColumnName],
+              onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
+              onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
+            };
+          }
+          tableInResult.foreignKeys[constraintName].columnsFrom = [
+            ...new Set(tableInResult.foreignKeys[constraintName].columnsFrom)
+          ];
+          tableInResult.foreignKeys[constraintName].columnsTo = [
+            ...new Set(tableInResult.foreignKeys[constraintName].columnsTo)
+          ];
         }
-        tableInResult.foreignKeys[constraintName].columnsFrom = [
-          ...new Set(tableInResult.foreignKeys[constraintName].columnsFrom)
-        ];
-        tableInResult.foreignKeys[constraintName].columnsTo = [
-          ...new Set(tableInResult.foreignKeys[constraintName].columnsTo)
-        ];
+      } catch (e) {
+        console.log(`Can't proccess foreign keys`);
       }
       progressCallback("fks", foreignKeysCount, "done");
       const idxs = await db.execute(
         `select * from INFORMATION_SCHEMA.STATISTICS
 	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = ? and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`,
-        [schema4]
+        [inputSchema]
       );
       const idxRows = idxs[0];
       for (const idxRow of idxRows) {
@@ -23221,12 +25791,13 @@ var init_sqliteSerializer = __esm({
 });
 
 // src/serializer/index.ts
-var import_fs3, import_node, import_path3, safeRegister, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
+var import_fs3, import_node, import_path3, import_glob, safeRegister, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
     import_fs3 = __toESM(require("fs"));
     import_node = __toESM(require_node2());
     import_path3 = __toESM(require("path"));
+    import_glob = __toESM(require_glob());
     safeRegister = () => {
       try {
         const { unregister } = (0, import_node.register)({
@@ -23267,9 +25838,19 @@ var init_serializer = __esm({
       return generateSqliteSnapshot2(tables, enums);
     };
     prepareFilenames = (path4) => {
-      const fileName = import_fs3.default.lstatSync(path4).isDirectory() ? null : import_path3.default.resolve(path4);
-      const filenames = fileName ? [fileName] : import_fs3.default.readdirSync(path4).map((it) => import_path3.default.join(import_path3.default.resolve(path4), it));
-      return filenames;
+      if (typeof path4 === "string") {
+        path4 = [path4];
+      }
+      const result = path4.reduce((result2, cur) => {
+        const globbed = import_glob.default.sync(cur);
+        globbed.forEach((it) => {
+          const fileName = import_fs3.default.lstatSync(it).isDirectory() ? null : import_path3.default.resolve(it);
+          const filenames = fileName ? [fileName] : import_fs3.default.readdirSync(it).map((file) => import_path3.default.join(import_path3.default.resolve(it), file));
+          filenames.filter((file) => !import_fs3.default.lstatSync(file).isDirectory()).forEach((file) => result2.add(file));
+        });
+        return result2;
+      }, /* @__PURE__ */ new Set());
+      return [...result];
     };
   }
 });
@@ -44892,13 +47473,13 @@ var init_mysql_introspect = __esm({
         },
         { mysql: [] }
       );
-      const schemaStatements = Object.entries(schemas).filter((it) => it[0] !== "public").map((it) => {
+      const schemaStatements = Object.entries(schemas).map((it) => {
         return `export const ${it[1]} = mysqlSchema("${it[0]}");
 `;
       }).join();
       const tableStatements = Object.values(schema4.tables).map((table4) => {
         const schema5 = schemas[table4.schema];
-        const func = schema5 || schema5 === "public" ? "mysqlTable" : schema5;
+        const func = schema5 ? schema5 : "mysqlTable";
         let statement = "";
         if (imports.mysql.includes(table4.name.camelCase())) {
           statement = `// Table name is in conflict with ${table4.name.camelCase()} import.
@@ -45228,16 +47809,21 @@ var init_mysqlIntrospect = __esm({
       if (typeof config.connectionString !== "undefined") {
         const connection = config.connectionString;
         client = await (0, import_promise.createConnection)(connection);
-        databaseName = connection.split("/")[connection.split("/").length - 1];
+        const connectionUrl = new URL(connection);
+        const pathname = connectionUrl.pathname;
+        databaseName = pathname.split("/")[pathname.split("/").length - 1];
       } else {
         client = await (0, import_promise.createConnection)(config);
         databaseName = config.database;
       }
       await client.connect();
       const progress = new IntrospectProgress();
-      const res = await (0, import_hanji5.renderWithTask)(progress, fromDatabase(client, databaseName, (stage, count, status) => {
-        progress.update(stage, count, status);
-      }));
+      const res = await (0, import_hanji5.renderWithTask)(
+        progress,
+        fromDatabase(client, databaseName, (stage, count, status) => {
+          progress.update(stage, count, status);
+        })
+      );
       const schema4 = { id: originUUID, prevId: "", ...res };
       const ts = schemaToTypeScript2(schema4);
       return { schema: schema4, ts };
@@ -45362,15 +47948,16 @@ var package_default = {
   name: "drizzle-kit",
   version: "0.16.9",
   repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
-  author: "Alex Blokh <aleksandrblokh@gmail.com>",
+  author: "Drizzle Team",
   license: "MIT",
   bin: {
     "drizzle-kit": "./index.js"
   },
   scripts: {
     "start:pg": "node -r esbuild-register ./src/cli/index.ts generate --out ./dev/migrations --dialect pg --schema ./dev/data",
+    "start:mysql": "node -r esbuild-register ./src/cli/index.ts generate:mysql --out ./dev/migrations --schema ./dev/migrations/schema.ts",
     "check:pg": "node -r esbuild-register ./src/cli/index.ts check --out ./dev/migrations --dialect pg",
-    "introspect:mysql": "node -r esbuild-register ./src/cli/index.ts introspect:mysql --out ./dev/migrations --connectionString mysql://root:password123@127.0.0.1:3306/mySchema",
+    "introspect:mysql": "node -r esbuild-register ./src/cli/index.ts introspect:mysql --out ./dev/migrations --connectionString ",
     "up:pg": "node -r esbuild-register ./src/cli/index.ts up --out ./dev/equedi --dialect pg",
     "check:equedi": "node -r esbuild-register ./src/cli/index.ts check --out ./dev/equedi --dialect pg",
     run: "node -r esbuild-register index.ts",
@@ -45406,12 +47993,14 @@ var package_default = {
     commander: "^9.4.1",
     esbuild: "^0.15.18",
     "esbuild-register": "^3.4.2",
+    glob: "^8.1.0",
     hanji: "^0.0.5",
     "json-diff": "0.9.0",
     zod: "^3.20.2"
   },
   devDependencies: {
     "@types/dockerode": "^3.3.14",
+    "@types/glob": "^8.1.0",
     "@types/node": "^18.11.15",
     "@types/pg": "^8.6.5",
     "@typescript-eslint/eslint-plugin": "^5.46.1",
@@ -45419,7 +48008,7 @@ var package_default = {
     ava: "^5.1.0",
     dockerode: "^3.3.4",
     "drizzle-kit": "^0.16.8",
-    "drizzle-orm": "0.19.0-03308d4",
+    "drizzle-orm": "0.21.0-2e66963",
     esbuild: "^0.15.7",
     "esbuild-register": "^3.3.3",
     eslint: "^8.29.0",
@@ -45776,22 +48365,23 @@ drizzle-orm: v${npmVersion}` : "";
   return versions2;
 };
 var configSchema = objectType({
-  schema: stringType(),
+  schema: unionType([stringType(), stringType().array()]),
   out: stringType().default("drizzle"),
   breakpoints: booleanType()
 }).strict();
 var optionsSchema = objectType({
-  schema: stringType().optional(),
+  schema: unionType([stringType(), stringType().array()]).optional(),
   out: stringType().optional(),
   config: stringType().optional(),
   breakpoints: booleanType().optional().default(false)
 }).strict();
-var generatePgCommand = new Command("generate:pg").option("--schema <schema>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
+var generatePgCommand = new Command("generate:pg").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
   printVersions();
   assertOrmCoreVersion();
+  console.log(options);
   const oprtionsParsed = optionsSchema.parse(options);
   const result = prepareGenerateConfig(oprtionsParsed);
   if (result instanceof Error) {
@@ -45802,7 +48392,7 @@ var generatePgCommand = new Command("generate:pg").option("--schema <schema>", "
   const { prepareAndMigratePg: prepareAndMigratePg2 } = (init_migrate(), __toCommonJS(migrate_exports));
   await prepareAndMigratePg2(result);
 });
-var generateMysqlCommand = new Command("generate:mysql").option("--schema <schema>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
+var generateMysqlCommand = new Command("generate:mysql").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
@@ -45818,7 +48408,7 @@ var generateMysqlCommand = new Command("generate:mysql").option("--schema <schem
   const { prepareAndMigrateMySql: prepareAndMigrateMySql2 } = (init_migrate(), __toCommonJS(migrate_exports));
   await prepareAndMigrateMySql2(result);
 });
-var generateSqliteCommand = new Command("generate:sqlite").option("--schema <schema>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
+var generateSqliteCommand = new Command("generate:sqlite").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {