@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/managers/tasks.esnext

@@ -0,0 +1,100 @@
+import { __exports as tasks } from '../../../../../../../_virtual/tasks.esnext';
+import { __require as requireUtils } from '../utils/index.esnext';
+
+var hasRequiredTasks;
+function requireTasks() {
+  if (hasRequiredTasks) return tasks;
+  hasRequiredTasks = 1;
+  Object.defineProperty(tasks, "__esModule", { value: true });
+  tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+  const utils = requireUtils();
+  function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
+    const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
+    const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
+    const staticTasks = convertPatternsToTasks(
+      staticPatterns,
+      negativePatterns,
+      /* dynamic */
+      false
+    );
+    const dynamicTasks = convertPatternsToTasks(
+      dynamicPatterns,
+      negativePatterns,
+      /* dynamic */
+      true
+    );
+    return staticTasks.concat(dynamicTasks);
+  }
+  tasks.generate = generate;
+  function processPatterns(input, settings) {
+    let patterns = input;
+    if (settings.braceExpansion) {
+      patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
+    }
+    if (settings.baseNameMatch) {
+      patterns = patterns.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`);
+    }
+    return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
+  }
+  function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks2 = [];
+    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks2.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    if ("." in insideCurrentDirectoryGroup) {
+      tasks2.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
+    } else {
+      tasks2.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+    }
+    return tasks2;
+  }
+  tasks.convertPatternsToTasks = convertPatternsToTasks;
+  function getPositivePatterns(patterns) {
+    return utils.pattern.getPositivePatterns(patterns);
+  }
+  tasks.getPositivePatterns = getPositivePatterns;
+  function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils.pattern.convertToPositivePattern);
+    return positive;
+  }
+  tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+  function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+      const base = utils.pattern.getBaseDirectory(pattern);
+      if (base in collection) {
+        collection[base].push(pattern);
+      } else {
+        collection[base] = [pattern];
+      }
+      return collection;
+    }, group);
+  }
+  tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+  function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map((base) => {
+      return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+  }
+  tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+  function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+      dynamic,
+      positive,
+      negative,
+      base,
+      patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+    };
+  }
+  tasks.convertPatternGroupToTask = convertPatternGroupToTask;
+  return tasks;
+}
+
+export { requireTasks as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/async.esnext

@@ -0,0 +1,34 @@
+import { __exports as async } from '../../../../../../../_virtual/async.esnext';
+import { __require as requireAsync$1 } from '../readers/async.esnext';
+import { __require as requireProvider } from './provider.esnext';
+
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", { value: true });
+  const async_1 = requireAsync$1();
+  const provider_1 = requireProvider();
+  class ProviderAsync extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new async_1.default(this._settings);
+    }
+    async read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const entries = await this.api(root, task, options);
+      return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  async.default = ProviderAsync;
+  return async;
+}
+
+export { requireAsync as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/deep.esnext

@@ -0,0 +1,70 @@
+import { __exports as deep } from '../../../../../../../../_virtual/deep.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+import { __require as requirePartial } from '../matchers/partial.esnext';
+
+var hasRequiredDeep;
+function requireDeep() {
+  if (hasRequiredDeep) return deep;
+  hasRequiredDeep = 1;
+  Object.defineProperty(deep, "__esModule", { value: true });
+  const utils = requireUtils();
+  const partial_1 = requirePartial();
+  class DeepFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+    }
+    getFilter(basePath, positive, negative) {
+      const matcher = this._getMatcher(positive);
+      const negativeRe = this._getNegativePatternsRe(negative);
+      return (entry) => this._filter(basePath, entry, matcher, negativeRe);
+    }
+    _getMatcher(patterns) {
+      return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(patterns) {
+      const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+      return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+    }
+    _filter(basePath, entry, matcher, negativeRe) {
+      if (this._isSkippedByDeep(basePath, entry.path)) {
+        return false;
+      }
+      if (this._isSkippedSymbolicLink(entry)) {
+        return false;
+      }
+      const filepath = utils.path.removeLeadingDotSegment(entry.path);
+      if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+        return false;
+      }
+      return this._isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    _isSkippedByDeep(basePath, entryPath) {
+      if (this._settings.deep === Infinity) {
+        return false;
+      }
+      return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+    }
+    _getEntryLevel(basePath, entryPath) {
+      const entryPathDepth = entryPath.split("/").length;
+      if (basePath === "") {
+        return entryPathDepth;
+      }
+      const basePathDepth = basePath.split("/").length;
+      return entryPathDepth - basePathDepth;
+    }
+    _isSkippedSymbolicLink(entry) {
+      return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(entryPath, matcher) {
+      return !this._settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    _isSkippedByNegativePatterns(entryPath, patternsRe) {
+      return !utils.pattern.matchAny(entryPath, patternsRe);
+    }
+  }
+  deep.default = DeepFilter;
+  return deep;
+}
+
+export { requireDeep as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/entry.esnext

@@ -0,0 +1,92 @@
+import { __exports as entry } from '../../../../../../../../_virtual/entry.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+
+var hasRequiredEntry;
+function requireEntry() {
+  if (hasRequiredEntry) return entry;
+  hasRequiredEntry = 1;
+  Object.defineProperty(entry, "__esModule", { value: true });
+  const utils = requireUtils();
+  class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this.index = /* @__PURE__ */ new Map();
+    }
+    getFilter(positive, negative) {
+      const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
+      const patterns = {
+        positive: {
+          all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
+        },
+        negative: {
+          absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
+          relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
+        }
+      };
+      return (entry2) => this._filter(entry2, patterns);
+    }
+    _filter(entry2, patterns) {
+      const filepath = utils.path.removeLeadingDotSegment(entry2.path);
+      if (this._settings.unique && this._isDuplicateEntry(filepath)) {
+        return false;
+      }
+      if (this._onlyFileFilter(entry2) || this._onlyDirectoryFilter(entry2)) {
+        return false;
+      }
+      const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry2.dirent.isDirectory());
+      if (this._settings.unique && isMatched) {
+        this._createIndexRecord(filepath);
+      }
+      return isMatched;
+    }
+    _isDuplicateEntry(filepath) {
+      return this.index.has(filepath);
+    }
+    _createIndexRecord(filepath) {
+      this.index.set(filepath, void 0);
+    }
+    _onlyFileFilter(entry2) {
+      return this._settings.onlyFiles && !entry2.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry2) {
+      return this._settings.onlyDirectories && !entry2.dirent.isDirectory();
+    }
+    _isMatchToPatternsSet(filepath, patterns, isDirectory) {
+      const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
+      if (!isMatched) {
+        return false;
+      }
+      const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
+      if (isMatchedByRelativeNegative) {
+        return false;
+      }
+      const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
+      if (isMatchedByAbsoluteNegative) {
+        return false;
+      }
+      return true;
+    }
+    _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
+      if (patternsRe.length === 0) {
+        return false;
+      }
+      const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+      return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
+    }
+    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+      if (patternsRe.length === 0) {
+        return false;
+      }
+      const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+      if (!isMatched && isDirectory) {
+        return utils.pattern.matchAny(filepath + "/", patternsRe);
+      }
+      return isMatched;
+    }
+  }
+  entry.default = EntryFilter;
+  return entry;
+}
+
+export { requireEntry as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/error.esnext

@@ -0,0 +1,25 @@
+import { __exports as error } from '../../../../../../../../_virtual/error.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+
+var hasRequiredError;
+function requireError() {
+  if (hasRequiredError) return error;
+  hasRequiredError = 1;
+  Object.defineProperty(error, "__esModule", { value: true });
+  const utils = requireUtils();
+  class ErrorFilter {
+    constructor(_settings) {
+      this._settings = _settings;
+    }
+    getFilter() {
+      return (error2) => this._isNonFatalError(error2);
+    }
+    _isNonFatalError(error2) {
+      return utils.errno.isEnoentCodeError(error2) || this._settings.suppressErrors;
+    }
+  }
+  error.default = ErrorFilter;
+  return error;
+}
+
+export { requireError as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/matcher.esnext

@@ -0,0 +1,55 @@
+import { __exports as matcher } from '../../../../../../../../_virtual/matcher.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+
+var hasRequiredMatcher;
+function requireMatcher() {
+  if (hasRequiredMatcher) return matcher;
+  hasRequiredMatcher = 1;
+  Object.defineProperty(matcher, "__esModule", { value: true });
+  const utils = requireUtils();
+  class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+      this._patterns = _patterns;
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this._storage = [];
+      this._fillStorage();
+    }
+    _fillStorage() {
+      for (const pattern of this._patterns) {
+        const segments = this._getPatternSegments(pattern);
+        const sections = this._splitSegmentsIntoSections(segments);
+        this._storage.push({
+          complete: sections.length <= 1,
+          pattern,
+          segments,
+          sections
+        });
+      }
+    }
+    _getPatternSegments(pattern) {
+      const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+      return parts.map((part) => {
+        const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+        if (!dynamic) {
+          return {
+            dynamic: false,
+            pattern: part
+          };
+        }
+        return {
+          dynamic: true,
+          pattern: part,
+          patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+        };
+      });
+    }
+    _splitSegmentsIntoSections(segments) {
+      return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+    }
+  }
+  matcher.default = Matcher;
+  return matcher;
+}
+
+export { requireMatcher as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/partial.esnext

@@ -0,0 +1,41 @@
+import { __exports as partial } from '../../../../../../../../_virtual/partial.esnext';
+import { __require as requireMatcher } from './matcher.esnext';
+
+var hasRequiredPartial;
+function requirePartial() {
+  if (hasRequiredPartial) return partial;
+  hasRequiredPartial = 1;
+  Object.defineProperty(partial, "__esModule", { value: true });
+  const matcher_1 = requireMatcher();
+  class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+      const parts = filepath.split("/");
+      const levels = parts.length;
+      const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+      for (const pattern of patterns) {
+        const section = pattern.sections[0];
+        if (!pattern.complete && levels > section.length) {
+          return true;
+        }
+        const match = parts.every((part, index) => {
+          const segment = pattern.segments[index];
+          if (segment.dynamic && segment.patternRe.test(part)) {
+            return true;
+          }
+          if (!segment.dynamic && segment.pattern === part) {
+            return true;
+          }
+          return false;
+        });
+        if (match) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  partial.default = PartialMatcher;
+  return partial;
+}
+
+export { requirePartial as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.esnext

@@ -0,0 +1,62 @@
+import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+import path__default from 'node:path';
+import { __require as requireDeep } from './filters/deep.esnext';
+import { __require as requireEntry } from './filters/entry.esnext';
+import { __require as requireError } from './filters/error.esnext';
+import { __require as requireEntry$1 } from './transformers/entry.esnext';
+
+var hasRequiredProvider;
+function requireProvider() {
+  if (hasRequiredProvider) return provider;
+  hasRequiredProvider = 1;
+  Object.defineProperty(provider, "__esModule", { value: true });
+  const path = path__default;
+  const deep_1 = requireDeep();
+  const entry_1 = requireEntry();
+  const error_1 = requireError();
+  const entry_2 = requireEntry$1();
+  class Provider {
+    constructor(_settings) {
+      this._settings = _settings;
+      this.errorFilter = new error_1.default(this._settings);
+      this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+      this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+      this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+      return path.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+      const basePath = task.base === "." ? "" : task.base;
+      return {
+        basePath,
+        pathSegmentSeparator: "/",
+        concurrency: this._settings.concurrency,
+        deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+        entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+        errorFilter: this.errorFilter.getFilter(),
+        followSymbolicLinks: this._settings.followSymbolicLinks,
+        fs: this._settings.fs,
+        stats: this._settings.stats,
+        throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+        transform: this.entryTransformer.getTransformer()
+      };
+    }
+    _getMicromatchOptions() {
+      return {
+        dot: this._settings.dot,
+        matchBase: this._settings.baseNameMatch,
+        nobrace: !this._settings.braceExpansion,
+        nocase: !this._settings.caseSensitiveMatch,
+        noext: !this._settings.extglob,
+        noglobstar: !this._settings.globstar,
+        posix: true,
+        strictSlashes: false
+      };
+    }
+  }
+  provider.default = Provider;
+  return provider;
+}
+
+export { requireProvider as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/stream.esnext

@@ -0,0 +1,40 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream.esnext';
+import require$$0 from 'node:stream';
+import { __require as requireStream$1 } from '../readers/stream.esnext';
+import { __require as requireProvider } from './provider.esnext';
+
+var hasRequiredStream;
+function requireStream() {
+  if (hasRequiredStream) return stream;
+  hasRequiredStream = 1;
+  Object.defineProperty(stream, "__esModule", { value: true });
+  const stream_1 = require$$0;
+  const stream_2 = requireStream$1();
+  const provider_1 = requireProvider();
+  class ProviderStream extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const source = this.api(root, task, options);
+      const destination = new stream_1.Readable({ objectMode: true, read: () => {
+      } });
+      source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end"));
+      destination.once("close", () => source.destroy());
+      return destination;
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  stream.default = ProviderStream;
+  return stream;
+}
+
+export { requireStream as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/sync.esnext

@@ -0,0 +1,34 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync.esnext';
+import { __require as requireSync$1 } from '../readers/sync.esnext';
+import { __require as requireProvider } from './provider.esnext';
+
+var hasRequiredSync;
+function requireSync() {
+  if (hasRequiredSync) return sync;
+  hasRequiredSync = 1;
+  Object.defineProperty(sync, "__esModule", { value: true });
+  const sync_1 = requireSync$1();
+  const provider_1 = requireProvider();
+  class ProviderSync extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new sync_1.default(this._settings);
+    }
+    read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const entries = this.api(root, task, options);
+      return entries.map(options.transform);
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  sync.default = ProviderSync;
+  return sync;
+}
+
+export { requireSync as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/transformers/entry.esnext

@@ -0,0 +1,36 @@
+import { __exports as entry } from '../../../../../../../../_virtual/entry2.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+
+var hasRequiredEntry;
+function requireEntry() {
+  if (hasRequiredEntry) return entry;
+  hasRequiredEntry = 1;
+  Object.defineProperty(entry, "__esModule", { value: true });
+  const utils = requireUtils();
+  class EntryTransformer {
+    constructor(_settings) {
+      this._settings = _settings;
+    }
+    getTransformer() {
+      return (entry2) => this._transform(entry2);
+    }
+    _transform(entry2) {
+      let filepath = entry2.path;
+      if (this._settings.absolute) {
+        filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+        filepath = utils.path.unixify(filepath);
+      }
+      if (this._settings.markDirectories && entry2.dirent.isDirectory()) {
+        filepath += "/";
+      }
+      if (!this._settings.objectMode) {
+        return filepath;
+      }
+      return Object.assign(Object.assign({}, entry2), { path: filepath });
+    }
+  }
+  entry.default = EntryTransformer;
+  return entry;
+}
+
+export { requireEntry as __require };

package/build/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/async.esnext

@@ -0,0 +1,45 @@
+import { __exports as async } from '../../../../../../../_virtual/async2.esnext';
+import { __require as requireOut } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext';
+import { __require as requireReader } from './reader.esnext';
+import { __require as requireStream } from './stream.esnext';
+
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", { value: true });
+  const fsWalk = requireOut();
+  const reader_1 = requireReader();
+  const stream_1 = requireStream();
+  class ReaderAsync extends reader_1.default {
+    constructor() {
+      super(...arguments);
+      this._walkAsync = fsWalk.walk;
+      this._readerStream = new stream_1.default(this._settings);
+    }
+    dynamic(root, options) {
+      return new Promise((resolve, reject) => {
+        this._walkAsync(root, options, (error, entries) => {
+          if (error === null) {
+            resolve(entries);
+          } else {
+            reject(error);
+          }
+        });
+      });
+    }
+    async static(patterns, options) {
+      const entries = [];
+      const stream = this._readerStream.static(patterns, options);
+      return new Promise((resolve, reject) => {
+        stream.once("error", reject);
+        stream.on("data", (entry) => entries.push(entry));
+        stream.once("end", () => resolve(entries));
+      });
+    }
+  }
+  async.default = ReaderAsync;
+  return async;
+}
+
+export { requireAsync as __require };