@shopify/cli-hydrogen 1.1.0 → 2.0.1

package/dist/{Command-da8a6365.js → Command-4e1093c6.js}

@@ -6,7 +6,7 @@ import require$$0$6 from 'assert';
 import require$$0$8, { join, dirname, basename, parse as parse$b, resolve as resolve$2 } from 'path';
 import require$$0$9 from 'os';
 import require$$0$a from 'events';
-import { path as path$t, output as output$1 } from '@shopify/cli-kit';
+import { path as path$t, output } from '@shopify/cli-kit';
 import require$$0$2 from 'tty';
 import require$$1$1 from 'readline';
 import require$$0$b from 'buffer';
@@ -21,7 +21,7 @@ import 'prettier';
 import { Command as Command$1 } from '@oclif/core';
 
 var name = "@shopify/cli-hydrogen";
-var version$1 = "1.1.0";
+var version$1 = "2.0.1";
 var description$1 = "Commands for building Hydrogen storefronts";
 var type$2 = "module";
 var files = [
@@ -54,23 +54,18 @@ var eslintConfig = {
 };
 var dependencies$1 = {
 	"@oclif/core": "1.3.6",
-	"@miniflare/cache": "^2.2.0",
-	"@miniflare/core": "^2.2.0",
-	"@miniflare/runner-vm": "^2.2.0",
-	"@miniflare/shared": "^2.2.0",
-	"@miniflare/storage-memory": "^2.2.0",
-	"@miniflare/web-sockets": "^2.2.0",
+	"@shopify/mini-oxygen": "^0.0.5",
 	"@types/prettier": "^2.4.4",
 	prettier: "^2.6.1",
 	vite: "^2.9.1"
 };
 var peerDependencies = {
-	"@shopify/cli-kit": "1.0.9"
+	"@shopify/cli-kit": "2.0.1"
 };
 var devDependencies = {
-	"@shopify/cli-testing": "0.30.2",
 	"@babel/core": "^7.17.8",
 	"@shopify/ast-utilities": "^1.3.4",
+	"@shopify/cli-testing": "0.30.2",
 	"@shopify/prettier-config": "^1.1.2",
 	"@types/change-case": "^2.3.1",
 	"@types/connect": "^3.4.35",
@@ -104,10 +99,10 @@ var devDependencies = {
 	typescript: "^4.2.3",
 	unconfig: "^0.3.2",
 	vite: "^2.9.1",
-	vitest: "0.9.2"
+	vitest: "0.9.4"
 };
 var engines = {
-	node: "^14.13.1 || ^16.0.0 || ^17.0.0"
+	node: "^14.13.1 || ^16.0.0 || ^17.0.0 || ^18.0.0"
 };
 var os$2 = [
 	"darwin",
@@ -155,7 +150,7 @@ const SEMVER_SPEC_VERSION = '2.0.0';
 
 const MAX_LENGTH$4 = 256;
 const MAX_SAFE_INTEGER$3 = Number.MAX_SAFE_INTEGER ||
-  /* istanbul ignore next */ 9007199254740991;
+/* istanbul ignore next */ 9007199254740991;
 
 // Max safe segment length for coercion.
 const MAX_SAFE_COMPONENT_LENGTH = 16;
@@ -164,7 +159,7 @@ var constants$6 = {
   SEMVER_SPEC_VERSION,
   MAX_LENGTH: MAX_LENGTH$4,
   MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$3,
-  MAX_SAFE_COMPONENT_LENGTH
+  MAX_SAFE_COMPONENT_LENGTH,
 };
 
 const debug$5 = (
@@ -190,7 +185,7 @@ let R = 0;
 
 const createToken = (name, value, isGlobal) => {
   const index = R++;
-  debug(index, value);
+  debug(name, index, value);
   t[name] = index;
   src[index] = value;
   re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
@@ -358,8 +353,8 @@ createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
 // Star ranges basically just allow anything at all.
 createToken('STAR', '(<|>)?=?\\s*\\*');
 // >=0.0.0 is like a star
-createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
-createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
 }(re$5, re$5.exports));
 
 // parse out just the options we care about so we always get a consistent
@@ -368,9 +363,9 @@ const opts = ['includePrerelease', 'loose', 'rtl'];
 const parseOptions$4 = options =>
   !options ? {}
   : typeof options !== 'object' ? { loose: true }
-  : opts.filter(k => options[k]).reduce((options, k) => {
-    options[k] = true;
-    return options
+  : opts.filter(k => options[k]).reduce((o, k) => {
+    o[k] = true;
+    return o
   }, {});
 var parseOptions_1 = parseOptions$4;
 
@@ -395,7 +390,7 @@ const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
 
 var identifiers = {
   compareIdentifiers: compareIdentifiers$1,
-  rcompareIdentifiers
+  rcompareIdentifiers,
 };
 
 const debug$4 = debug_1;
@@ -665,7 +660,7 @@ class SemVer$e {
         if (identifier) {
           // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
           // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-          if (this.prerelease[0] === identifier) {
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
             if (isNaN(this.prerelease[1])) {
               this.prerelease = [identifier, 0];
             }
@@ -686,7 +681,7 @@ class SemVer$e {
 
 var semver$1 = SemVer$e;
 
-const {MAX_LENGTH: MAX_LENGTH$2} = constants$6;
+const { MAX_LENGTH: MAX_LENGTH$2 } = constants$6;
 const { re: re$3, t: t$3 } = re$5.exports;
 const SemVer$d = semver$1;
 
@@ -743,7 +738,10 @@ const inc = (version, release, options, identifier) => {
   }
 
   try {
-    return new SemVer$c(version, options).inc(release, identifier).version
+    return new SemVer$c(
+      version instanceof SemVer$c ? version.version : version,
+      options
+    ).inc(release, identifier).version
   } catch (er) {
     return null
   }
@@ -857,17 +855,21 @@ const lte$1 = lte_1;
 const cmp$1 = (a, op, b, loose) => {
   switch (op) {
     case '===':
-      if (typeof a === 'object')
+      if (typeof a === 'object') {
         a = a.version;
-      if (typeof b === 'object')
+      }
+      if (typeof b === 'object') {
         b = b.version;
+      }
       return a === b
 
     case '!==':
-      if (typeof a === 'object')
+      if (typeof a === 'object') {
         a = a.version;
-      if (typeof b === 'object')
+      }
+      if (typeof b === 'object') {
         b = b.version;
+      }
       return a !== b
 
     case '':
@@ -898,7 +900,7 @@ var cmp_1 = cmp$1;
 
 const SemVer$6 = semver$1;
 const parse$5 = parse_1$2;
-const {re: re$2, t: t$2} = re$5.exports;
+const { re: re$2, t: t$2 } = re$5.exports;
 
 const coerce = (version, options) => {
   if (version instanceof SemVer$6) {
@@ -941,8 +943,9 @@ const coerce = (version, options) => {
     re$2[t$2.COERCERTL].lastIndex = -1;
   }
 
-  if (match === null)
+  if (match === null) {
     return null
+  }
 
   return parse$5(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
 };
@@ -1738,9 +1741,9 @@ class Range$a {
     // First, split based on boolean or ||
     this.raw = range;
     this.set = range
-      .split(/\s*\|\|\s*/)
+      .split('||')
       // map the range to a 2d array of comparators
-      .map(range => this.parseRange(range.trim()))
+      .map(r => this.parseRange(r.trim()))
       // throw out any comparator lists that are empty
       // this generally means that it was not a valid range, which is allowed
       // in loose mode, but will still throw if the WHOLE range is invalid.
@@ -1755,9 +1758,9 @@ class Range$a {
       // keep the first one, in case they're all null sets
       const first = this.set[0];
       this.set = this.set.filter(c => !isNullSet(c[0]));
-      if (this.set.length === 0)
+      if (this.set.length === 0) {
         this.set = [first];
-      else if (this.set.length > 1) {
+      } else if (this.set.length > 1) {
         // if we have any that are *, then the range is just *
         for (const c of this.set) {
           if (c.length === 1 && isAny(c[0])) {
@@ -1793,8 +1796,9 @@ class Range$a {
     const memoOpts = Object.keys(this.options).join(',');
     const memoKey = `parseRange:${memoOpts}:${range}`;
     const cached = cache.get(memoKey);
-    if (cached)
+    if (cached) {
       return cached
+    }
 
     const loose = this.options.loose;
     // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
@@ -1803,7 +1807,7 @@ class Range$a {
     debug$3('hyphen replace', range);
     // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
     range = range.replace(re$1[t$1.COMPARATORTRIM], comparatorTrimReplace);
-    debug$3('comparator trim', range, re$1[t$1.COMPARATORTRIM]);
+    debug$3('comparator trim', range);
 
     // `~ 1.2.3` => `~1.2.3`
     range = range.replace(re$1[t$1.TILDETRIM], tildeTrimReplace);
@@ -1817,30 +1821,37 @@ class Range$a {
     // At this point, the range is completely trimmed and
     // ready to be split into comparators.
 
-    const compRe = loose ? re$1[t$1.COMPARATORLOOSE] : re$1[t$1.COMPARATOR];
-    const rangeList = range
+    let rangeList = range
       .split(' ')
       .map(comp => parseComparator(comp, this.options))
       .join(' ')
       .split(/\s+/)
       // >=0.0.0 is equivalent to *
-      .map(comp => replaceGTE0(comp, this.options))
+      .map(comp => replaceGTE0(comp, this.options));
+
+    if (loose) {
       // in loose mode, throw out any that are not valid comparators
-      .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
-      .map(comp => new Comparator$3(comp, this.options));
+      rangeList = rangeList.filter(comp => {
+        debug$3('loose invalid filter', comp, this.options);
+        return !!comp.match(re$1[t$1.COMPARATORLOOSE])
+      });
+    }
+    debug$3('range list', rangeList);
 
     // if any comparators are the null set, then replace with JUST null set
     // if more than one comparator, remove any * comparators
     // also, don't include the same comparator more than once
-    rangeList.length;
     const rangeMap = new Map();
-    for (const comp of rangeList) {
-      if (isNullSet(comp))
+    const comparators = rangeList.map(comp => new Comparator$3(comp, this.options));
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
         return [comp]
+      }
       rangeMap.set(comp.value, comp);
     }
-    if (rangeMap.size > 1 && rangeMap.has(''))
+    if (rangeMap.size > 1 && rangeMap.has('')) {
       rangeMap.delete('');
+    }
 
     const result = [...rangeMap.values()];
     cache.set(memoKey, result);
@@ -1905,7 +1916,7 @@ const {
   t: t$1,
   comparatorTrimReplace,
   tildeTrimReplace,
-  caretTrimReplace
+  caretTrimReplace,
 } = re$5.exports;
 
 const isNullSet = c => c.value === '<0.0.0-0';
@@ -1954,8 +1965,8 @@ const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
 // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
 // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
 const replaceTildes = (comp, options) =>
-  comp.trim().split(/\s+/).map((comp) => {
-    return replaceTilde(comp, options)
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceTilde(c, options)
   }).join(' ');
 
 const replaceTilde = (comp, options) => {
@@ -1993,8 +2004,8 @@ const replaceTilde = (comp, options) => {
 // ^1.2.3 --> >=1.2.3 <2.0.0-0
 // ^1.2.0 --> >=1.2.0 <2.0.0-0
 const replaceCarets = (comp, options) =>
-  comp.trim().split(/\s+/).map((comp) => {
-    return replaceCaret(comp, options)
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceCaret(c, options)
   }).join(' ');
 
 const replaceCaret = (comp, options) => {
@@ -2052,8 +2063,8 @@ const replaceCaret = (comp, options) => {
 
 const replaceXRanges = (comp, options) => {
   debug$3('replaceXRanges', comp, options);
-  return comp.split(/\s+/).map((comp) => {
-    return replaceXRange(comp, options)
+  return comp.split(/\s+/).map((c) => {
+    return replaceXRange(c, options)
   }).join(' ')
 };
 
@@ -2114,8 +2125,9 @@ const replaceXRange = (comp, options) => {
         }
       }
 
-      if (gtlt === '<')
+      if (gtlt === '<') {
         pr = '-0';
+      }
 
       ret = `${gtlt + M}.${m}.${p}${pr}`;
     } else if (xm) {
@@ -2224,6 +2236,7 @@ class Comparator$2 {
   static get ANY () {
     return ANY$2
   }
+
   constructor (comp, options) {
     options = parseOptions(options);
 
@@ -2300,7 +2313,7 @@ class Comparator$2 {
     if (!options || typeof options !== 'object') {
       options = {
         loose: !!options,
-        includePrerelease: false
+        includePrerelease: false,
       };
     }
 
@@ -2348,7 +2361,7 @@ class Comparator$2 {
 var comparator = Comparator$2;
 
 const parseOptions = parseOptions_1;
-const {re, t} = re$5.exports;
+const { re, t } = re$5.exports;
 const cmp = cmp_1;
 const debug$2 = debug_1;
 const SemVer$4 = semver$1;
@@ -2474,8 +2487,9 @@ const minVersion = (range, loose) => {
           throw new Error(`Unexpected operation: ${comparator.operator}`)
       }
     });
-    if (setMin && (!minver || gt$1(minver, setMin)))
+    if (setMin && (!minver || gt$1(minver, setMin))) {
       minver = setMin;
+    }
   }
 
   if (minver && range.test(minver)) {
@@ -2500,7 +2514,7 @@ var valid = validRange;
 
 const SemVer = semver$1;
 const Comparator$1 = comparator;
-const {ANY: ANY$1} = Comparator$1;
+const { ANY: ANY$1 } = Comparator$1;
 const Range$2 = range$2;
 const satisfies$2 = satisfies_1;
 const gt = gt_1;
@@ -2604,38 +2618,41 @@ const satisfies$1 = satisfies_1;
 const compare$2 = compare_1;
 var simplify = (versions, range, options) => {
   const set = [];
-  let min = null;
+  let first = null;
   let prev = null;
   const v = versions.sort((a, b) => compare$2(a, b, options));
   for (const version of v) {
     const included = satisfies$1(version, range, options);
     if (included) {
       prev = version;
-      if (!min)
-        min = version;
+      if (!first) {
+        first = version;
+      }
     } else {
       if (prev) {
-        set.push([min, prev]);
+        set.push([first, prev]);
       }
       prev = null;
-      min = null;
+      first = null;
     }
   }
-  if (min)
-    set.push([min, null]);
+  if (first) {
+    set.push([first, null]);
+  }
 
   const ranges = [];
   for (const [min, max] of set) {
-    if (min === max)
+    if (min === max) {
       ranges.push(min);
-    else if (!max && min === v[0])
+    } else if (!max && min === v[0]) {
       ranges.push('*');
-    else if (!max)
+    } else if (!max) {
       ranges.push(`>=${min}`);
-    else if (min === v[0])
+    } else if (min === v[0]) {
       ranges.push(`<=${max}`);
-    else
+    } else {
       ranges.push(`${min} - ${max}`);
+    }
   }
   const simplified = ranges.join(' || ');
   const original = typeof range.raw === 'string' ? range.raw : String(range);
@@ -2685,8 +2702,9 @@ const compare$1 = compare_1;
 // - Else return true
 
 const subset = (sub, dom, options = {}) => {
-  if (sub === dom)
+  if (sub === dom) {
     return true
+  }
 
   sub = new Range(sub, options);
   dom = new Range(dom, options);
@@ -2696,73 +2714,84 @@ const subset = (sub, dom, options = {}) => {
     for (const simpleDom of dom.set) {
       const isSub = simpleSubset(simpleSub, simpleDom, options);
       sawNonNull = sawNonNull || isSub !== null;
-      if (isSub)
+      if (isSub) {
         continue OUTER
+      }
     }
     // the null set is a subset of everything, but null simple ranges in
     // a complex range should be ignored.  so if we saw a non-null range,
     // then we know this isn't a subset, but if EVERY simple range was null,
     // then it is a subset.
-    if (sawNonNull)
+    if (sawNonNull) {
       return false
+    }
   }
   return true
 };
 
 const simpleSubset = (sub, dom, options) => {
-  if (sub === dom)
+  if (sub === dom) {
     return true
+  }
 
   if (sub.length === 1 && sub[0].semver === ANY) {
-    if (dom.length === 1 && dom[0].semver === ANY)
+    if (dom.length === 1 && dom[0].semver === ANY) {
       return true
-    else if (options.includePrerelease)
-      sub = [ new Comparator('>=0.0.0-0') ];
-    else
-      sub = [ new Comparator('>=0.0.0') ];
+    } else if (options.includePrerelease) {
+      sub = [new Comparator('>=0.0.0-0')];
+    } else {
+      sub = [new Comparator('>=0.0.0')];
+    }
   }
 
   if (dom.length === 1 && dom[0].semver === ANY) {
-    if (options.includePrerelease)
+    if (options.includePrerelease) {
       return true
-    else
-      dom = [ new Comparator('>=0.0.0') ];
+    } else {
+      dom = [new Comparator('>=0.0.0')];
+    }
   }
 
   const eqSet = new Set();
   let gt, lt;
   for (const c of sub) {
-    if (c.operator === '>' || c.operator === '>=')
+    if (c.operator === '>' || c.operator === '>=') {
       gt = higherGT(gt, c, options);
-    else if (c.operator === '<' || c.operator === '<=')
+    } else if (c.operator === '<' || c.operator === '<=') {
       lt = lowerLT(lt, c, options);
-    else
+    } else {
       eqSet.add(c.semver);
+    }
   }
 
-  if (eqSet.size > 1)
+  if (eqSet.size > 1) {
     return null
+  }
 
   let gtltComp;
   if (gt && lt) {
     gtltComp = compare$1(gt.semver, lt.semver, options);
-    if (gtltComp > 0)
+    if (gtltComp > 0) {
       return null
-    else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
       return null
+    }
   }
 
   // will iterate one or zero times
   for (const eq of eqSet) {
-    if (gt && !satisfies(eq, String(gt), options))
+    if (gt && !satisfies(eq, String(gt), options)) {
       return null
+    }
 
-    if (lt && !satisfies(eq, String(lt), options))
+    if (lt && !satisfies(eq, String(lt), options)) {
       return null
+    }
 
     for (const c of dom) {
-      if (!satisfies(eq, String(c), options))
+      if (!satisfies(eq, String(c), options)) {
         return false
+      }
     }
 
     return true
@@ -2798,10 +2827,12 @@ const simpleSubset = (sub, dom, options) => {
       }
       if (c.operator === '>' || c.operator === '>=') {
         higher = higherGT(gt, c, options);
-        if (higher === c && higher !== gt)
+        if (higher === c && higher !== gt) {
           return false
-      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
         return false
+      }
     }
     if (lt) {
       if (needDomLTPre) {
@@ -2814,37 +2845,44 @@ const simpleSubset = (sub, dom, options) => {
       }
       if (c.operator === '<' || c.operator === '<=') {
         lower = lowerLT(lt, c, options);
-        if (lower === c && lower !== lt)
+        if (lower === c && lower !== lt) {
           return false
-      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
         return false
+      }
     }
-    if (!c.operator && (lt || gt) && gtltComp !== 0)
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
       return false
+    }
   }
 
   // if there was a < or >, and nothing in the dom, then must be false
   // UNLESS it was limited by another range in the other direction.
   // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
-  if (gt && hasDomLT && !lt && gtltComp !== 0)
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
     return false
+  }
 
-  if (lt && hasDomGT && !gt && gtltComp !== 0)
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
     return false
+  }
 
   // we needed a prerelease range in a specific tuple, but didn't get one
   // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
   // because it includes prereleases in the 1.2.3 tuple
-  if (needDomGTPre || needDomLTPre)
+  if (needDomGTPre || needDomLTPre) {
     return false
+  }
 
   return true
 };
 
 // >=1.2.3 is lower than >1.2.3
 const higherGT = (a, b, options) => {
-  if (!a)
+  if (!a) {
     return b
+  }
   const comp = compare$1(a.semver, b.semver, options);
   return comp > 0 ? a
     : comp < 0 ? b
@@ -2854,8 +2892,9 @@ const higherGT = (a, b, options) => {
 
 // <=1.2.3 is higher than <1.2.3
 const lowerLT = (a, b, options) => {
-  if (!a)
+  if (!a) {
     return b
+  }
   const comp = compare$1(a.semver, b.semver, options);
   return comp < 0 ? a
     : comp > 0 ? b
@@ -4060,13 +4099,13 @@ function patch$1 (fs) {
   fs.lstatSync = statFixSync(fs.lstatSync);
 
   // if lchmod/lchown do not exist, then make them no-ops
-  if (!fs.lchmod) {
+  if (fs.chmod && !fs.lchmod) {
     fs.lchmod = function (path, mode, cb) {
       if (cb) process.nextTick(cb);
     };
     fs.lchmodSync = function () {};
   }
-  if (!fs.lchown) {
+  if (fs.chown && !fs.lchown) {
     fs.lchown = function (path, uid, gid, cb) {
       if (cb) process.nextTick(cb);
     };
@@ -4083,32 +4122,38 @@ function patch$1 (fs) {
   // CPU to a busy looping process, which can cause the program causing the lock
   // contention to be starved of CPU by node, so the contention doesn't resolve.
   if (platform$1 === "win32") {
-    fs.rename = (function (fs$rename) { return function (from, to, cb) {
-      var start = Date.now();
-      var backoff = 0;
-      fs$rename(from, to, function CB (er) {
-        if (er
-            && (er.code === "EACCES" || er.code === "EPERM")
-            && Date.now() - start < 60000) {
-          setTimeout(function() {
-            fs.stat(to, function (stater, st) {
-              if (stater && stater.code === "ENOENT")
-                fs$rename(from, to, CB);
-              else
-                cb(er);
-            });
-          }, backoff);
-          if (backoff < 100)
-            backoff += 10;
-          return;
-        }
-        if (cb) cb(er);
-      });
-    }})(fs.rename);
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now();
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er);
+              });
+            }, backoff);
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er);
+        });
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+      return rename
+    })(fs.rename);
   }
 
   // if read() returns EAGAIN, then just try it again.
-  fs.read = (function (fs$read) {
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
     function read (fd, buffer, offset, length, position, callback_) {
       var callback;
       if (callback_ && typeof callback_ === 'function') {
@@ -4129,7 +4174,8 @@ function patch$1 (fs) {
     return read
   })(fs.read);
 
-  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
     var eagCounter = 0;
     while (true) {
       try {
@@ -4188,7 +4234,7 @@ function patch$1 (fs) {
   }
 
   function patchLutimes (fs) {
-    if (constants$5.hasOwnProperty("O_SYMLINK")) {
+    if (constants$5.hasOwnProperty("O_SYMLINK") && fs.futimes) {
       fs.lutimes = function (path, at, mt, cb) {
         fs.open(path, constants$5.O_SYMLINK, function (er, fd) {
           if (er) {
@@ -4222,7 +4268,7 @@ function patch$1 (fs) {
         return ret
       };
 
-    } else {
+    } else if (fs.futimes) {
       fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
       fs.lutimesSync = function () {};
     }
@@ -4670,16 +4716,35 @@ function patch (fs) {
 
   var fs$readdir = fs.readdir;
   fs.readdir = readdir;
+  var noReaddirOptionVersions = /^v[0-5]\./;
   function readdir (path, options, cb) {
     if (typeof options === 'function')
       cb = options, options = null;
 
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      };
+
     return go$readdir(path, options, cb)
 
-    function go$readdir (path, options, cb, startTime) {
-      return fs$readdir(path, options, function (err, files) {
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()]);
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ]);
         else {
           if (files && files.sort)
             files.sort();
@@ -4687,7 +4752,7 @@ function patch (fs) {
           if (typeof cb === 'function')
             cb.call(this, err, files);
         }
-      })
+      }
     }
   }
 
@@ -4963,7 +5028,6 @@ Object.assign(exports, fs);
 api.forEach(method => {
   exports[method] = u(fs[method]);
 });
-exports.realpath.native = u(fs.realpath.native);
 
 // We differ from mz/fs in that we still ship the old, broken, fs.exists()
 // since we are a drop-in replacement for the native module
@@ -5026,6 +5090,16 @@ if (typeof fs.writev === 'function') {
     })
   };
 }
+
+// fs.realpath.native sometimes not available if fs is monkey-patched
+if (typeof fs.realpath.native === 'function') {
+  exports.realpath.native = u(fs.realpath.native);
+} else {
+  process.emitWarning(
+    'fs.realpath.native is not a function. Is fs being monkey-patched?',
+    'Warning', 'fs-extra-WARN0003'
+  );
+}
 }(fs$v));
 
 var makeDir$1 = {};
@@ -5089,14 +5163,26 @@ var mkdirs$2 = {
   ensureDirSync: makeDirSync
 };
 
-const fs$s = gracefulFs;
+const u$9 = universalify$1.fromPromise;
+const fs$s = fs$v;
+
+function pathExists$8 (path) {
+  return fs$s.access(path).then(() => true).catch(() => false)
+}
+
+var pathExists_1 = {
+  pathExists: u$9(pathExists$8),
+  pathExistsSync: fs$s.existsSync
+};
+
+const fs$r = gracefulFs;
 
 function utimesMillis$1 (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  fs$s.open(path, 'r+', (err, fd) => {
+  fs$r.open(path, 'r+', (err, fd) => {
     if (err) return callback(err)
-    fs$s.futimes(fd, atime, mtime, futimesErr => {
-      fs$s.close(fd, closeErr => {
+    fs$r.futimes(fd, atime, mtime, futimesErr => {
+      fs$r.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
       });
     });
@@ -5104,9 +5190,9 @@ function utimesMillis$1 (path, atime, mtime, callback) {
 }
 
 function utimesMillisSync$1 (path, atime, mtime) {
-  const fd = fs$s.openSync(path, 'r+');
-  fs$s.futimesSync(fd, atime, mtime);
-  return fs$s.closeSync(fd)
+  const fd = fs$r.openSync(path, 'r+');
+  fs$r.futimesSync(fd, atime, mtime);
+  return fs$r.closeSync(fd)
 }
 
 var utimes = {
@@ -5114,14 +5200,14 @@ var utimes = {
   utimesMillisSync: utimesMillisSync$1
 };
 
-const fs$r = fs$v;
+const fs$q = fs$v;
 const path$r = require$$0$8;
 const util$6 = require$$0$3;
 
 function getStats$2 (src, dest, opts) {
   const statFunc = opts.dereference
-    ? (file) => fs$r.stat(file, { bigint: true })
-    : (file) => fs$r.lstat(file, { bigint: true });
+    ? (file) => fs$q.stat(file, { bigint: true })
+    : (file) => fs$q.lstat(file, { bigint: true });
   return Promise.all([
     statFunc(src),
     statFunc(dest).catch(err => {
@@ -5134,8 +5220,8 @@ function getStats$2 (src, dest, opts) {
 function getStatsSync (src, dest, opts) {
   let destStat;
   const statFunc = opts.dereference
-    ? (file) => fs$r.statSync(file, { bigint: true })
-    : (file) => fs$r.lstatSync(file, { bigint: true });
+    ? (file) => fs$q.statSync(file, { bigint: true })
+    : (file) => fs$q.lstatSync(file, { bigint: true });
   const srcStat = statFunc(src);
   try {
     destStat = statFunc(dest);
@@ -5213,7 +5299,7 @@ function checkParentPaths (src, srcStat, dest, funcName, cb) {
   const srcParent = path$r.resolve(path$r.dirname(src));
   const destParent = path$r.resolve(path$r.dirname(dest));
   if (destParent === srcParent || destParent === path$r.parse(destParent).root) return cb()
-  fs$r.stat(destParent, { bigint: true }, (err, destStat) => {
+  fs$q.stat(destParent, { bigint: true }, (err, destStat) => {
     if (err) {
       if (err.code === 'ENOENT') return cb()
       return cb(err)
@@ -5231,7 +5317,7 @@ function checkParentPathsSync (src, srcStat, dest, funcName) {
   if (destParent === srcParent || destParent === path$r.parse(destParent).root) return
   let destStat;
   try {
-    destStat = fs$r.statSync(destParent, { bigint: true });
+    destStat = fs$q.statSync(destParent, { bigint: true });
   } catch (err) {
     if (err.code === 'ENOENT') return
     throw err
@@ -5267,193 +5353,12 @@ var stat$5 = {
   areIdentical: areIdentical$2
 };
 
-const fs$q = gracefulFs;
+const fs$p = gracefulFs;
 const path$q = require$$0$8;
-const mkdirsSync$1 = mkdirs$2.mkdirsSync;
-const utimesMillisSync = utimes.utimesMillisSync;
-const stat$4 = stat$5;
-
-function copySync$2 (src, dest, opts) {
-  if (typeof opts === 'function') {
-    opts = { filter: opts };
-  }
-
-  opts = opts || {};
-  opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
-  opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
-
-  // Warn about using preserveTimestamps on 32-bit node
-  if (opts.preserveTimestamps && process.arch === 'ia32') {
-    console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
-    see https://github.com/jprichardson/node-fs-extra/issues/269`);
-  }
-
-  const { srcStat, destStat } = stat$4.checkPathsSync(src, dest, 'copy', opts);
-  stat$4.checkParentPathsSync(src, srcStat, dest, 'copy');
-  return handleFilterAndCopy(destStat, src, dest, opts)
-}
-
-function handleFilterAndCopy (destStat, src, dest, opts) {
-  if (opts.filter && !opts.filter(src, dest)) return
-  const destParent = path$q.dirname(dest);
-  if (!fs$q.existsSync(destParent)) mkdirsSync$1(destParent);
-  return getStats$1(destStat, src, dest, opts)
-}
-
-function startCopy$1 (destStat, src, dest, opts) {
-  if (opts.filter && !opts.filter(src, dest)) return
-  return getStats$1(destStat, src, dest, opts)
-}
-
-function getStats$1 (destStat, src, dest, opts) {
-  const statSync = opts.dereference ? fs$q.statSync : fs$q.lstatSync;
-  const srcStat = statSync(src);
-
-  if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts)
-  else if (srcStat.isFile() ||
-           srcStat.isCharacterDevice() ||
-           srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts)
-  else if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts)
-  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
-  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
-  throw new Error(`Unknown file: ${src}`)
-}
-
-function onFile$1 (srcStat, destStat, src, dest, opts) {
-  if (!destStat) return copyFile$1(srcStat, src, dest, opts)
-  return mayCopyFile$1(srcStat, src, dest, opts)
-}
-
-function mayCopyFile$1 (srcStat, src, dest, opts) {
-  if (opts.overwrite) {
-    fs$q.unlinkSync(dest);
-    return copyFile$1(srcStat, src, dest, opts)
-  } else if (opts.errorOnExist) {
-    throw new Error(`'${dest}' already exists`)
-  }
-}
-
-function copyFile$1 (srcStat, src, dest, opts) {
-  fs$q.copyFileSync(src, dest);
-  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
-  return setDestMode$1(dest, srcStat.mode)
-}
-
-function handleTimestamps (srcMode, src, dest) {
-  // Make sure the file is writable before setting the timestamp
-  // otherwise open fails with EPERM when invoked with 'r+'
-  // (through utimes call)
-  if (fileIsNotWritable$1(srcMode)) makeFileWritable$1(dest, srcMode);
-  return setDestTimestamps$1(src, dest)
-}
-
-function fileIsNotWritable$1 (srcMode) {
-  return (srcMode & 0o200) === 0
-}
-
-function makeFileWritable$1 (dest, srcMode) {
-  return setDestMode$1(dest, srcMode | 0o200)
-}
-
-function setDestMode$1 (dest, srcMode) {
-  return fs$q.chmodSync(dest, srcMode)
-}
-
-function setDestTimestamps$1 (src, dest) {
-  // The initial srcStat.atime cannot be trusted
-  // because it is modified by the read(2) system call
-  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  const updatedSrcStat = fs$q.statSync(src);
-  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
-}
-
-function onDir$1 (srcStat, destStat, src, dest, opts) {
-  if (!destStat) return mkDirAndCopy$1(srcStat.mode, src, dest, opts)
-  return copyDir$1(src, dest, opts)
-}
-
-function mkDirAndCopy$1 (srcMode, src, dest, opts) {
-  fs$q.mkdirSync(dest);
-  copyDir$1(src, dest, opts);
-  return setDestMode$1(dest, srcMode)
-}
-
-function copyDir$1 (src, dest, opts) {
-  fs$q.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
-}
-
-function copyDirItem$1 (item, src, dest, opts) {
-  const srcItem = path$q.join(src, item);
-  const destItem = path$q.join(dest, item);
-  const { destStat } = stat$4.checkPathsSync(srcItem, destItem, 'copy', opts);
-  return startCopy$1(destStat, srcItem, destItem, opts)
-}
-
-function onLink$1 (destStat, src, dest, opts) {
-  let resolvedSrc = fs$q.readlinkSync(src);
-  if (opts.dereference) {
-    resolvedSrc = path$q.resolve(process.cwd(), resolvedSrc);
-  }
-
-  if (!destStat) {
-    return fs$q.symlinkSync(resolvedSrc, dest)
-  } else {
-    let resolvedDest;
-    try {
-      resolvedDest = fs$q.readlinkSync(dest);
-    } catch (err) {
-      // dest exists and is a regular file or directory,
-      // Windows may throw UNKNOWN error. If dest already exists,
-      // fs throws error anyway, so no need to guard against it here.
-      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$q.symlinkSync(resolvedSrc, dest)
-      throw err
-    }
-    if (opts.dereference) {
-      resolvedDest = path$q.resolve(process.cwd(), resolvedDest);
-    }
-    if (stat$4.isSrcSubdir(resolvedSrc, resolvedDest)) {
-      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
-    }
-
-    // prevent copy if src is a subdir of dest since unlinking
-    // dest in this case would result in removing src contents
-    // and therefore a broken symlink would be created.
-    if (fs$q.statSync(dest).isDirectory() && stat$4.isSrcSubdir(resolvedDest, resolvedSrc)) {
-      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
-    }
-    return copyLink$1(resolvedSrc, dest)
-  }
-}
-
-function copyLink$1 (resolvedSrc, dest) {
-  fs$q.unlinkSync(dest);
-  return fs$q.symlinkSync(resolvedSrc, dest)
-}
-
-var copySync_1 = copySync$2;
-
-var copySync$1 = {
-  copySync: copySync_1
-};
-
-const u$9 = universalify$1.fromPromise;
-const fs$p = fs$v;
-
-function pathExists$8 (path) {
-  return fs$p.access(path).then(() => true).catch(() => false)
-}
-
-var pathExists_1 = {
-  pathExists: u$9(pathExists$8),
-  pathExistsSync: fs$p.existsSync
-};
-
-const fs$o = gracefulFs;
-const path$p = require$$0$8;
 const mkdirs$1 = mkdirs$2.mkdirs;
 const pathExists$7 = pathExists_1.pathExists;
 const utimesMillis = utimes.utimesMillis;
-const stat$3 = stat$5;
+const stat$4 = stat$5;
 
 function copy$2 (src, dest, opts, cb) {
   if (typeof opts === 'function' && !cb) {
@@ -5471,14 +5376,17 @@ function copy$2 (src, dest, opts, cb) {
 
   // Warn about using preserveTimestamps on 32-bit node
   if (opts.preserveTimestamps && process.arch === 'ia32') {
-    console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
-    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+    process.emitWarning(
+      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+      'Warning', 'fs-extra-WARN0001'
+    );
   }
 
-  stat$3.checkPaths(src, dest, 'copy', opts, (err, stats) => {
+  stat$4.checkPaths(src, dest, 'copy', opts, (err, stats) => {
     if (err) return cb(err)
     const { srcStat, destStat } = stats;
-    stat$3.checkParentPaths(src, srcStat, dest, 'copy', err => {
+    stat$4.checkParentPaths(src, srcStat, dest, 'copy', err => {
       if (err) return cb(err)
       if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
       return checkParentDir(destStat, src, dest, opts, cb)
@@ -5487,13 +5395,13 @@ function copy$2 (src, dest, opts, cb) {
 }
 
 function checkParentDir (destStat, src, dest, opts, cb) {
-  const destParent = path$p.dirname(dest);
+  const destParent = path$q.dirname(dest);
   pathExists$7(destParent, (err, dirExists) => {
     if (err) return cb(err)
-    if (dirExists) return getStats(destStat, src, dest, opts, cb)
+    if (dirExists) return getStats$1(destStat, src, dest, opts, cb)
     mkdirs$1(destParent, err => {
       if (err) return cb(err)
-      return getStats(destStat, src, dest, opts, cb)
+      return getStats$1(destStat, src, dest, opts, cb)
     });
   });
 }
@@ -5505,48 +5413,48 @@ function handleFilter (onInclude, destStat, src, dest, opts, cb) {
   }, error => cb(error));
 }
 
-function startCopy (destStat, src, dest, opts, cb) {
-  if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)
-  return getStats(destStat, src, dest, opts, cb)
+function startCopy$1 (destStat, src, dest, opts, cb) {
+  if (opts.filter) return handleFilter(getStats$1, destStat, src, dest, opts, cb)
+  return getStats$1(destStat, src, dest, opts, cb)
 }
 
-function getStats (destStat, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$o.stat : fs$o.lstat;
+function getStats$1 (destStat, src, dest, opts, cb) {
+  const stat = opts.dereference ? fs$p.stat : fs$p.lstat;
   stat(src, (err, srcStat) => {
     if (err) return cb(err)
 
-    if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)
+    if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts, cb)
     else if (srcStat.isFile() ||
              srcStat.isCharacterDevice() ||
-             srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)
-    else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)
+             srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts, cb)
+    else if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts, cb)
     else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))
     else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))
     return cb(new Error(`Unknown file: ${src}`))
   });
 }
 
-function onFile (srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return copyFile(srcStat, src, dest, opts, cb)
-  return mayCopyFile(srcStat, src, dest, opts, cb)
+function onFile$1 (srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return copyFile$1(srcStat, src, dest, opts, cb)
+  return mayCopyFile$1(srcStat, src, dest, opts, cb)
 }
 
-function mayCopyFile (srcStat, src, dest, opts, cb) {
+function mayCopyFile$1 (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
-    fs$o.unlink(dest, err => {
+    fs$p.unlink(dest, err => {
       if (err) return cb(err)
-      return copyFile(srcStat, src, dest, opts, cb)
+      return copyFile$1(srcStat, src, dest, opts, cb)
     });
   } else if (opts.errorOnExist) {
     return cb(new Error(`'${dest}' already exists`))
   } else return cb()
 }
 
-function copyFile (srcStat, src, dest, opts, cb) {
-  fs$o.copyFile(src, dest, err => {
+function copyFile$1 (srcStat, src, dest, opts, cb) {
+  fs$p.copyFile(src, dest, err => {
     if (err) return cb(err)
     if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
-    return setDestMode(dest, srcStat.mode, cb)
+    return setDestMode$1(dest, srcStat.mode, cb)
   });
 }
 
@@ -5554,8 +5462,8 @@ function handleTimestampsAndMode (srcMode, src, dest, cb) {
   // Make sure the file is writable before setting the timestamp
   // otherwise open fails with EPERM when invoked with 'r+'
   // (through utimes call)
-  if (fileIsNotWritable(srcMode)) {
-    return makeFileWritable(dest, srcMode, err => {
+  if (fileIsNotWritable$1(srcMode)) {
+    return makeFileWritable$1(dest, srcMode, err => {
       if (err) return cb(err)
       return setDestTimestampsAndMode(srcMode, src, dest, cb)
     })
@@ -5563,52 +5471,52 @@ function handleTimestampsAndMode (srcMode, src, dest, cb) {
   return setDestTimestampsAndMode(srcMode, src, dest, cb)
 }
 
-function fileIsNotWritable (srcMode) {
+function fileIsNotWritable$1 (srcMode) {
   return (srcMode & 0o200) === 0
 }
 
-function makeFileWritable (dest, srcMode, cb) {
-  return setDestMode(dest, srcMode | 0o200, cb)
+function makeFileWritable$1 (dest, srcMode, cb) {
+  return setDestMode$1(dest, srcMode | 0o200, cb)
 }
 
 function setDestTimestampsAndMode (srcMode, src, dest, cb) {
-  setDestTimestamps(src, dest, err => {
+  setDestTimestamps$1(src, dest, err => {
     if (err) return cb(err)
-    return setDestMode(dest, srcMode, cb)
+    return setDestMode$1(dest, srcMode, cb)
   });
 }
 
-function setDestMode (dest, srcMode, cb) {
-  return fs$o.chmod(dest, srcMode, cb)
+function setDestMode$1 (dest, srcMode, cb) {
+  return fs$p.chmod(dest, srcMode, cb)
 }
 
-function setDestTimestamps (src, dest, cb) {
+function setDestTimestamps$1 (src, dest, cb) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  fs$o.stat(src, (err, updatedSrcStat) => {
+  fs$p.stat(src, (err, updatedSrcStat) => {
     if (err) return cb(err)
     return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
   });
 }
 
-function onDir (srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)
-  return copyDir(src, dest, opts, cb)
+function onDir$1 (srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return mkDirAndCopy$1(srcStat.mode, src, dest, opts, cb)
+  return copyDir$1(src, dest, opts, cb)
 }
 
-function mkDirAndCopy (srcMode, src, dest, opts, cb) {
-  fs$o.mkdir(dest, err => {
+function mkDirAndCopy$1 (srcMode, src, dest, opts, cb) {
+  fs$p.mkdir(dest, err => {
     if (err) return cb(err)
-    copyDir(src, dest, opts, err => {
+    copyDir$1(src, dest, opts, err => {
       if (err) return cb(err)
-      return setDestMode(dest, srcMode, cb)
+      return setDestMode$1(dest, srcMode, cb)
     });
   });
 }
 
-function copyDir (src, dest, opts, cb) {
-  fs$o.readdir(src, (err, items) => {
+function copyDir$1 (src, dest, opts, cb) {
+  fs$p.readdir(src, (err, items) => {
     if (err) return cb(err)
     return copyDirItems(items, src, dest, opts, cb)
   });
@@ -5617,71 +5525,240 @@ function copyDir (src, dest, opts, cb) {
 function copyDirItems (items, src, dest, opts, cb) {
   const item = items.pop();
   if (!item) return cb()
-  return copyDirItem(items, item, src, dest, opts, cb)
+  return copyDirItem$1(items, item, src, dest, opts, cb)
 }
 
-function copyDirItem (items, item, src, dest, opts, cb) {
-  const srcItem = path$p.join(src, item);
-  const destItem = path$p.join(dest, item);
-  stat$3.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
+function copyDirItem$1 (items, item, src, dest, opts, cb) {
+  const srcItem = path$q.join(src, item);
+  const destItem = path$q.join(dest, item);
+  stat$4.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
     if (err) return cb(err)
     const { destStat } = stats;
-    startCopy(destStat, srcItem, destItem, opts, err => {
+    startCopy$1(destStat, srcItem, destItem, opts, err => {
       if (err) return cb(err)
       return copyDirItems(items, src, dest, opts, cb)
     });
   });
 }
 
-function onLink (destStat, src, dest, opts, cb) {
-  fs$o.readlink(src, (err, resolvedSrc) => {
+function onLink$1 (destStat, src, dest, opts, cb) {
+  fs$p.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
     if (opts.dereference) {
-      resolvedSrc = path$p.resolve(process.cwd(), resolvedSrc);
+      resolvedSrc = path$q.resolve(process.cwd(), resolvedSrc);
     }
 
     if (!destStat) {
-      return fs$o.symlink(resolvedSrc, dest, cb)
+      return fs$p.symlink(resolvedSrc, dest, cb)
     } else {
-      fs$o.readlink(dest, (err, resolvedDest) => {
+      fs$p.readlink(dest, (err, resolvedDest) => {
         if (err) {
           // dest exists and is a regular file or directory,
           // Windows may throw UNKNOWN error. If dest already exists,
           // fs throws error anyway, so no need to guard against it here.
-          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$o.symlink(resolvedSrc, dest, cb)
+          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$p.symlink(resolvedSrc, dest, cb)
           return cb(err)
         }
         if (opts.dereference) {
-          resolvedDest = path$p.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path$q.resolve(process.cwd(), resolvedDest);
         }
-        if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        if (stat$4.isSrcSubdir(resolvedSrc, resolvedDest)) {
           return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
         }
 
         // do not copy if src is a subdir of dest since unlinking
         // dest in this case would result in removing src contents
         // and therefore a broken symlink would be created.
-        if (destStat.isDirectory() && stat$3.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (destStat.isDirectory() && stat$4.isSrcSubdir(resolvedDest, resolvedSrc)) {
           return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
         }
-        return copyLink(resolvedSrc, dest, cb)
+        return copyLink$1(resolvedSrc, dest, cb)
       });
     }
   });
 }
 
-function copyLink (resolvedSrc, dest, cb) {
-  fs$o.unlink(dest, err => {
+function copyLink$1 (resolvedSrc, dest, cb) {
+  fs$p.unlink(dest, err => {
     if (err) return cb(err)
-    return fs$o.symlink(resolvedSrc, dest, cb)
+    return fs$p.symlink(resolvedSrc, dest, cb)
   });
 }
 
 var copy_1 = copy$2;
 
+const fs$o = gracefulFs;
+const path$p = require$$0$8;
+const mkdirsSync$1 = mkdirs$2.mkdirsSync;
+const utimesMillisSync = utimes.utimesMillisSync;
+const stat$3 = stat$5;
+
+function copySync$1 (src, dest, opts) {
+  if (typeof opts === 'function') {
+    opts = { filter: opts };
+  }
+
+  opts = opts || {};
+  opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
+  opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
+
+  // Warn about using preserveTimestamps on 32-bit node
+  if (opts.preserveTimestamps && process.arch === 'ia32') {
+    process.emitWarning(
+      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
+      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
+      'Warning', 'fs-extra-WARN0002'
+    );
+  }
+
+  const { srcStat, destStat } = stat$3.checkPathsSync(src, dest, 'copy', opts);
+  stat$3.checkParentPathsSync(src, srcStat, dest, 'copy');
+  return handleFilterAndCopy(destStat, src, dest, opts)
+}
+
+function handleFilterAndCopy (destStat, src, dest, opts) {
+  if (opts.filter && !opts.filter(src, dest)) return
+  const destParent = path$p.dirname(dest);
+  if (!fs$o.existsSync(destParent)) mkdirsSync$1(destParent);
+  return getStats(destStat, src, dest, opts)
+}
+
+function startCopy (destStat, src, dest, opts) {
+  if (opts.filter && !opts.filter(src, dest)) return
+  return getStats(destStat, src, dest, opts)
+}
+
+function getStats (destStat, src, dest, opts) {
+  const statSync = opts.dereference ? fs$o.statSync : fs$o.lstatSync;
+  const srcStat = statSync(src);
+
+  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
+  else if (srcStat.isFile() ||
+           srcStat.isCharacterDevice() ||
+           srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
+  else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
+  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
+  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
+  throw new Error(`Unknown file: ${src}`)
+}
+
+function onFile (srcStat, destStat, src, dest, opts) {
+  if (!destStat) return copyFile(srcStat, src, dest, opts)
+  return mayCopyFile(srcStat, src, dest, opts)
+}
+
+function mayCopyFile (srcStat, src, dest, opts) {
+  if (opts.overwrite) {
+    fs$o.unlinkSync(dest);
+    return copyFile(srcStat, src, dest, opts)
+  } else if (opts.errorOnExist) {
+    throw new Error(`'${dest}' already exists`)
+  }
+}
+
+function copyFile (srcStat, src, dest, opts) {
+  fs$o.copyFileSync(src, dest);
+  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+  return setDestMode(dest, srcStat.mode)
+}
+
+function handleTimestamps (srcMode, src, dest) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+  return setDestTimestamps(src, dest)
+}
+
+function fileIsNotWritable (srcMode) {
+  return (srcMode & 0o200) === 0
+}
+
+function makeFileWritable (dest, srcMode) {
+  return setDestMode(dest, srcMode | 0o200)
+}
+
+function setDestMode (dest, srcMode) {
+  return fs$o.chmodSync(dest, srcMode)
+}
+
+function setDestTimestamps (src, dest) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  const updatedSrcStat = fs$o.statSync(src);
+  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
+}
+
+function onDir (srcStat, destStat, src, dest, opts) {
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
+  return copyDir(src, dest, opts)
+}
+
+function mkDirAndCopy (srcMode, src, dest, opts) {
+  fs$o.mkdirSync(dest);
+  copyDir(src, dest, opts);
+  return setDestMode(dest, srcMode)
+}
+
+function copyDir (src, dest, opts) {
+  fs$o.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts));
+}
+
+function copyDirItem (item, src, dest, opts) {
+  const srcItem = path$p.join(src, item);
+  const destItem = path$p.join(dest, item);
+  const { destStat } = stat$3.checkPathsSync(srcItem, destItem, 'copy', opts);
+  return startCopy(destStat, srcItem, destItem, opts)
+}
+
+function onLink (destStat, src, dest, opts) {
+  let resolvedSrc = fs$o.readlinkSync(src);
+  if (opts.dereference) {
+    resolvedSrc = path$p.resolve(process.cwd(), resolvedSrc);
+  }
+
+  if (!destStat) {
+    return fs$o.symlinkSync(resolvedSrc, dest)
+  } else {
+    let resolvedDest;
+    try {
+      resolvedDest = fs$o.readlinkSync(dest);
+    } catch (err) {
+      // dest exists and is a regular file or directory,
+      // Windows may throw UNKNOWN error. If dest already exists,
+      // fs throws error anyway, so no need to guard against it here.
+      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$o.symlinkSync(resolvedSrc, dest)
+      throw err
+    }
+    if (opts.dereference) {
+      resolvedDest = path$p.resolve(process.cwd(), resolvedDest);
+    }
+    if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
+      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
+    }
+
+    // prevent copy if src is a subdir of dest since unlinking
+    // dest in this case would result in removing src contents
+    // and therefore a broken symlink would be created.
+    if (fs$o.statSync(dest).isDirectory() && stat$3.isSrcSubdir(resolvedDest, resolvedSrc)) {
+      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
+    }
+    return copyLink(resolvedSrc, dest)
+  }
+}
+
+function copyLink (resolvedSrc, dest) {
+  fs$o.unlinkSync(dest);
+  return fs$o.symlinkSync(resolvedSrc, dest)
+}
+
+var copySync_1 = copySync$1;
+
 const u$8 = universalify$1.fromCallback;
 var copy$1 = {
-  copy: u$8(copy_1)
+  copy: u$8(copy_1),
+  copySync: copySync_1
 };
 
 const fs$n = gracefulFs;
@@ -6049,7 +6126,7 @@ const path$m = require$$0$8;
 const fs$k = gracefulFs;
 const mkdir$2 = mkdirs$2;
 
-function createFile (file, callback) {
+function createFile$1 (file, callback) {
   function makeFile () {
     fs$k.writeFile(file, '', err => {
       if (err) return callback(err)
@@ -6084,7 +6161,7 @@ function createFile (file, callback) {
   });
 }
 
-function createFileSync (file) {
+function createFileSync$1 (file) {
   let stats;
   try {
     stats = fs$k.statSync(file);
@@ -6107,9 +6184,9 @@ function createFileSync (file) {
   fs$k.writeFileSync(file, '');
 }
 
-var file$2 = {
-  createFile: u$5(createFile),
-  createFileSync
+var file$1 = {
+  createFile: u$5(createFile$1),
+  createFileSync: createFileSync$1
 };
 
 const u$4 = universalify$1.fromCallback;
@@ -6119,7 +6196,7 @@ const mkdir$1 = mkdirs$2;
 const pathExists$6 = pathExists_1.pathExists;
 const { areIdentical: areIdentical$1 } = stat$5;
 
-function createLink (srcpath, dstpath, callback) {
+function createLink$1 (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
     fs$j.link(srcpath, dstpath, err => {
       if (err) return callback(err)
@@ -6148,7 +6225,7 @@ function createLink (srcpath, dstpath, callback) {
   });
 }
 
-function createLinkSync (srcpath, dstpath) {
+function createLinkSync$1 (srcpath, dstpath) {
   let dstStat;
   try {
     dstStat = fs$j.lstatSync(dstpath);
@@ -6170,9 +6247,9 @@ function createLinkSync (srcpath, dstpath) {
   return fs$j.linkSync(srcpath, dstpath)
 }
 
-var link$2 = {
-  createLink: u$4(createLink),
-  createLinkSync
+var link$1 = {
+  createLink: u$4(createLink$1),
+  createLinkSync: createLinkSync$1
 };
 
 const path$k = require$$0$8;
@@ -6322,7 +6399,7 @@ const pathExists$4 = pathExists_1.pathExists;
 
 const { areIdentical } = stat$5;
 
-function createSymlink (srcpath, dstpath, type, callback) {
+function createSymlink$1 (srcpath, dstpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback;
   type = (typeof type === 'function') ? false : type;
 
@@ -6358,7 +6435,7 @@ function _createSymlink (srcpath, dstpath, type, callback) {
   });
 }
 
-function createSymlinkSync (srcpath, dstpath, type) {
+function createSymlinkSync$1 (srcpath, dstpath, type) {
   let stats;
   try {
     stats = fs$g.lstatSync(dstpath);
@@ -6379,31 +6456,31 @@ function createSymlinkSync (srcpath, dstpath, type) {
   return fs$g.symlinkSync(srcpath, dstpath, type)
 }
 
-var symlink$1 = {
-  createSymlink: u$3(createSymlink),
-  createSymlinkSync
+var symlink = {
+  createSymlink: u$3(createSymlink$1),
+  createSymlinkSync: createSymlinkSync$1
 };
 
-const file$1 = file$2;
-const link$1 = link$2;
-const symlink = symlink$1;
+const { createFile, createFileSync } = file$1;
+const { createLink, createLinkSync } = link$1;
+const { createSymlink, createSymlinkSync } = symlink;
 
 var ensure = {
   // file
-  createFile: file$1.createFile,
-  createFileSync: file$1.createFileSync,
-  ensureFile: file$1.createFile,
-  ensureFileSync: file$1.createFileSync,
+  createFile,
+  createFileSync,
+  ensureFile: createFile,
+  ensureFileSync: createFileSync,
   // link
-  createLink: link$1.createLink,
-  createLinkSync: link$1.createLinkSync,
-  ensureLink: link$1.createLink,
-  ensureLinkSync: link$1.createLinkSync,
+  createLink,
+  createLinkSync,
+  ensureLink: createLink,
+  ensureLinkSync: createLinkSync,
   // symlink
-  createSymlink: symlink.createSymlink,
-  createSymlinkSync: symlink.createSymlinkSync,
-  ensureSymlink: symlink.createSymlink,
-  ensureSymlinkSync: symlink.createSymlinkSync
+  createSymlink,
+  createSymlinkSync,
+  ensureSymlink: createSymlink,
+  ensureSymlinkSync: createSymlinkSync
 };
 
 function stringify$8 (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
@@ -6554,13 +6631,13 @@ function outputFileSync$1 (file, ...args) {
   fs$f.writeFileSync(file, ...args);
 }
 
-var output = {
+var outputFile_1 = {
   outputFile: u$2(outputFile$1),
   outputFileSync: outputFileSync$1
 };
 
 const { stringify: stringify$6 } = utils$n;
-const { outputFile } = output;
+const { outputFile } = outputFile_1;
 
 async function outputJson (file, data, options = {}) {
   const str = stringify$6(data, options);
@@ -6571,7 +6648,7 @@ async function outputJson (file, data, options = {}) {
 var outputJson_1 = outputJson;
 
 const { stringify: stringify$5 } = utils$n;
-const { outputFileSync } = output;
+const { outputFileSync } = outputFile_1;
 
 function outputJsonSync (file, data, options) {
   const str = stringify$5(data, options);
@@ -6598,68 +6675,11 @@ var json = jsonFile;
 
 const fs$e = gracefulFs;
 const path$h = require$$0$8;
-const copySync = copySync$1.copySync;
-const removeSync = remove_1.removeSync;
-const mkdirpSync = mkdirs$2.mkdirpSync;
-const stat$2 = stat$5;
-
-function moveSync$1 (src, dest, opts) {
-  opts = opts || {};
-  const overwrite = opts.overwrite || opts.clobber || false;
-
-  const { srcStat, isChangingCase = false } = stat$2.checkPathsSync(src, dest, 'move', opts);
-  stat$2.checkParentPathsSync(src, srcStat, dest, 'move');
-  if (!isParentRoot$1(dest)) mkdirpSync(path$h.dirname(dest));
-  return doRename$1(src, dest, overwrite, isChangingCase)
-}
-
-function isParentRoot$1 (dest) {
-  const parent = path$h.dirname(dest);
-  const parsedPath = path$h.parse(parent);
-  return parsedPath.root === parent
-}
-
-function doRename$1 (src, dest, overwrite, isChangingCase) {
-  if (isChangingCase) return rename$1(src, dest, overwrite)
-  if (overwrite) {
-    removeSync(dest);
-    return rename$1(src, dest, overwrite)
-  }
-  if (fs$e.existsSync(dest)) throw new Error('dest already exists.')
-  return rename$1(src, dest, overwrite)
-}
-
-function rename$1 (src, dest, overwrite) {
-  try {
-    fs$e.renameSync(src, dest);
-  } catch (err) {
-    if (err.code !== 'EXDEV') throw err
-    return moveAcrossDevice$1(src, dest, overwrite)
-  }
-}
-
-function moveAcrossDevice$1 (src, dest, overwrite) {
-  const opts = {
-    overwrite,
-    errorOnExist: true
-  };
-  copySync(src, dest, opts);
-  return removeSync(src)
-}
-
-var moveSync_1 = moveSync$1;
-
-var moveSync = {
-  moveSync: moveSync_1
-};
-
-const fs$d = gracefulFs;
-const path$g = require$$0$8;
 const copy = copy$1.copy;
 const remove = remove_1.remove;
 const mkdirp = mkdirs$2.mkdirp;
 const pathExists$2 = pathExists_1.pathExists;
-const stat$1 = stat$5;
+const stat$2 = stat$5;
 
 function move$1 (src, dest, opts, cb) {
   if (typeof opts === 'function') {
@@ -6667,52 +6687,54 @@ function move$1 (src, dest, opts, cb) {
     opts = {};
   }
 
+  opts = opts || {};
+
   const overwrite = opts.overwrite || opts.clobber || false;
 
-  stat$1.checkPaths(src, dest, 'move', opts, (err, stats) => {
+  stat$2.checkPaths(src, dest, 'move', opts, (err, stats) => {
     if (err) return cb(err)
     const { srcStat, isChangingCase = false } = stats;
-    stat$1.checkParentPaths(src, srcStat, dest, 'move', err => {
+    stat$2.checkParentPaths(src, srcStat, dest, 'move', err => {
       if (err) return cb(err)
-      if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)
-      mkdirp(path$g.dirname(dest), err => {
+      if (isParentRoot$1(dest)) return doRename$1(src, dest, overwrite, isChangingCase, cb)
+      mkdirp(path$h.dirname(dest), err => {
         if (err) return cb(err)
-        return doRename(src, dest, overwrite, isChangingCase, cb)
+        return doRename$1(src, dest, overwrite, isChangingCase, cb)
       });
     });
   });
 }
 
-function isParentRoot (dest) {
-  const parent = path$g.dirname(dest);
-  const parsedPath = path$g.parse(parent);
+function isParentRoot$1 (dest) {
+  const parent = path$h.dirname(dest);
+  const parsedPath = path$h.parse(parent);
   return parsedPath.root === parent
 }
 
-function doRename (src, dest, overwrite, isChangingCase, cb) {
-  if (isChangingCase) return rename(src, dest, overwrite, cb)
+function doRename$1 (src, dest, overwrite, isChangingCase, cb) {
+  if (isChangingCase) return rename$1(src, dest, overwrite, cb)
   if (overwrite) {
     return remove(dest, err => {
       if (err) return cb(err)
-      return rename(src, dest, overwrite, cb)
+      return rename$1(src, dest, overwrite, cb)
     })
   }
   pathExists$2(dest, (err, destExists) => {
     if (err) return cb(err)
     if (destExists) return cb(new Error('dest already exists.'))
-    return rename(src, dest, overwrite, cb)
+    return rename$1(src, dest, overwrite, cb)
   });
 }
 
-function rename (src, dest, overwrite, cb) {
-  fs$d.rename(src, dest, err => {
+function rename$1 (src, dest, overwrite, cb) {
+  fs$e.rename(src, dest, err => {
     if (!err) return cb()
     if (err.code !== 'EXDEV') return cb(err)
-    return moveAcrossDevice(src, dest, overwrite, cb)
+    return moveAcrossDevice$1(src, dest, overwrite, cb)
   });
 }
 
-function moveAcrossDevice (src, dest, overwrite, cb) {
+function moveAcrossDevice$1 (src, dest, overwrite, cb) {
   const opts = {
     overwrite,
     errorOnExist: true
@@ -6725,24 +6747,76 @@ function moveAcrossDevice (src, dest, overwrite, cb) {
 
 var move_1 = move$1;
 
+const fs$d = gracefulFs;
+const path$g = require$$0$8;
+const copySync = copy$1.copySync;
+const removeSync = remove_1.removeSync;
+const mkdirpSync = mkdirs$2.mkdirpSync;
+const stat$1 = stat$5;
+
+function moveSync (src, dest, opts) {
+  opts = opts || {};
+  const overwrite = opts.overwrite || opts.clobber || false;
+
+  const { srcStat, isChangingCase = false } = stat$1.checkPathsSync(src, dest, 'move', opts);
+  stat$1.checkParentPathsSync(src, srcStat, dest, 'move');
+  if (!isParentRoot(dest)) mkdirpSync(path$g.dirname(dest));
+  return doRename(src, dest, overwrite, isChangingCase)
+}
+
+function isParentRoot (dest) {
+  const parent = path$g.dirname(dest);
+  const parsedPath = path$g.parse(parent);
+  return parsedPath.root === parent
+}
+
+function doRename (src, dest, overwrite, isChangingCase) {
+  if (isChangingCase) return rename(src, dest, overwrite)
+  if (overwrite) {
+    removeSync(dest);
+    return rename(src, dest, overwrite)
+  }
+  if (fs$d.existsSync(dest)) throw new Error('dest already exists.')
+  return rename(src, dest, overwrite)
+}
+
+function rename (src, dest, overwrite) {
+  try {
+    fs$d.renameSync(src, dest);
+  } catch (err) {
+    if (err.code !== 'EXDEV') throw err
+    return moveAcrossDevice(src, dest, overwrite)
+  }
+}
+
+function moveAcrossDevice (src, dest, overwrite) {
+  const opts = {
+    overwrite,
+    errorOnExist: true
+  };
+  copySync(src, dest, opts);
+  return removeSync(src)
+}
+
+var moveSync_1 = moveSync;
+
 const u = universalify$1.fromCallback;
 var move = {
-  move: u(move_1)
+  move: u(move_1),
+  moveSync: moveSync_1
 };
 
 var lib$2 = {
   // Export promiseified graceful-fs:
   ...fs$v,
   // Export extra methods:
-  ...copySync$1,
   ...copy$1,
   ...empty$2,
   ...ensure,
   ...json,
   ...mkdirs$2,
-  ...moveSync,
   ...move,
-  ...output,
+  ...outputFile_1,
   ...pathExists_1,
   ...remove_1
 };
@@ -10699,10 +10773,10 @@ micromatch$1.not = (list, patterns, options = {}) => {
     items.push(state.output);
   };
 
-  let matches = micromatch$1(list, patterns, { ...options, onResult });
+  let matches = new Set(micromatch$1(list, patterns, { ...options, onResult }));
 
   for (let item of items) {
-    if (!matches.includes(item)) {
+    if (!matches.has(item)) {
       result.add(item);
     }
   }
@@ -10952,7 +11026,7 @@ micromatch$1.scan = (...args) => picomatch.scan(...args);
  *
  * ```js
  * const mm = require('micromatch');
- * const state = mm(pattern[, options]);
+ * const state = mm.parse(pattern[, options]);
  * ```
  * @param {String} `glob`
  * @param {Object} `options`
@@ -52045,16 +52119,16 @@ class Interface {
       message.forEach((msg) => {
         const [label, ...values] = msg;
         const spacer = [INDENT, INDENT].join("");
-        output$1.info(source$1.cyan([spacer, label, ...values].join(spacer)));
+        output.info(source$1.cyan([spacer, label, ...values].join(spacer)));
       });
       return;
     }
     const styledText = options.error ? source$1.redBright`${message}` : message;
     const type = options.error ? `${source$1.black.bgRedBright` error `}${INDENT}` : "";
     const combinedMessage = [type, styledText].join("");
-    output$1.info(options.strong ? source$1.bold(combinedMessage) : combinedMessage);
+    output.info(options.strong ? source$1.bold(combinedMessage) : combinedMessage);
     if (options.breakAfter) {
-      output$1.info("");
+      output.info("");
     }
   }
   printFile({ path, overwritten, diff }) {
@@ -54143,7 +54217,7 @@ function _defu(baseObj, defaults, namespace = ".", merger) {
       continue;
     }
     if (Array.isArray(val) && Array.isArray(obj[key])) {
-      obj[key] = obj[key].concat(val);
+      obj[key] = val.concat(obj[key]);
     } else if (isObject(val) && isObject(obj[key])) {
       obj[key] = _defu(val, obj[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
     } else {
@@ -54152,23 +54226,10 @@ function _defu(baseObj, defaults, namespace = ".", merger) {
   }
   return obj;
 }
-function extend(merger) {
+function createDefu(merger) {
   return (...args) => args.reduce((p, c) => _defu(p, c, "", merger), {});
 }
-const defu = extend();
-defu.fn = extend((obj, key, currentValue, _namespace) => {
-  if (typeof obj[key] !== "undefined" && typeof currentValue === "function") {
-    obj[key] = currentValue(obj[key]);
-    return true;
-  }
-});
-defu.arrayFn = extend((obj, key, currentValue, _namespace) => {
-  if (Array.isArray(obj[key]) && typeof currentValue === "function") {
-    obj[key] = currentValue(obj[key]);
-    return true;
-  }
-});
-defu.extend = extend;
+const defu = createDefu();
 
 const defaultExtensions = ["mts", "cts", "ts", "mjs", "cjs", "js", "json", ""];
 
@@ -63396,4 +63457,4 @@ class Command extends Command$1 {
 }
 
 export { Command as C, HelpfulError as H, source$1 as a, commonjsGlobal as b, cliHydrogenPackageJson as c, commonjsRequire as d, semver as s };
-//# sourceMappingURL=Command-da8a6365.js.map
+//# sourceMappingURL=Command-4e1093c6.js.map