@prisma/cli-init 0.7.0 → 0.8.0

package/dist/{chunk-YTWW6A72.js → chunk-7WBH7PZA.js}

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
-// ../../node_modules/.pnpm/valibot@1.2.0_typescript@5.8.3/node_modules/valibot/dist/index.mjs
+// ../../node_modules/.pnpm/valibot@1.2.0_typescript@5.9.3/node_modules/valibot/dist/index.mjs
 var store$4;
 // @__NO_SIDE_EFFECTS__
 function getGlobalConfig(config$1) {
@@ -693,7 +693,7 @@ function withResolvers(options) {
   };
 }
 
-// ../../node_modules/.pnpm/std-env@3.9.0/node_modules/std-env/dist/index.mjs
+// ../../node_modules/.pnpm/std-env@3.10.0/node_modules/std-env/dist/index.mjs
 var r = /* @__PURE__ */ Object.create(null);
 var i = (e) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e ? r : globalThis);
 var o = new Proxy(r, { get(e, s) {
@@ -829,7 +829,110 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
   return linux(name);
 }
 
-// ../../node_modules/.pnpm/grammex@3.1.10/node_modules/grammex/dist/utils.js
+// ../../node_modules/.pnpm/graphmatch@1.1.0/node_modules/graphmatch/dist/utils.js
+var getNodes = (node) => {
+  const nodes = /* @__PURE__ */ new Set();
+  const queue = [node];
+  for (let i2 = 0; i2 < queue.length; i2++) {
+    const node2 = queue[i2];
+    if (nodes.has(node2))
+      continue;
+    nodes.add(node2);
+    const { children } = node2;
+    if (!children?.length)
+      continue;
+    for (let ci = 0, cl = children.length; ci < cl; ci++) {
+      queue.push(children[ci]);
+    }
+  }
+  return Array.from(nodes);
+};
+var getNodeFlags = (node) => {
+  let flags = "";
+  const nodes = getNodes(node);
+  for (let i2 = 0, l2 = nodes.length; i2 < l2; i2++) {
+    const node2 = nodes[i2];
+    if (!node2.regex)
+      continue;
+    const nodeFlags = node2.regex.flags;
+    flags || (flags = nodeFlags);
+    if (flags === nodeFlags)
+      continue;
+    throw new Error(`Inconsistent RegExp flags used: "${flags}" and "${nodeFlags}"`);
+  }
+  return flags;
+};
+var getNodeSourceWithCache = (node, partial, cache) => {
+  const cached = cache.get(node);
+  if (cached !== void 0)
+    return cached;
+  const isNodePartial = node.partial ?? partial;
+  let source = "";
+  if (node.regex) {
+    source += isNodePartial ? "(?:$|" : "";
+    source += node.regex.source;
+  }
+  if (node.children?.length) {
+    const children = uniq(node.children.map((node2) => getNodeSourceWithCache(node2, partial, cache)).filter(Boolean));
+    if (children?.length) {
+      const isSomeChildNonPartial = node.children.some((child) => !child.regex || !(child.partial ?? partial));
+      const needsWrapperGroup = children.length > 1 || isNodePartial && (!source.length || isSomeChildNonPartial);
+      source += needsWrapperGroup ? isNodePartial ? "(?:$|" : "(?:" : "";
+      source += children.join("|");
+      source += needsWrapperGroup ? ")" : "";
+    }
+  }
+  if (node.regex) {
+    source += isNodePartial ? ")" : "";
+  }
+  cache.set(node, source);
+  return source;
+};
+var getNodeSource = (node, partial) => {
+  const cache = /* @__PURE__ */ new Map();
+  const nodes = getNodes(node);
+  for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+    const source = getNodeSourceWithCache(nodes[i2], partial, cache);
+    if (i2 > 0)
+      continue;
+    return source;
+  }
+  return "";
+};
+var uniq = (values) => {
+  return Array.from(new Set(values));
+};
+
+// ../../node_modules/.pnpm/graphmatch@1.1.0/node_modules/graphmatch/dist/index.js
+var graphmatch = (node, input, options) => {
+  return graphmatch.compile(node, options).test(input);
+};
+graphmatch.compile = (node, options) => {
+  const partial = options?.partial ?? false;
+  const source = getNodeSource(node, partial);
+  const flags = getNodeFlags(node);
+  return new RegExp(`^(?:${source})$`, flags);
+};
+var dist_default = graphmatch;
+
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/compile/index.js
+var compile = (node, options) => {
+  const re = dist_default.compile(node, options);
+  const source = `${re.source.slice(0, -1)}[\\\\/]?$`;
+  const flags = re.flags;
+  return new RegExp(source, flags);
+};
+var compile_default = compile;
+
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/merge/index.js
+var merge = (res) => {
+  const source = res.map((re) => re.source).join("|") || "$^";
+  const flags = res[0]?.flags;
+  return new RegExp(source, flags);
+};
+var merge_default = merge;
+
+// ../../node_modules/.pnpm/grammex@3.1.12/node_modules/grammex/dist/utils.js
 var isArray = (value) => {
   return Array.isArray(value);
 };
@@ -885,7 +988,7 @@ var memoize = (fn) => {
   };
 };
 
-// ../../node_modules/.pnpm/grammex@3.1.10/node_modules/grammex/dist/index.js
+// ../../node_modules/.pnpm/grammex@3.1.12/node_modules/grammex/dist/index.js
 var parse = (input, rule, options = {}) => {
   const state = { cache: {}, input, index: 0, indexBacktrackMax: 0, options, output: [] };
   const matched = resolve(rule)(state);
@@ -1034,6 +1137,9 @@ var optional2 = (rule, handler) => {
 var star = (rule, handler) => {
   return repeat(rule, 0, Infinity, handler);
 };
+var plus = (rule, handler) => {
+  return repeat(rule, 1, Infinity, handler);
+};
 var and = (rules, handler) => {
   const erules = rules.map(resolve);
   return memoizable(handleable(backtrackable((state) => {
@@ -1179,23 +1285,51 @@ var resolve = memoize((rule) => {
   throw new Error("Invalid rule");
 });
 
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/utils.js
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/utils.js
 var identity = (value) => {
   return value;
 };
-var makeParser = (grammar) => {
-  return (input) => {
-    return parse(input, grammar, { memoization: false }).join("");
+var isString2 = (value) => {
+  return typeof value === "string";
+};
+var memoizeByObject = (fn) => {
+  const cacheFull = /* @__PURE__ */ new WeakMap();
+  const cachePartial = /* @__PURE__ */ new WeakMap();
+  return (globs, options) => {
+    const cache = options?.partial ? cachePartial : cacheFull;
+    const cached = cache.get(globs);
+    if (cached !== void 0)
+      return cached;
+    const result = fn(globs, options);
+    cache.set(globs, result);
+    return result;
   };
 };
-var memoize2 = (fn) => {
-  const cache = {};
-  return (arg) => {
-    return cache[arg] ?? (cache[arg] = fn(arg));
+var memoizeByPrimitive = (fn) => {
+  const cacheFull = {};
+  const cachePartial = {};
+  return (glob, options) => {
+    const cache = options?.partial ? cachePartial : cacheFull;
+    return cache[glob] ?? (cache[glob] = fn(glob, options));
   };
 };
 
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/range.js
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/normalize/grammar.js
+var Escaped = match(/\\./, identity);
+var Passthrough = match(/./, identity);
+var StarStarStar = match(/\*\*\*+/, "*");
+var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_2, $1) => `${$1}*`);
+var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_2, $1) => `${$1}*`);
+var Grammar = star(or([Escaped, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough]));
+var grammar_default = Grammar;
+
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/normalize/index.js
+var normalize = (glob) => {
+  return parse(glob, grammar_default, { memoization: false }).join("");
+};
+var normalize_default = normalize;
+
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/range.js
 var ALPHABET = "abcdefghijklmnopqrstuvwxyz";
 var int2alpha = (int) => {
   let alpha = "";
@@ -1229,82 +1363,121 @@ var makeRangeAlpha = (start, end) => {
   return makeRangeInt(alpha2int(start), alpha2int(end)).map(int2alpha);
 };
 
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/convert/grammar.js
-var Escaped = match(/\\./, identity);
-var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => `\\${char}`);
-var Slash = match(/[\\/]/, "[\\\\/]");
-var Passthrough = match(/./, identity);
-var NegationOdd = match(/^(?:!!)*!(.*)$/, (_2, glob) => `(?!^${parser_default(glob)}$).*?`);
-var NegationEven = match(/^(!!)+/, "");
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/parse/utils.js
+var regex3 = (source) => {
+  const regex4 = new RegExp(source, "s");
+  return { partial: false, regex: regex4, children: [] };
+};
+var alternation = (children) => {
+  return { children };
+};
+var sequence = /* @__PURE__ */ (() => {
+  const pushToLeaves = (parent, child, handled) => {
+    if (handled.has(parent))
+      return;
+    handled.add(parent);
+    const { children } = parent;
+    if (!children.length) {
+      children.push(child);
+    } else {
+      for (let i2 = 0, l2 = children.length; i2 < l2; i2++) {
+        pushToLeaves(children[i2], child, handled);
+      }
+    }
+  };
+  return (nodes) => {
+    if (!nodes.length) {
+      return alternation([]);
+    }
+    for (let i2 = nodes.length - 1; i2 >= 1; i2--) {
+      const handled = /* @__PURE__ */ new Set();
+      const parent = nodes[i2 - 1];
+      const child = nodes[i2];
+      pushToLeaves(parent, child, handled);
+    }
+    return nodes[0];
+  };
+})();
+var slash = () => {
+  const regex4 = new RegExp("[\\\\/]", "s");
+  return { regex: regex4, children: [] };
+};
+
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/parse/grammar.js
+var Escaped2 = match(/\\./, regex3);
+var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => regex3(`\\${char}`));
+var Slash = match(/[\\\/]/, slash);
+var Passthrough2 = match(/[^$.*+?^(){}[\]\|\\\/]+/, regex3);
+var NegationOdd = match(/^(?:!!)*!(.*)$/, (_2, glob) => regex3(`(?!^${dist_default2.compile(glob).source}$).*?`));
+var NegationEven = match(/^(!!)+/);
 var Negation = or([NegationOdd, NegationEven]);
-var StarStarBetween = match(/\/(\*\*\/)+/, "(?:[\\\\/].+[\\\\/]|[\\\\/])");
-var StarStarStart = match(/^(\*\*\/)+/, "(?:^|.*[\\\\/])");
-var StarStarEnd = match(/\/(\*\*)$/, "(?:[\\\\/].*|$)");
-var StarStarNone = match(/\*\*/, ".*");
+var StarStarBetween = match(/\/(\*\*\/)+/, () => alternation([sequence([slash(), regex3(".+?"), slash()]), slash()]));
+var StarStarStart = match(/^(\*\*\/)+/, () => alternation([regex3("^"), sequence([regex3(".*?"), slash()])]));
+var StarStarEnd = match(/\/(\*\*)$/, () => alternation([sequence([slash(), regex3(".*?")]), regex3("$")]));
+var StarStarNone = match(/\*\*/, () => regex3(".*?"));
 var StarStar = or([StarStarBetween, StarStarStart, StarStarEnd, StarStarNone]);
-var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, "[^\\\\/]*[\\\\/]");
-var StarSingle = match(/\*/, "[^\\\\/]*");
+var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, () => sequence([regex3("[^\\\\/]*?"), slash()]));
+var StarSingle = match(/\*/, () => regex3("[^\\\\/]*"));
 var Star = or([StarDouble, StarSingle]);
-var Question = match("?", "[^\\\\/]");
+var Question = match("?", () => regex3("[^\\\\/]"));
 var ClassOpen = match("[", identity);
 var ClassClose = match("]", identity);
 var ClassNegation = match(/[!^]/, "^\\\\/");
 var ClassRange = match(/[a-z]-[a-z]|[0-9]-[0-9]/i, identity);
+var ClassEscaped = match(/\\./, identity);
 var ClassEscape = match(/[$.*+?^(){}[\|]/, (char) => `\\${char}`);
-var ClassPassthrough = match(/[^\]]/, identity);
-var ClassValue = or([Escaped, ClassEscape, ClassRange, ClassPassthrough]);
-var Class = and([ClassOpen, optional2(ClassNegation), star(ClassValue), ClassClose]);
+var ClassSlash = match(/[\\\/]/, "\\\\/");
+var ClassPassthrough = match(/[^$.*+?^(){}[\]\|\\\/]+/, identity);
+var ClassValue = or([ClassEscaped, ClassEscape, ClassSlash, ClassRange, ClassPassthrough]);
+var Class = and([ClassOpen, optional2(ClassNegation), star(ClassValue), ClassClose], (_2) => regex3(_2.join("")));
 var RangeOpen = match("{", "(?:");
 var RangeClose = match("}", ")");
 var RangeNumeric = match(/(\d+)\.\.(\d+)/, (_2, $1, $2) => makeRangePaddedInt(+$1, +$2, Math.min($1.length, $2.length)).join("|"));
 var RangeAlphaLower = match(/([a-z]+)\.\.([a-z]+)/, (_2, $1, $2) => makeRangeAlpha($1, $2).join("|"));
 var RangeAlphaUpper = match(/([A-Z]+)\.\.([A-Z]+)/, (_2, $1, $2) => makeRangeAlpha($1.toLowerCase(), $2.toLowerCase()).join("|").toUpperCase());
 var RangeValue = or([RangeNumeric, RangeAlphaLower, RangeAlphaUpper]);
-var Range = and([RangeOpen, RangeValue, RangeClose]);
-var BracesOpen = match("{", "(?:");
-var BracesClose = match("}", ")");
-var BracesComma = match(",", "|");
-var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => `\\${char}`);
-var BracesPassthrough = match(/[^}]/, identity);
+var Range = and([RangeOpen, RangeValue, RangeClose], (_2) => regex3(_2.join("")));
+var BracesOpen = match("{");
+var BracesClose = match("}");
+var BracesComma = match(",");
+var BracesEscaped = match(/\\./, regex3);
+var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => regex3(`\\${char}`));
+var BracesSlash = match(/[\\\/]/, slash);
+var BracesPassthrough = match(/[^$.*+?^(){}[\]\|\\\/,]+/, regex3);
 var BracesNested = lazy(() => Braces);
-var BracesValue = or([StarStar, Star, Question, Class, Range, BracesNested, Escaped, BracesEscape, BracesComma, BracesPassthrough]);
-var Braces = and([BracesOpen, star(BracesValue), BracesClose]);
-var Grammar = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped, Escape, Slash, Passthrough]));
-var grammar_default = Grammar;
-
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/convert/parser.js
-var parser = makeParser(grammar_default);
-var parser_default = parser;
-
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/normalize/grammar.js
-var Escaped2 = match(/\\./, identity);
-var Passthrough2 = match(/./, identity);
-var StarStarStar = match(/\*\*\*+/, "*");
-var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_2, $1) => `${$1}*`);
-var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_2, $1) => `${$1}*`);
-var Grammar2 = star(or([Escaped2, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough2]));
+var BracesEmptyValue = match("", () => regex3("(?:)"));
+var BracesFullValue = plus(or([StarStar, Star, Question, Class, Range, BracesNested, BracesEscaped, BracesEscape, BracesSlash, BracesPassthrough]), sequence);
+var BracesValue = or([BracesFullValue, BracesEmptyValue]);
+var Braces = and([BracesOpen, optional2(and([BracesValue, star(and([BracesComma, BracesValue]))])), BracesClose], alternation);
+var Grammar2 = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped2, Escape, Slash, Passthrough2]), sequence);
 var grammar_default2 = Grammar2;
 
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/normalize/parser.js
-var parser2 = makeParser(grammar_default2);
-var parser_default2 = parser2;
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/parse/index.js
+var _parse = (glob) => {
+  return parse(glob, grammar_default2, { memoization: false })[0];
+};
+var parse_default = _parse;
 
-// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/index.js
-var zeptomatch = (glob, path2) => {
-  if (Array.isArray(glob)) {
-    const res = glob.map(zeptomatch.compile);
-    const isMatch = res.some((re) => re.test(path2));
-    return isMatch;
-  } else {
-    const re = zeptomatch.compile(glob);
-    const isMatch = re.test(path2);
-    return isMatch;
-  }
+// ../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/index.js
+var zeptomatch = (glob, path2, options) => {
+  return zeptomatch.compile(glob, options).test(path2);
 };
-zeptomatch.compile = memoize2((glob) => {
-  return new RegExp(`^${parser_default(parser_default2(glob))}[\\\\/]?$`, "s");
-});
-var dist_default = zeptomatch;
+zeptomatch.compile = (() => {
+  const compileGlob = memoizeByPrimitive((glob, options) => {
+    return compile_default(parse_default(normalize_default(glob)), options);
+  });
+  const compileGlobs = memoizeByObject((globs, options) => {
+    return merge_default(globs.map((glob) => compileGlob(glob, options)));
+  });
+  return (glob, options) => {
+    if (isString2(glob)) {
+      return compileGlob(glob, options);
+    } else {
+      return compileGlobs(glob, options);
+    }
+  };
+})();
+var dist_default2 = zeptomatch;
 
 // ../../dev/server/src/filesystem.ts
 var GLOBAL_DIR_ROOT_PATH = envPaths("prisma-dev");
@@ -1332,7 +1505,7 @@ async function writeBinaryFile(buffer, path2) {
   await chmod(path2, "755");
 }
 async function streamAsTextTo(file, path2) {
-  await file.stream().pipeTo(WriteStream.toWeb(createWriteStream(path2, { encoding: "utf-8" })));
+  await file.stream().pipeTo(WriteStream.toWeb(createWriteStream(path2, { encoding: "utf8" })));
 }
 function isFileNotFoundError(error) {
   return error != null && typeof error === "object" && "code" in error && error.code === "ENOENT";
@@ -1354,7 +1527,7 @@ async function readDirectoryNames(path2, globs) {
   try {
     const dirents = await readdir(path2, { withFileTypes: true });
     return dirents.reduce((names, dirent) => {
-      if (dirent.isDirectory() && !dirent.name.startsWith(".") && (!globs || dist_default(globs, dirent.name))) {
+      if (dirent.isDirectory() && !dirent.name.startsWith(".") && (!globs || dist_default2(globs, dirent.name))) {
         names.push(dirent.name);
       }
       return names;