drizzle-kit 0.17.4 → 0.17.5-e5944eb

package/utils.js

@@ -1,9 +1,13 @@
+#!/usr/bin/env -S node --loader @esbuild-kit/esm-loader --no-warnings 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -524,7 +528,7 @@ var require_hanji = __commonJS({
       }
     };
     exports.TaskTerminal = TaskTerminal;
-    function render2(view) {
+    function render3(view) {
       const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
       if (view instanceof Prompt2) {
         const terminal = new Terminal(view, stdin, stdout, closable);
@@ -536,7 +540,7 @@ var require_hanji = __commonJS({
       closable.close();
       return;
     }
-    exports.render = render2;
+    exports.render = render3;
     function renderWithTask(view, task) {
       return __awaiter(this, void 0, void 0, function* () {
         const terminal = new TaskTerminal(view, process.stdout);
@@ -6659,6 +6663,2345 @@ var require_lib = __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 fs = 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(err) {
+        if (err) {
+          backtrace.message = err.message;
+          err = backtrace;
+          missingCallback(err);
+        }
+      }
+      function missingCallback(err) {
+        if (err) {
+          if (process.throwDeprecation)
+            throw err;
+          else if (!process.noDeprecation) {
+            var msg = "fs: missing callback " + (err.stack || err.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]) {
+          fs.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 = fs.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) {
+            fs.statSync(base);
+            linkTarget = fs.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]) {
+          fs.lstat(base, function(err) {
+            if (err)
+              return cb(err);
+            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 fs.lstat(base, gotStat);
+      }
+      function gotStat(err, stat) {
+        if (err)
+          return cb(err);
+        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);
+          }
+        }
+        fs.stat(base, function(err2) {
+          if (err2)
+            return cb(err2);
+          fs.readlink(base, function(err3, target) {
+            if (!isWindows)
+              seenLinks[id] = target;
+            gotTarget(err3, target);
+          });
+        });
+      }
+      function gotTarget(err, target, base2) {
+        if (err)
+          return cb(err);
+        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 fs = require("fs");
+    var origRealpath = fs.realpath;
+    var origRealpathSync = fs.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() {
+      fs.realpath = realpath;
+      fs.realpathSync = realpathSync;
+    }
+    function unmonkeypatch() {
+      fs.realpath = origRealpath;
+      fs.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 path = require_path();
+    minimatch.sep = path.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 (path.sep !== "/") {
+          f = f.split(path.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_common = __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 fs = require("fs");
+    var path = 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 || fs;
+      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 = path.resolve(cwd);
+      else {
+        self2.cwd = path.resolve(options.cwd);
+        self2.changedCwd = self2.cwd !== cwd;
+      }
+      self2.root = options.root || path.resolve(self2.cwd, "/");
+      self2.root = path.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 = path.join(self2.root, f);
+      } else if (isAbsolute(f) || f === "") {
+        abs = f;
+      } else if (self2.changedCwd) {
+        abs = path.resolve(self2.cwd, f);
+      } else {
+        abs = path.resolve(f);
+      }
+      if (process.platform === "win32")
+        abs = abs.replace(/\\/g, "/");
+      return abs;
+    }
+    function isIgnored(self2, path2) {
+      if (!self2.ignore.length)
+        return false;
+      return self2.ignore.some(function(item) {
+        return item.matcher.match(path2) || !!(item.gmatcher && item.gmatcher.match(path2));
+      });
+    }
+    function childrenIgnored(self2, path2) {
+      if (!self2.ignore.length)
+        return false;
+      return self2.ignore.some(function(item) {
+        return !!(item.gmatcher && item.gmatcher.match(path2));
+      });
+    }
+  }
+});
+
+// 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 path = require("path");
+    var assert = require("assert");
+    var isAbsolute = require("path").isAbsolute;
+    var common = require_common();
+    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 = path.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 error = new Error(er.code + " invalid cwd " + this.cwd);
+            error.path = this.cwd;
+            error.code = er.code;
+            throw error;
+          }
+          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 = path.join(this.root, prefix);
+        } else {
+          prefix = path.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 path = require("path");
+    var assert = require("assert");
+    var isAbsolute = require("path").isAbsolute;
+    var globSync = require_sync();
+    var common = require_common();
+    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 = path.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 error = new Error(er.code + " invalid cwd " + this.cwd);
+            error.path = this.cwd;
+            error.code = er.code;
+            this.emit("error", error);
+            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 = path.join(this.root, prefix);
+        } else {
+          prefix = path.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/index.ts
+var import_glob;
+var init_serializer = __esm({
+  "src/serializer/index.ts"() {
+    import_glob = __toESM(require_glob());
+  }
+});
+
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -8785,9 +11128,9 @@ var ZodArray = class extends ZodType {
     return this.min(1, message);
   }
 };
-ZodArray.create = (schema3, params) => {
+ZodArray.create = (schema4, params) => {
   return new ZodArray({
-    type: schema3,
+    type: schema4,
     minLength: null,
     maxLength: null,
     exactLength: null,
@@ -8813,27 +11156,27 @@ var AugmentFactory = (def) => (augmentation) => {
     })
   });
 };
-function deepPartialify(schema3) {
-  if (schema3 instanceof ZodObject) {
+function deepPartialify(schema4) {
+  if (schema4 instanceof ZodObject) {
     const newShape = {};
-    for (const key in schema3.shape) {
-      const fieldSchema = schema3.shape[key];
+    for (const key in schema4.shape) {
+      const fieldSchema = schema4.shape[key];
       newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
     }
     return new ZodObject({
-      ...schema3._def,
+      ...schema4._def,
       shape: () => newShape
     });
-  } else if (schema3 instanceof ZodArray) {
-    return ZodArray.create(deepPartialify(schema3.element));
-  } else if (schema3 instanceof ZodOptional) {
-    return ZodOptional.create(deepPartialify(schema3.unwrap()));
-  } else if (schema3 instanceof ZodNullable) {
-    return ZodNullable.create(deepPartialify(schema3.unwrap()));
-  } else if (schema3 instanceof ZodTuple) {
-    return ZodTuple.create(schema3.items.map((item) => deepPartialify(item)));
+  } else if (schema4 instanceof ZodArray) {
+    return ZodArray.create(deepPartialify(schema4.element));
+  } else if (schema4 instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema4.unwrap()));
+  } else if (schema4 instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema4.unwrap()));
+  } else if (schema4 instanceof ZodTuple) {
+    return ZodTuple.create(schema4.items.map((item) => deepPartialify(item)));
   } else {
-    return schema3;
+    return schema4;
   }
 }
 var ZodObject = class extends ZodType {
@@ -8971,8 +11314,8 @@ var ZodObject = class extends ZodType {
       unknownKeys: "passthrough"
     });
   }
-  setKey(key, schema3) {
-    return this.augment({ [key]: schema3 });
+  setKey(key, schema4) {
+    return this.augment({ [key]: schema4 });
   }
   merge(merging) {
     const merged = new ZodObject({
@@ -9405,10 +11748,10 @@ var ZodTuple = class extends ZodType {
       status.dirty();
     }
     const items = ctx.data.map((item, itemIndex) => {
-      const schema3 = this._def.items[itemIndex] || this._def.rest;
-      if (!schema3)
+      const schema4 = this._def.items[itemIndex] || this._def.rest;
+      if (!schema4)
         return null;
-      return schema3._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+      return schema4._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
     }).filter((x) => !!x);
     if (ctx.common.async) {
       return Promise.all(items).then((results) => {
@@ -9901,9 +12244,9 @@ var ZodPromise = class extends ZodType {
     }));
   }
 };
-ZodPromise.create = (schema3, params) => {
+ZodPromise.create = (schema4, params) => {
   return new ZodPromise({
-    type: schema3,
+    type: schema4,
     typeName: ZodFirstPartyTypeKind.ZodPromise,
     ...processCreateParams(params)
   });
@@ -10010,17 +12353,17 @@ var ZodEffects = class extends ZodType {
     util.assertNever(effect);
   }
 };
-ZodEffects.create = (schema3, effect, params) => {
+ZodEffects.create = (schema4, effect, params) => {
   return new ZodEffects({
-    schema: schema3,
+    schema: schema4,
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     effect,
     ...processCreateParams(params)
   });
 };
-ZodEffects.createWithPreprocess = (preprocess, schema3, params) => {
+ZodEffects.createWithPreprocess = (preprocess, schema4, params) => {
   return new ZodEffects({
-    schema: schema3,
+    schema: schema4,
     effect: { type: "preprocess", transform: preprocess },
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params)
@@ -10962,22 +13305,22 @@ function applyJsonDiff(json1, json2) {
 var findAlternationsInTable = (table4, tableSchema) => {
   var _a;
   const columns = (_a = table4.columns) != null ? _a : {};
-  let schema3 = {
+  let schema4 = {
     type: "none",
     value: tableSchema
   };
   if ("schema" in table4) {
     if (table4.schema.__new) {
-      schema3 = { type: "changed", old: table4.schema.__old, new: table4.schema.__new };
+      schema4 = { type: "changed", old: table4.schema.__old, new: table4.schema.__new };
     } else {
-      schema3 = { type: "deleted", value: table4.schema.__old };
+      schema4 = { type: "deleted", value: table4.schema.__old };
     }
   }
   if ("schema__added" in table4) {
-    schema3 = { type: "added", value: table4.schema__added };
+    schema4 = { type: "added", value: table4.schema__added };
   }
   if ("schema__deleted" in table4) {
-    schema3 = { type: "deleted", value: table4.schema__deleted };
+    schema4 = { type: "deleted", value: table4.schema__deleted };
   }
   const added = Object.keys(columns).filter((it) => it.includes("__added")).map((it) => {
     return { ...columns[it] };
@@ -11013,7 +13356,7 @@ var findAlternationsInTable = (table4, tableSchema) => {
   const mappedAltered = altered.map((it) => alternationsInColumn(it));
   return {
     name: table4.name,
-    schema: schema3,
+    schema: schema4,
     deleted,
     added,
     altered: mappedAltered,
@@ -11091,10 +13434,30 @@ var alternationsInColumn = (column4) => {
       return { ...others, autoincrement: { type: "deleted", value: it.autoincrement__deleted } };
     }
     return it;
+  }).map((it) => {
+    if ("primaryKey" in it) {
+      return { ...it, primaryKey: { type: "changed", old: it.primaryKey.__old, new: it.primaryKey.__new } };
+    }
+    if ("primaryKey__added" in it) {
+      const { primaryKey__added, ...others } = it;
+      return { ...others, primaryKey: { type: "added", value: it.primaryKey__added } };
+    }
+    if ("primaryKey__deleted" in it) {
+      const { primaryKey__deleted, ...others } = it;
+      return { ...others, primaryKey: { type: "deleted", value: it.primaryKey__deleted } };
+    }
+    return it;
   });
   return result[0];
 };
 
+// src/migrationPreparator.ts
+init_serializer();
+
+// src/cli/commands/migrate.ts
+var import_hanji2 = __toESM(require_hanji());
+var BREAKPOINT = "--> statement-breakpoint\n";
+
 // src/sqlgenerator.ts
 var pgNativeTypes = /* @__PURE__ */ new Set([
   "uuid",
@@ -11150,9 +13513,9 @@ var PgCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "pg";
   }
   convert(st) {
-    const { tableName, schema: schema3, columns, compositePKs } = st;
+    const { tableName, schema: schema4, columns, compositePKs } = st;
     let statement = "";
-    const name = schema3 ? `"${schema3}"."${tableName}"` : `"${tableName}"`;
+    const name = schema4 ? `"${schema4}"."${tableName}"` : `"${tableName}"`;
     statement += `CREATE TABLE IF NOT EXISTS ${name} (
 `;
     for (let i = 0; i < columns.length; i++) {
@@ -11169,6 +13532,7 @@ var PgCreateTableConvertor = class extends Convertor {
 `;
     if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
       const compositePK4 = PgSquasher.unsquashPK(compositePKs[0]);
+      statement += BREAKPOINT;
       statement += `ALTER TABLE ${name} ADD CONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK4.columns.join('","')}");`;
       statement += `
 `;
@@ -11181,9 +13545,9 @@ var MySqlCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "mysql";
   }
   convert(st) {
-    const { tableName, columns, schema: schema3, compositePKs } = st;
+    const { tableName, columns, schema: schema4, compositePKs } = st;
     let statement = "";
-    const tName = schema3 ? `\`${schema3}\`.\`${tableName}\`` : `\`${tableName}\``;
+    const tName = schema4 ? `\`${schema4}\`.\`${tableName}\`` : `\`${tableName}\``;
     statement += `CREATE TABLE ${tName} (
 `;
     for (let i = 0; i < columns.length; i++) {
@@ -11201,7 +13565,10 @@ var MySqlCreateTableConvertor = class extends Convertor {
 `;
     if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
       const compositePK4 = MySqlSquasher.unsquashPK(compositePKs[0]);
-      statement += `ALTER TABLE ${tName} ADD PRIMARY KEY(\`${compositePK4.columns.join("`,`")}\`);`;
+      statement += BREAKPOINT;
+      statement += `ALTER TABLE ${tName} ADD PRIMARY KEY(\`${compositePK4.columns.join(
+        "`,`"
+      )}\`);`;
       statement += `
 `;
     }
@@ -11303,9 +13670,9 @@ var PgRenameTableConvertor = class extends Convertor {
     return statement.type === "rename_table" && dialect3 === "pg";
   }
   convert(statement) {
-    const { tableNameFrom, tableNameTo, toSchema: schema3 } = statement;
-    const from = schema3 ? `"${schema3}"."${tableNameFrom}"` : `"${tableNameFrom}"`;
-    const to = schema3 ? `"${schema3}"."${tableNameTo}"` : `"${tableNameTo}"`;
+    const { tableNameFrom, tableNameTo, toSchema: schema4 } = statement;
+    const from = schema4 ? `"${schema4}"."${tableNameFrom}"` : `"${tableNameFrom}"`;
+    const to = schema4 ? `"${schema4}"."${tableNameTo}"` : `"${tableNameTo}"`;
     return `ALTER TABLE ${from} RENAME TO ${to};`;
   }
 };
@@ -11601,7 +13968,7 @@ var PgAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor {
       statement.new
     );
     return `ALTER TABLE "${statement.tableName}" DROP CONSTRAINT ${statement.oldConstraintName};
-ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintName} PRIMARY KEY(${newColumns.join(",")});`;
+${BREAKPOINT}ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintName} PRIMARY KEY(${newColumns.join(",")});`;
   }
 };
 var MySqlAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
@@ -11713,6 +14080,39 @@ var SqliteAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor
     return msg;
   }
 };
+var PgAlterTableAlterColumnSetPrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "alter_table_alter_column_set_primarykey" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const { tableName, columnName } = statement;
+    return `ALTER TABLE "${tableName}" ADD PRIMARY KEY ("${columnName}");`;
+  }
+};
+var PgAlterTableAlterColumnDropPrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "alter_table_alter_column_drop_primarykey" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const { tableName, columnName, schema: schema4 } = statement;
+    return `/* 
+    Unfortunately in current drizzle-kit version we can't automatically get name for primary key.
+    We are working on making it available!
+
+    Meanwhile you can:
+        1. Check pk name in your database, by running
+            SELECT constraint_name FROM information_schema.table_constraints
+            WHERE table_schema = '${typeof schema4 === "undefined" || schema4 === "" ? "public" : schema4}'
+                AND table_name = '${tableName}'
+                AND constraint_type = 'PRIMARY KEY';
+        2. Uncomment code below and paste pk name manually
+        
+    Hope to release this update as soon as possible
+*/
+
+-- ALTER TABLE "${tableName}" DROP CONSTRAINT "<constraint_name>";`;
+  }
+};
 var PgAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
   can(statement, dialect3) {
     return statement.type === "alter_table_alter_column_set_notnull" && dialect3 === "pg";
@@ -11978,8 +14378,8 @@ var PgAlterTableSetSchemaConvertor = class extends Convertor {
     return statement.type === "alter_table_set_schema" && dialect3 === "pg";
   }
   convert(statement) {
-    const { tableName, schema: schema3 } = statement;
-    return `ALTER TABLE "${tableName}" SET SCHEMA "${schema3}";
+    const { tableName, schema: schema4 } = statement;
+    return `ALTER TABLE "${tableName}" SET SCHEMA "${schema4}";
 `;
   }
 };
@@ -12037,9 +14437,9 @@ var MysqlAlterTableSetSchemaConvertor = class extends Convertor {
     return statement.type === "alter_table_set_schema" && dialect3 === "mysql";
   }
   convert(statement) {
-    const { tableName, schema: schema3 } = statement;
+    const { tableName, schema: schema4 } = statement;
     const nameFrom = `\`${tableName}\``;
-    const nameTo = `\`${schema3}\`.\`${tableName}\``;
+    const nameTo = `\`${schema4}\`.\`${tableName}\``;
     return `RENAME TABLE ${nameFrom} TO ${nameTo};
 `;
   }
@@ -12061,8 +14461,8 @@ var MysqlAlterTableRemoveFromSchemaConvertor = class extends Convertor {
     return statement.type === "alter_table_remove_from_schema" && dialect3 === "mysql";
   }
   convert(statement) {
-    const { tableName, schema: schema3 } = statement;
-    const nameFrom = `\`${schema3}\`.\`${tableName}\``;
+    const { tableName, schema: schema4 } = statement;
+    const nameFrom = `\`${schema4}\`.\`${tableName}\``;
     const nameTo = `\`${tableName}\``;
     return `RENAME TABLE ${nameFrom} TO ${nameTo};
 `;
@@ -12104,6 +14504,8 @@ convertors.push(new PgDropIndexConvertor());
 convertors.push(new SqliteDropIndexConvertor());
 convertors.push(new MySqlDropIndexConvertor());
 convertors.push(new AlterTypeAddValueConvertor());
+convertors.push(new PgAlterTableAlterColumnSetPrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterColumnDropPrimaryKeyConvertor());
 convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
 convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
 convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
@@ -12152,7 +14554,7 @@ var fromJson = (statements, dialect3) => {
     const convertor = filtered.length === 1 ? filtered[0] : void 0;
     if (!convertor) {
       console.log("no convertor:", statement.type, dialect3);
-      return "dry run";
+      return "";
     }
     return convertor.convert(statement);
   });
@@ -12185,11 +14587,11 @@ drop type __venum;
 
 // src/jsonStatements.ts
 var preparePgCreateTableJson = (table4, json2) => {
-  const { name, schema: schema3, columns, compositePrimaryKeys } = table4;
+  const { name, schema: schema4, columns, compositePrimaryKeys } = table4;
   return {
     type: "create_table",
     tableName: name,
-    schema: schema3,
+    schema: schema4,
     columns: Object.values(columns),
     compositePKs: Object.values(compositePrimaryKeys),
     compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${PgSquasher.unsquashPK(
@@ -12198,11 +14600,11 @@ var preparePgCreateTableJson = (table4, json2) => {
   };
 };
 var prepareMySqlCreateTableJson = (table4, json2) => {
-  const { name, schema: schema3, columns, compositePrimaryKeys } = table4;
+  const { name, schema: schema4, columns, compositePrimaryKeys } = table4;
   return {
     type: "create_table",
     tableName: name,
-    schema: schema3,
+    schema: schema4,
     columns: Object.values(columns),
     compositePKs: Object.values(compositePrimaryKeys),
     compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${MySqlSquasher.unsquashPK(
@@ -12281,21 +14683,21 @@ var prepareDeleteSchemasJson = (values) => {
     };
   });
 };
-var prepareRenameColumns = (tableName, schema3, pairs) => {
+var prepareRenameColumns = (tableName, schema4, pairs) => {
   return pairs.map((it) => {
     return {
       type: "alter_table_rename_column",
       tableName,
       oldColumnName: it.from.name,
       newColumnName: it.to.name,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var prepareAlterTableColumnsJson = (tableName, schema3, deleted, added, altered, addedFk, json2, dialect3) => {
+var prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, json2, dialect3) => {
   const addColumns = [];
-  const dropColumns = _prepareDropColumns(tableName, schema3, deleted);
-  const alterColumns = _prepareAlterColumns(tableName, schema3, altered, json2);
+  const dropColumns = _prepareDropColumns(tableName, schema4, deleted);
+  const alterColumns = _prepareAlterColumns(tableName, schema4, altered, json2);
   if (dialect3 === "sqlite") {
     let jsonCreateFKStatements = Object.values(addedFk);
     const sqliteAddColumns = _prepareSQLiteAddColumns(
@@ -12305,27 +14707,27 @@ var prepareAlterTableColumnsJson = (tableName, schema3, deleted, added, altered,
     );
     addColumns.push(...sqliteAddColumns);
   } else {
-    addColumns.push(..._prepareAddColumns(tableName, schema3, added));
+    addColumns.push(..._prepareAddColumns(tableName, schema4, added));
   }
   return { addColumns, dropColumns, alterColumns };
 };
-var _prepareDropColumns = (taleName, schema3, columns) => {
+var _prepareDropColumns = (taleName, schema4, columns) => {
   return columns.map((it) => {
     return {
       type: "alter_table_drop_column",
       tableName: taleName,
       columnName: it.name,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var _prepareAddColumns = (tableName, schema3, columns) => {
+var _prepareAddColumns = (tableName, schema4, columns) => {
   return columns.map((it) => {
     return {
       type: "alter_table_add_column",
       tableName,
       column: it,
-      schema: schema3
+      schema: schema4
     };
   });
 };
@@ -12345,8 +14747,8 @@ var _prepareSQLiteAddColumns = (tableName, columns, referenceData) => {
     };
   });
 };
-var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+var _prepareAlterColumns = (tableName, schema4, columns, json2) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   let statements = [];
   for (const column4 of columns) {
     const columnName = typeof column4.name !== "string" ? column4.name.new : column4.name;
@@ -12361,7 +14763,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         tableName,
         oldColumnName: column4.name.old,
         newColumnName: column4.name.new,
-        schema: schema3
+        schema: schema4
       });
     }
     if (((_a = column4.type) == null ? void 0 : _a.type) === "changed") {
@@ -12370,7 +14772,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         tableName,
         columnName,
         newDataType: column4.type.new,
-        schema: schema3,
+        schema: schema4,
         columnDefault,
         columnOnUpdate,
         columnNotNull,
@@ -12383,7 +14785,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         tableName,
         columnName,
         newDefaultValue: column4.default.value,
-        schema: schema3
+        schema: schema4
       });
     }
     if (((_c = column4.default) == null ? void 0 : _c.type) === "changed") {
@@ -12392,7 +14794,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         tableName,
         columnName,
         newDefaultValue: column4.default.new,
-        schema: schema3
+        schema: schema4
       });
     }
     if (((_d = column4.default) == null ? void 0 : _d.type) === "deleted") {
@@ -12400,7 +14802,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type: "alter_table_alter_column_drop_default",
         tableName,
         columnName,
-        schema: schema3
+        schema: schema4
       });
     }
     if (((_e = column4.notNull) == null ? void 0 : _e.type) === "added") {
@@ -12408,7 +14810,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type: "alter_table_alter_column_set_notnull",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12422,7 +14824,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type,
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12435,7 +14837,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type: "alter_table_alter_column_drop_notnull",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12448,7 +14850,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type: "alter_table_alter_column_set_autoincrement",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12462,7 +14864,7 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type,
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12475,7 +14877,47 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         type: "alter_table_alter_column_drop_autoincrement",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
+        newDataType: columnType,
+        columnDefault,
+        columnOnUpdate,
+        columnNotNull,
+        columnAutoIncrement
+      });
+    }
+    if (((_k = column4.primaryKey) == null ? void 0 : _k.type) === "added") {
+      statements.push({
+        type: "alter_table_alter_column_set_primarykey",
+        tableName,
+        columnName,
+        schema: schema4,
+        newDataType: columnType,
+        columnDefault,
+        columnOnUpdate,
+        columnNotNull,
+        columnAutoIncrement
+      });
+    }
+    if (((_l = column4.primaryKey) == null ? void 0 : _l.type) === "changed") {
+      const type = column4.primaryKey.new ? "alter_table_alter_column_set_primarykey" : "alter_table_alter_column_drop_primarykey";
+      statements.push({
+        type,
+        tableName,
+        columnName,
+        schema: schema4,
+        newDataType: columnType,
+        columnDefault,
+        columnOnUpdate,
+        columnNotNull,
+        columnAutoIncrement
+      });
+    }
+    if (((_m = column4.primaryKey) == null ? void 0 : _m.type) === "deleted") {
+      statements.push({
+        type: "alter_table_alter_column_drop_primarykey",
+        tableName,
+        columnName,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12483,12 +14925,12 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         columnAutoIncrement
       });
     }
-    if (((_k = column4.onUpdate) == null ? void 0 : _k.type) === "added") {
+    if (((_n = column4.onUpdate) == null ? void 0 : _n.type) === "added") {
       statements.push({
         type: "alter_table_alter_column_set_on_update",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12496,12 +14938,12 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
         columnAutoIncrement
       });
     }
-    if (((_l = column4.onUpdate) == null ? void 0 : _l.type) === "deleted") {
+    if (((_o = column4.onUpdate) == null ? void 0 : _o.type) === "deleted") {
       statements.push({
         type: "alter_table_alter_column_drop_on_update",
         tableName,
         columnName,
-        schema: schema3,
+        schema: schema4,
         newDataType: columnType,
         columnDefault,
         columnOnUpdate,
@@ -12512,54 +14954,54 @@ var _prepareAlterColumns = (tableName, schema3, columns, json2) => {
   }
   return statements;
 };
-var prepareCreateIndexesJson = (tableName, schema3, indexes) => {
+var prepareCreateIndexesJson = (tableName, schema4, indexes) => {
   return Object.values(indexes).map((indexData) => {
     return {
       type: "create_index",
       tableName,
       data: indexData,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var prepareCreateReferencesJson = (tableName, schema3, foreignKeys) => {
+var prepareCreateReferencesJson = (tableName, schema4, foreignKeys) => {
   return Object.values(foreignKeys).map((fkData) => {
     return {
       type: "create_reference",
       tableName,
       data: fkData,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var prepareDropReferencesJson = (tableName, schema3, foreignKeys) => {
+var prepareDropReferencesJson = (tableName, schema4, foreignKeys) => {
   return Object.values(foreignKeys).map((fkData) => {
     return {
       type: "delete_reference",
       tableName,
       data: fkData,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var prepareAlterReferencesJson = (tableName, schema3, foreignKeys) => {
+var prepareAlterReferencesJson = (tableName, schema4, foreignKeys) => {
   return Object.values(foreignKeys).map((fkData) => {
     return {
       type: "alter_reference",
       tableName,
       data: fkData.__new,
       oldFkey: fkData.__old,
-      schema: schema3
+      schema: schema4
     };
   });
 };
-var prepareDropIndexesJson = (tableName, schema3, indexes) => {
+var prepareDropIndexesJson = (tableName, schema4, indexes) => {
   return Object.values(indexes).map((indexData) => {
     return {
       type: "drop_index",
       tableName,
       data: indexData,
-      schema: schema3
+      schema: schema4
     };
   });
 };
@@ -12657,58 +15099,58 @@ var prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json2) => {
 };
 
 // src/snapshotsDiffer.ts
-var makeChanged = (schema3) => {
+var makeChanged = (schema4) => {
   return objectType({
     type: enumType(["changed"]),
-    old: schema3,
-    new: schema3
+    old: schema4,
+    new: schema4
   });
 };
-var makeSelfOrChanged = (schema3) => {
+var makeSelfOrChanged = (schema4) => {
   return unionType([
-    schema3,
+    schema4,
     objectType({
       type: enumType(["changed"]),
-      old: schema3,
-      new: schema3
+      old: schema4,
+      new: schema4
     })
   ]);
 };
-var makePatched = (schema3) => {
+var makePatched = (schema4) => {
   return unionType([
     objectType({
       type: literalType("added"),
-      value: schema3
+      value: schema4
     }),
     objectType({
       type: literalType("deleted"),
-      value: schema3
+      value: schema4
     }),
     objectType({
       type: literalType("changed"),
-      old: schema3,
-      new: schema3
+      old: schema4,
+      new: schema4
     })
   ]);
 };
-var makeSelfOrPatched = (schema3) => {
+var makeSelfOrPatched = (schema4) => {
   return unionType([
     objectType({
       type: literalType("none"),
-      value: schema3.optional()
+      value: schema4.optional()
     }),
     objectType({
       type: literalType("added"),
-      value: schema3
+      value: schema4
     }),
     objectType({
       type: literalType("deleted"),
-      value: schema3
+      value: schema4
     }),
     objectType({
       type: literalType("changed"),
-      old: schema3,
-      new: schema3
+      old: schema4,
+      new: schema4
     })
   ]);
 };
@@ -12740,6 +15182,7 @@ var alteredColumnSchema = objectType({
   default: makePatched(anyType()).optional(),
   notNull: makePatched(booleanType()).optional(),
   onUpdate: makePatched(booleanType()).optional(),
+  primaryKey: makePatched(booleanType()).optional(),
   autoincrement: makePatched(booleanType()).optional()
 }).strict();
 var enumSchema2 = objectType({
@@ -12851,9 +15294,9 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
       created: table4.added,
       deleted: table4.deleted
     });
-    const schema3 = valueFromSelfOrPatchedNew(table4.schema);
+    const schema4 = valueFromSelfOrPatchedNew(table4.schema);
     jsonRenameColumnsStatements.push(
-      ...prepareRenameColumns(table4.name, schema3, result.renamed)
+      ...prepareRenameColumns(table4.name, schema4, result.renamed)
     );
     const renamedColumnsAltered = result.renamed.map(
       (it) => alteredColumnSchema.parse(diffForRenamedColumn(it.from, it.to))
@@ -12969,17 +15412,17 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
   });
   const rColumns = jsonRenameColumnsStatements.map((it) => {
     const tableName = it.tableName;
-    const schema3 = it.schema;
+    const schema4 = it.schema;
     return {
-      from: { schema: schema3, table: tableName, column: it.oldColumnName },
-      to: { schema: schema3, table: tableName, column: it.newColumnName }
+      from: { schema: schema4, table: tableName, column: it.oldColumnName },
+      to: { schema: schema4, table: tableName, column: it.newColumnName }
     };
   });
   const jsonTableAlternations = allAlteredResolved.map((it) => {
-    const schema3 = valueFromSelfOrPatchedNew(it.schema);
+    const schema4 = valueFromSelfOrPatchedNew(it.schema);
     return prepareAlterTableColumnsJson(
       it.name,
-      schema3,
+      schema4,
       it.deleted,
       it.added,
       it.altered,
@@ -12997,27 +15440,27 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     { createColumns: [], dropColumns: [], alterColumns: [] }
   );
   const jsonCreateIndexesForAllAlteredTables = allAltered.map((it) => {
-    const schema3 = valueFromSelfOrPatchedNew(it.schema);
-    return prepareCreateIndexesJson(it.name, schema3, it.addedIndexes || {});
+    const schema4 = valueFromSelfOrPatchedNew(it.schema);
+    return prepareCreateIndexesJson(it.name, schema4, it.addedIndexes || {});
   }).flat();
   const jsonDropIndexesForAllAlteredTables = allAltered.map((it) => {
-    const schema3 = valueFromSelfOrPatchedNew(it.schema);
-    return prepareDropIndexesJson(it.name, schema3, it.deletedIndexes || {});
+    const schema4 = valueFromSelfOrPatchedNew(it.schema);
+    return prepareDropIndexesJson(it.name, schema4, it.deletedIndexes || {});
   }).flat();
   const jsonCreateReferencesForCreatedTables = created.map((it) => {
     return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
   }).flat();
   const jsonReferencesForAllAlteredTables = allAltered.map((it) => {
-    const schema3 = valueFromSelfOrPatchedNew(it.schema);
-    const forAdded = dialect3 !== "sqlite" ? prepareCreateReferencesJson(it.name, schema3, it.addedForeignKeys) : [];
+    const schema4 = valueFromSelfOrPatchedNew(it.schema);
+    const forAdded = dialect3 !== "sqlite" ? prepareCreateReferencesJson(it.name, schema4, it.addedForeignKeys) : [];
     const forAltered = prepareDropReferencesJson(
       it.name,
-      schema3,
+      schema4,
       it.deletedForeignKeys
     );
     const alteredFKs = prepareAlterReferencesJson(
       it.name,
-      schema3,
+      schema4,
       it.alteredForeignKeys
     );
     return [...forAdded, ...forAltered, ...alteredFKs];
@@ -13370,8 +15813,8 @@ var tableRenameKey = (it) => {
   const out = it.schema ? `"${it.schema}"."${it.name}"` : `"${it.name}"`;
   return out;
 };
-var columnRenameKey = (table4, schema3, column4) => {
-  const out = schema3 ? `"${schema3}"."${table4}"."${column4}"` : `"${table4}"."${column4}"`;
+var columnRenameKey = (table4, schema4, column4) => {
+  const out = schema4 ? `"${schema4}"."${table4}"."${column4}"` : `"${table4}"."${column4}"`;
   return out;
 };
 var kloudMeta = () => {
@@ -13422,11 +15865,11 @@ var statementsForDiffs = async (in1, in2) => {
   };
   const columnsResolver = async (input) => {
     const tableName = input.tableName;
-    const schema3 = input.schema;
+    const schema4 = input.schema;
     const predicate = (leftMissing, created2) => {
       for (let i = 0; i < leftMissing.length; i++) {
         const it = leftMissing[i];
-        if (right._meta.columns[columnRenameKey(tableName, schema3, it.name)] === columnRenameKey(tableName, schema3, created2.name)) {
+        if (right._meta.columns[columnRenameKey(tableName, schema4, it.name)] === columnRenameKey(tableName, schema4, created2.name)) {
           return it;
         }
       }
@@ -13437,7 +15880,7 @@ var statementsForDiffs = async (in1, in2) => {
       input.created,
       predicate
     );
-    return { tableName, schema: schema3, created, renamed, deleted };
+    return { tableName, schema: schema4, created, renamed, deleted };
   };
   const result = await applySnapshotsDiff(
     lsquashed,