@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.esnext

@@ -0,0 +1,168 @@
+import require$$0 from 'node:util';
+import { __require as requireBraces } from '../../../braces@3.0.3/node_modules/braces/index.esnext';
+import { __require as requirePicomatch } from '../../../picomatch@2.3.1/node_modules/picomatch/index.esnext';
+import { __require as requireUtils } from '../../../picomatch@2.3.1/node_modules/picomatch/lib/utils.esnext';
+
+var micromatch_1;
+var hasRequiredMicromatch;
+function requireMicromatch() {
+  if (hasRequiredMicromatch) return micromatch_1;
+  hasRequiredMicromatch = 1;
+  const util = require$$0;
+  const braces = requireBraces();
+  const picomatch = requirePicomatch();
+  const utils = requireUtils();
+  const isEmptyString = (v) => v === "" || v === "./";
+  const hasBraces = (v) => {
+    const index = v.indexOf("{");
+    return index > -1 && v.indexOf("}", index) > -1;
+  };
+  const micromatch = (list, patterns, options) => {
+    patterns = [].concat(patterns);
+    list = [].concat(list);
+    let omit = /* @__PURE__ */ new Set();
+    let keep = /* @__PURE__ */ new Set();
+    let items = /* @__PURE__ */ new Set();
+    let negatives = 0;
+    let onResult = (state) => {
+      items.add(state.output);
+      if (options && options.onResult) {
+        options.onResult(state);
+      }
+    };
+    for (let i = 0; i < patterns.length; i++) {
+      let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+      let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+      if (negated) negatives++;
+      for (let item of list) {
+        let matched = isMatch(item, true);
+        let match = negated ? !matched.isMatch : matched.isMatch;
+        if (!match) continue;
+        if (negated) {
+          omit.add(matched.output);
+        } else {
+          omit.delete(matched.output);
+          keep.add(matched.output);
+        }
+      }
+    }
+    let result = negatives === patterns.length ? [...items] : [...keep];
+    let matches = result.filter((item) => !omit.has(item));
+    if (options && matches.length === 0) {
+      if (options.failglob === true) {
+        throw new Error(`No matches found for "${patterns.join(", ")}"`);
+      }
+      if (options.nonull === true || options.nullglob === true) {
+        return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+      }
+    }
+    return matches;
+  };
+  micromatch.match = micromatch;
+  micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+  micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+  micromatch.any = micromatch.isMatch;
+  micromatch.not = (list, patterns, options = {}) => {
+    patterns = [].concat(patterns).map(String);
+    let result = /* @__PURE__ */ new Set();
+    let items = [];
+    let onResult = (state) => {
+      if (options.onResult) options.onResult(state);
+      items.push(state.output);
+    };
+    let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
+    for (let item of items) {
+      if (!matches.has(item)) {
+        result.add(item);
+      }
+    }
+    return [...result];
+  };
+  micromatch.contains = (str, pattern, options) => {
+    if (typeof str !== "string") {
+      throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    }
+    if (Array.isArray(pattern)) {
+      return pattern.some((p) => micromatch.contains(str, p, options));
+    }
+    if (typeof pattern === "string") {
+      if (isEmptyString(str) || isEmptyString(pattern)) {
+        return false;
+      }
+      if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
+        return true;
+      }
+    }
+    return micromatch.isMatch(str, pattern, { ...options, contains: true });
+  };
+  micromatch.matchKeys = (obj, patterns, options) => {
+    if (!utils.isObject(obj)) {
+      throw new TypeError("Expected the first argument to be an object");
+    }
+    let keys = micromatch(Object.keys(obj), patterns, options);
+    let res = {};
+    for (let key of keys) res[key] = obj[key];
+    return res;
+  };
+  micromatch.some = (list, patterns, options) => {
+    let items = [].concat(list);
+    for (let pattern of [].concat(patterns)) {
+      let isMatch = picomatch(String(pattern), options);
+      if (items.some((item) => isMatch(item))) {
+        return true;
+      }
+    }
+    return false;
+  };
+  micromatch.every = (list, patterns, options) => {
+    let items = [].concat(list);
+    for (let pattern of [].concat(patterns)) {
+      let isMatch = picomatch(String(pattern), options);
+      if (!items.every((item) => isMatch(item))) {
+        return false;
+      }
+    }
+    return true;
+  };
+  micromatch.all = (str, patterns, options) => {
+    if (typeof str !== "string") {
+      throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    }
+    return [].concat(patterns).every((p) => picomatch(p, options)(str));
+  };
+  micromatch.capture = (glob, input, options) => {
+    let posix = utils.isWindows(options);
+    let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+    let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+    if (match) {
+      return match.slice(1).map((v) => v === void 0 ? "" : v);
+    }
+  };
+  micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+  micromatch.scan = (...args) => picomatch.scan(...args);
+  micromatch.parse = (patterns, options) => {
+    let res = [];
+    for (let pattern of [].concat(patterns || [])) {
+      for (let str of braces(String(pattern), options)) {
+        res.push(picomatch.parse(str, options));
+      }
+    }
+    return res;
+  };
+  micromatch.braces = (pattern, options) => {
+    if (typeof pattern !== "string") throw new TypeError("Expected a string");
+    if (options && options.nobrace === true || !hasBraces(pattern)) {
+      return [pattern];
+    }
+    return braces(pattern, options);
+  };
+  micromatch.braceExpand = (pattern, options) => {
+    if (typeof pattern !== "string") throw new TypeError("Expected a string");
+    return micromatch.braces(pattern, { ...options, expand: true });
+  };
+  micromatch.hasBraces = hasBraces;
+  micromatch_1 = micromatch;
+  return micromatch_1;
+}
+
+export { requireMicromatch as __require };

package/build/esnext/node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.esnext

@@ -1,4 +1,11 @@
-const isWindows = typeof process === "object" && process && process.platform === "win32";
-var path = isWindows ? { sep: "\\" } : { sep: "/" };
+var path;
+var hasRequiredPath;
+function requirePath() {
+  if (hasRequiredPath) return path;
+  hasRequiredPath = 1;
+  const isWindows = typeof process === "object" && process && process.platform === "win32";
+  path = isWindows ? { sep: "\\" } : { sep: "/" };
+  return path;
+}
 
-export { path as p };
+export { requirePath as __require };