@quilted/create 0.1.89 → 0.2.0

package/build/esm/node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.mjs

@@ -7,27 +7,37 @@ const minimatch = minimatch_1 = (p, pattern, options = {}) => {
 
   // shortcut: comments match nothing.
   if (!options.nocomment && pattern.charAt(0) === '#') {
-    return false
+    return false;
   }
-
-  return new Minimatch(pattern, options).match(p)
+  return new Minimatch(pattern, options).match(p);
 };
-
 var minimatch_1 = minimatch;
-
 const path = path$1;
 minimatch.sep = path.sep;
-
 const GLOBSTAR = Symbol('globstar **');
 minimatch.GLOBSTAR = GLOBSTAR;
 const expand = braceExpansion;
-
 const plTypes = {
-  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
-  '?': { open: '(?:', close: ')?' },
-  '+': { open: '(?:', close: ')+' },
-  '*': { open: '(?:', close: ')*' },
-  '@': { open: '(?:', close: ')' }
+  '!': {
+    open: '(?:(?!(?:',
+    close: '))[^/]*?)'
+  },
+  '?': {
+    open: '(?:',
+    close: ')?'
+  },
+  '+': {
+    open: '(?:',
+    close: ')+'
+  },
+  '*': {
+    open: '(?:',
+    close: ')*'
+  },
+  '@': {
+    open: '(?:',
+    close: ')'
+  }
 };
 
 // any single thing other than /
@@ -49,7 +59,7 @@ const twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
 // "abc" -> { a:true, b:true, c:true }
 const charSet = s => s.split('').reduce((set, c) => {
   set[c] = true;
-  return set
+  return set;
 }, {});
 
 // characters that need to be escaped in RegExp.
@@ -60,27 +70,21 @@ const addPatternStartSet = charSet('[.(');
 
 // normalizes slashes.
 const slashSplit = /\/+/;
-
-minimatch.filter = (pattern, options = {}) =>
-  (p, i, list) => minimatch(p, pattern, options);
-
+minimatch.filter = (pattern, options = {}) => (p, i, list) => minimatch(p, pattern, options);
 const 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
+  return t;
 };
-
 minimatch.defaults = def => {
   if (!def || typeof def !== 'object' || !Object.keys(def).length) {
-    return minimatch
+    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) {
+    constructor(pattern, options) {
       super(pattern, ext(def, options));
     }
   };
@@ -90,14 +94,9 @@ minimatch.defaults = def => {
   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
+  return m;
 };
 
-
-
-
-
 // Brace expansion:
 // a{b,c}d -> abd acd
 // a{b,}c -> abc ac
@@ -109,7 +108,6 @@ minimatch.defaults = def => {
 // a{2..}b -> a{2..}b
 // a{b}c -> a{b}c
 minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
-
 const braceExpand = (pattern, options = {}) => {
   assertValidPattern(pattern);
 
@@ -117,20 +115,17 @@ const braceExpand = (pattern, options = {}) => {
   // improving this regexp to avoid a ReDOS vulnerability.
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     // shortcut. no need to expand.
-    return [pattern]
+    return [pattern];
   }
-
-  return expand(pattern)
+  return expand(pattern);
 };
-
 const MAX_PATTERN_LENGTH = 1024 * 64;
 const assertValidPattern = pattern => {
   if (typeof pattern !== 'string') {
-    throw new TypeError('invalid pattern')
+    throw new TypeError('invalid pattern');
   }
-
   if (pattern.length > MAX_PATTERN_LENGTH) {
-    throw new TypeError('pattern is too long')
+    throw new TypeError('pattern is too long');
   }
 };
 
@@ -146,34 +141,27 @@ const assertValidPattern = pattern => {
 // of * is equivalent to a single *.  Globstar behavior is enabled by
 // default, and can be disabled by setting options.noglobstar.
 const SUBPARSE = Symbol('subparse');
-
-minimatch.makeRe = (pattern, options) =>
-  new Minimatch(pattern, options || {}).makeRe();
-
+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
+  return list;
 };
 
 // replace stuff like \* with *
 const globUnescape = s => s.replace(/\\(.)/g, '$1');
 const regExpEscape = s => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-
 class Minimatch {
-  constructor (pattern, options) {
+  constructor(pattern, options) {
     assertValidPattern(pattern);
-
     if (!options) options = {};
-
     this.options = options;
     this.set = [];
     this.pattern = pattern;
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape ||
-      options.allowWindowsEscape === false;
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
     if (this.windowsPathsNoEscape) {
       this.pattern = this.pattern.replace(/\\/g, '/');
     }
@@ -186,21 +174,19 @@ class Minimatch {
     // make the set of regexps etc.
     this.make();
   }
-
-  debug () {}
-
-  make () {
+  debug() {}
+  make() {
     const pattern = this.pattern;
     const options = this.options;
 
     // empty patterns and comments match nothing.
     if (!options.nocomment && pattern.charAt(0) === '#') {
       this.comment = true;
-      return
+      return;
     }
     if (!pattern) {
       this.empty = true;
-      return
+      return;
     }
 
     // step 1: figure out negation, etc.
@@ -208,9 +194,7 @@ class Minimatch {
 
     // step 2: expand braces
     let set = this.globSet = this.braceExpand();
-
     if (options.debug) this.debug = (...args) => console.error(...args);
-
     this.debug(this.pattern, set);
 
     // step 3: now we have a set, so turn each one into a series of path-portion
@@ -219,34 +203,26 @@ class Minimatch {
     // set to the GLOBSTAR object for globstar behavior,
     // and will not contain any / characters
     set = this.globParts = set.map(s => s.split(slashSplit));
-
     this.debug(this.pattern, set);
 
     // glob --> regexps
     set = set.map((s, si, set) => s.map(this.parse, this));
-
     this.debug(this.pattern, set);
 
     // filter out everything that didn't compile properly.
     set = set.filter(s => s.indexOf(false) === -1);
-
     this.debug(this.pattern, set);
-
     this.set = set;
   }
-
-  parseNegate () {
-    if (this.options.nonegate) return
-
+  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.substr(negateOffset);
     this.negate = negate;
   }
@@ -256,31 +232,24 @@ class Minimatch {
   // Partial means, if you run out of file before you run
   // out of pattern, then that's fine, as long as all
   // the parts match.
-  matchOne (file, pattern, partial) {
+  matchOne(file, pattern, partial) {
     var options = this.options;
-
-    this.debug('matchOne',
-      { 'this': this, file: file, pattern: pattern });
-
+    this.debug('matchOne', {
+      'this': this,
+      file: file,
+      pattern: 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++) {
+    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);
 
       // should be impossible.
       // some invalid regexp stuff in the set.
       /* istanbul ignore if */
-      if (p === false) return false
-
+      if (p === false) return false;
       if (p === GLOBSTAR) {
         this.debug('GLOBSTAR', [pattern, p, f]);
 
@@ -317,30 +286,27 @@ class Minimatch {
           // . and .. are *never* matched by **, for explosively
           // exponential reasons.
           for (; fi < fl; fi++) {
-            if (file[fi] === '.' || file[fi] === '..' ||
-              (!options.dot && file[fi].charAt(0) === '.')) return false
+            if (file[fi] === '.' || file[fi] === '..' || !options.dot && file[fi].charAt(0) === '.') return false;
           }
-          return true
+          return true;
         }
 
         // ok, let's see if we can swallow whatever we can.
         while (fr < fl) {
           var swallowee = file[fr];
-
           this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
 
           // XXX remove this slice.  Just pass the start index.
           if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
             this.debug('globstar found match!', fr, fl, swallowee);
             // found a match.
-            return true
+            return true;
           } else {
             // can't swallow "." or ".." ever.
             // can only swallow ".foo" when explicitly asked.
-            if (swallowee === '.' || swallowee === '..' ||
-              (!options.dot && swallowee.charAt(0) === '.')) {
+            if (swallowee === '.' || swallowee === '..' || !options.dot && swallowee.charAt(0) === '.') {
               this.debug('dot detected!', file, fr, pattern, pr);
-              break
+              break;
             }
 
             // ** swallows a segment, and continue.
@@ -356,9 +322,9 @@ class Minimatch {
         if (partial) {
           // ran out of file
           this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-          if (fr === fl) return true
+          if (fr === fl) return true;
         }
-        return false
+        return false;
       }
 
       // something other than **
@@ -372,8 +338,7 @@ class Minimatch {
         hit = f.match(p);
         this.debug('pattern match', p, f, hit);
       }
-
-      if (!hit) return false
+      if (!hit) return false;
     }
 
     // Note: ending in / means that we'll get a final ""
@@ -391,43 +356,36 @@ class Minimatch {
     if (fi === fl && pi === pl) {
       // ran out of pattern and filename at the same time.
       // an exact hit!
-      return true
+      return true;
     } else if (fi === fl) {
       // ran out of file, but still had pattern left.
       // this is ok if we're doing the match as part of
       // a glob fs traversal.
-      return partial
-    } else /* istanbul ignore else */ if (pi === pl) {
-      // ran out of pattern, still have file left.
-      // this is only acceptable if we're on the very last
-      // empty segment of a file with a trailing slash.
-      // a/* should match a/b/
-      return (fi === fl - 1) && (file[fi] === '')
-    }
+      return partial;
+    } else /* istanbul ignore else */if (pi === pl) {
+        // ran out of pattern, still have file left.
+        // this is only acceptable if we're on the very last
+        // empty segment of a file with a trailing slash.
+        // a/* should match a/b/
+        return fi === fl - 1 && file[fi] === '';
+      }
 
     // should be unreachable.
     /* istanbul ignore next */
-    throw new Error('wtf?')
+    throw new Error('wtf?');
   }
-
-  braceExpand () {
-    return braceExpand(this.pattern, this.options)
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
   }
-
-  parse (pattern, isSub) {
+  parse(pattern, isSub) {
     assertValidPattern(pattern);
-
     const options = this.options;
 
     // shortcuts
     if (pattern === '**') {
-      if (!options.noglobstar)
-        return GLOBSTAR
-      else
-        pattern = '*';
+      if (!options.noglobstar) return GLOBSTAR;else pattern = '*';
     }
-    if (pattern === '') return ''
-
+    if (pattern === '') return '';
     let re = '';
     let hasMagic = !!options.nocase;
     let escaping = false;
@@ -445,9 +403,7 @@ class Minimatch {
     // even when options.dot is set.
     const patternStart = pattern.charAt(0) === '.' ? '' // anything
     // not (start or / followed by . or .. followed by / or end)
-    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
-    : '(?!\\.)';
-
+    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)';
     const clearStateChar = () => {
       if (stateChar) {
         // we had some state-tracking character
@@ -456,49 +412,46 @@ class Minimatch {
           case '*':
             re += star;
             hasMagic = true;
-          break
+            break;
           case '?':
             re += qmark;
             hasMagic = true;
-          break
+            break;
           default:
             re += '\\' + stateChar;
-          break
+            break;
         }
         this.debug('clearStateChar %j %j', stateChar, re);
         stateChar = false;
       }
     };
-
-    for (let i = 0, c; (i < pattern.length) && (c = pattern.charAt(i)); i++) {
+    for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
       this.debug('%s\t%s %s %j', pattern, i, re, c);
 
       // skip over any that are escaped.
       if (escaping) {
         /* istanbul ignore next - completely not allowed, even escaped. */
         if (c === '/') {
-          return false
+          return false;
         }
-
         if (reSpecials[c]) {
           re += '\\';
         }
         re += c;
         escaping = false;
-        continue
+        continue;
       }
-
       switch (c) {
         /* istanbul ignore next */
-        case '/': {
-          // Should already be path-split by now.
-          return false
-        }
-
+        case '/':
+          {
+            // Should already be path-split by now.
+            return false;
+          }
         case '\\':
           clearStateChar();
           escaping = true;
-        continue
+          continue;
 
         // the various stateChar values
         // for the "extglob" stuff.
@@ -515,7 +468,7 @@ class Minimatch {
             this.debug('  in class');
             if (c === '!' && i === classStart + 1) c = '^';
             re += c;
-            continue
+            continue;
           }
 
           // if we already have a stateChar, then it means
@@ -528,19 +481,16 @@ class Minimatch {
           // just clear the statechar *now*, rather than even diving into
           // the patternList stuff.
           if (options.noext) clearStateChar();
-        continue
-
+          continue;
         case '(':
           if (inClass) {
             re += '(';
-            continue
+            continue;
           }
-
           if (!stateChar) {
             re += '\\(';
-            continue
+            continue;
           }
-
           patternListStack.push({
             type: stateChar,
             start: i - 1,
@@ -552,14 +502,12 @@ class Minimatch {
           re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
           this.debug('plType %j %j', stateChar, re);
           stateChar = false;
-        continue
-
+          continue;
         case ')':
           if (inClass || !patternListStack.length) {
             re += '\\)';
-            continue
+            continue;
           }
-
           clearStateChar();
           hasMagic = true;
           pl = patternListStack.pop();
@@ -570,34 +518,29 @@ class Minimatch {
             negativeLists.push(pl);
           }
           pl.reEnd = re.length;
-        continue
-
+          continue;
         case '|':
           if (inClass || !patternListStack.length) {
             re += '\\|';
-            continue
+            continue;
           }
-
           clearStateChar();
           re += '|';
-        continue
+          continue;
 
         // these are mostly the same in regexp and glob
         case '[':
           // swallow any state-tracking char before the [
           clearStateChar();
-
           if (inClass) {
             re += '\\' + c;
-            continue
+            continue;
           }
-
           inClass = true;
           classStart = i;
           reClassStart = re.length;
           re += c;
-        continue
-
+          continue;
         case ']':
           //  a right bracket shall lose its special
           //  meaning and represent itself in
@@ -605,7 +548,7 @@ class Minimatch {
           //  first in the list.  -- POSIX.2 2.8.3.2
           if (i === classStart + 1 || !inClass) {
             re += '\\' + c;
-            continue
+            continue;
           }
 
           // handle the case where we left a class open.
@@ -626,26 +569,22 @@ class Minimatch {
             re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
             hasMagic = hasMagic || sp[1];
             inClass = false;
-            continue
+            continue;
           }
 
           // finish up the class.
           hasMagic = true;
           inClass = false;
           re += c;
-        continue
-
+          continue;
         default:
           // swallow any state char that wasn't consumed
           clearStateChar();
-
           if (reSpecials[c] && !(c === '^' && inClass)) {
             re += '\\';
           }
-
           re += c;
-          break
-
+          break;
       } // switch
     } // for
 
@@ -686,14 +625,10 @@ class Minimatch {
         // it exactly after itself.  That's why this trick works.
         //
         // I am sorry that you have to see this.
-        return $1 + $1 + $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;
-
+      const t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type;
       hasMagic = true;
       re = re.slice(0, pl.reStart) + t + '\\(' + tail;
     }
@@ -716,7 +651,6 @@ class Minimatch {
     // the pattern.
     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);
@@ -731,7 +665,6 @@ class Minimatch {
         cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
       }
       nlAfter = cleanAfter;
-
       const dollar = nlAfter === '' && isSub !== SUBPARSE ? '$' : '';
       re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
     }
@@ -742,40 +675,37 @@ class Minimatch {
     if (re !== '' && hasMagic) {
       re = '(?=.)' + re;
     }
-
     if (addPatternStart) {
       re = patternStart + re;
     }
 
     // parsing just a piece of a larger pattern.
     if (isSub === SUBPARSE) {
-      return [re, hasMagic]
+      return [re, hasMagic];
     }
 
     // skip the regexp for non-magical patterns
     // unescape anything in it, though, so that it'll be
     // an exact match against a file etc.
     if (!hasMagic) {
-      return globUnescape(pattern)
+      return globUnescape(pattern);
     }
-
     const flags = options.nocase ? 'i' : '';
     try {
       return Object.assign(new RegExp('^' + re + '$', flags), {
         _glob: pattern,
-        _src: re,
-      })
-    } catch (er) /* istanbul ignore next - should be impossible */ {
+        _src: re
+      });
+    } catch (er) /* istanbul ignore next - should be impossible */{
       // If it was an invalid regular expression, then it can't match
       // anything.  This trick looks for a character after the end of
       // the string, which is of course impossible, except in multi-line
       // mode, but it's not a /m regex.
-      return new RegExp('$.')
+      return new RegExp('$.');
     }
   }
-
-  makeRe () {
-    if (this.regexp || this.regexp === false) return this.regexp
+  makeRe() {
+    if (this.regexp || this.regexp === false) return this.regexp;
 
     // at this point, this.set is a 2d array of partial
     // pattern strings, or "**".
@@ -784,16 +714,12 @@ class Minimatch {
     // be used, really, but it's pretty convenient sometimes,
     // when you just want to work with a regex.
     const set = this.set;
-
     if (!set.length) {
       this.regexp = false;
-      return this.regexp
+      return this.regexp;
     }
     const options = this.options;
-
-    const twoStar = options.noglobstar ? star
-      : options.dot ? twoStarDot
-      : twoStarNoDot;
+    const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
     const flags = options.nocase ? 'i' : '';
 
     // coalesce globstars and regexpify non-globstar patterns
@@ -803,34 +729,30 @@ class Minimatch {
     // if it's in the middle, append (\/|\/twoStar\/) to previous
     // then filter out GLOBSTAR symbols
     let re = set.map(pattern => {
-      pattern = pattern.map(p =>
-        typeof p === 'string' ? regExpEscape(p)
-        : p === GLOBSTAR ? GLOBSTAR
-        : p._src
-      ).reduce((set, p) => {
+      pattern = pattern.map(p => typeof p === 'string' ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src).reduce((set, p) => {
         if (!(set[set.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
           set.push(p);
         }
-        return set
+        return set;
       }, []);
       pattern.forEach((p, i) => {
-        if (p !== GLOBSTAR || pattern[i-1] === GLOBSTAR) {
-          return
+        if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
+          return;
         }
         if (i === 0) {
           if (pattern.length > 1) {
-            pattern[i+1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i+1];
+            pattern[i + 1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i + 1];
           } else {
             pattern[i] = twoStar;
           }
         } else if (i === pattern.length - 1) {
-          pattern[i-1] += '(?:\\\/|' + twoStar + ')?';
+          pattern[i - 1] += '(?:\\\/|' + twoStar + ')?';
         } else {
-          pattern[i-1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i+1];
-          pattern[i+1] = GLOBSTAR;
+          pattern[i - 1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i + 1];
+          pattern[i + 1] = GLOBSTAR;
         }
       });
-      return pattern.filter(p => p !== GLOBSTAR).join('/')
+      return pattern.filter(p => p !== GLOBSTAR).join('/');
     }).join('|');
 
     // must match entire pattern
@@ -839,24 +761,20 @@ class Minimatch {
 
     // can match anything, as long as it's not this.
     if (this.negate) re = '^(?!' + re + ').*$';
-
     try {
       this.regexp = new RegExp(re, flags);
-    } catch (ex) /* istanbul ignore next - should be impossible */ {
+    } catch (ex) /* istanbul ignore next - should be impossible */{
       this.regexp = false;
     }
-    return this.regexp
+    return this.regexp;
   }
-
-  match (f, partial = this.partial) {
+  match(f, partial = this.partial) {
     this.debug('match', f, this.pattern);
     // short-circuit in the case of busted things.
     // comments, etc.
-    if (this.comment) return false
-    if (this.empty) return f === ''
-
-    if (f === '/' && partial) return true
-
+    if (this.comment) return false;
+    if (this.empty) return f === '';
+    if (f === '/' && partial) return true;
     const options = this.options;
 
     // windows: need to use /, not \
@@ -880,9 +798,8 @@ class Minimatch {
     let filename;
     for (let i = f.length - 1; i >= 0; i--) {
       filename = f[i];
-      if (filename) break
+      if (filename) break;
     }
-
     for (let i = 0; i < set.length; i++) {
       const pattern = set[i];
       let file = f;
@@ -891,24 +808,21 @@ class Minimatch {
       }
       const hit = this.matchOne(file, pattern, partial);
       if (hit) {
-        if (options.flipNegate) return true
-        return !this.negate
+        if (options.flipNegate) return true;
+        return !this.negate;
       }
     }
 
     // didn't get any hits.  this is success if it's a negative
     // pattern, failure otherwise.
-    if (options.flipNegate) return false
-    return this.negate
+    if (options.flipNegate) return false;
+    return this.negate;
   }
-
-  static defaults (def) {
-    return minimatch.defaults(def).Minimatch
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
   }
 }
-
 minimatch.Minimatch = Minimatch;
-
 var minimatch$1 = /*@__PURE__*/getDefaultExportFromCjs(minimatch_1);
 
 var minimatch$2 = /*#__PURE__*/Object.freeze({