@quilted/create 0.2.43 → 0.2.44

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

@@ -1,157 +1,163 @@
 import require$$0 from 'node:util';
-import { b as braces_1 } from '../../../braces@3.0.2/node_modules/braces/index.esnext';
-import { p as picomatch$1 } from '../../../picomatch@2.3.1/node_modules/picomatch/index.esnext';
-import '../../../picomatch@2.3.1/node_modules/picomatch/lib/utils.esnext';
-import { __exports as utils$1 } from '../../../../../_virtual/utils.esnext';
+import { __require as requireBraces } from '../../../braces@3.0.2/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';
 
-const util = require$$0;
-const braces = braces_1;
-const picomatch = picomatch$1;
-const utils = utils$1;
-const isEmptyString = (val) => val === "" || val === "./";
-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);
+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 = (val) => val === "" || val === "./";
+  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;
   };
-  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);
+  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);
       }
     }
-  }
-  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(", ")}"`);
+    return [...result];
+  };
+  micromatch.contains = (str, pattern, options) => {
+    if (typeof str !== "string") {
+      throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
     }
-    if (options.nonull === true || options.nullglob === true) {
-      return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+    if (Array.isArray(pattern)) {
+      return pattern.some((p) => micromatch.contains(str, p, options));
     }
-  }
-  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);
+    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 });
   };
-  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
-  for (let item of items) {
-    if (!matches.has(item)) {
-      result.add(item);
+  micromatch.matchKeys = (obj, patterns, options) => {
+    if (!utils.isObject(obj)) {
+      throw new TypeError("Expected the first argument to be an object");
     }
-  }
-  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;
+    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;
+      }
     }
-    if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
-      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 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 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);
     }
-  }
-  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;
+  };
+  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 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 || !/\{.*\}/.test(pattern)) {
+      return [pattern];
     }
-  }
-  return res;
-};
-micromatch.braces = (pattern, options) => {
-  if (typeof pattern !== "string") throw new TypeError("Expected a string");
-  if (options && options.nobrace === true || !/\{.*\}/.test(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 });
-};
-var micromatch_1 = micromatch;
+    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_1 = micromatch;
+  return micromatch_1;
+}
 
-export { micromatch_1 as m };
+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 };