@quilted/create 0.2.42 → 0.2.44

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

@@ -1,64 +1,70 @@
 import { __exports as deep } from '../../../../../../../../_virtual/deep.esnext';
-import '../../utils/index.esnext';
-import '../matchers/partial.esnext';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.esnext';
-import { __exports as partial } from '../../../../../../../../_virtual/partial.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
+import { __require as requirePartial } from '../matchers/partial.esnext';
 
-Object.defineProperty(deep, "__esModule", { value: true });
-const utils = utils$1;
-const partial_1 = partial;
-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;
+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;
     }
-    if (this._isSkippedSymbolicLink(entry)) {
-      return false;
+    getFilter(basePath, positive, negative) {
+      const matcher = this._getMatcher(positive);
+      const negativeRe = this._getNegativePatternsRe(negative);
+      return (entry) => this._filter(basePath, entry, matcher, negativeRe);
     }
-    const filepath = utils.path.removeLeadingDotSegment(entry.path);
-    if (this._isSkippedByPositivePatterns(filepath, matcher)) {
-      return false;
+    _getMatcher(patterns) {
+      return new partial_1.default(patterns, this._settings, this._micromatchOptions);
     }
-    return this._isSkippedByNegativePatterns(filepath, negativeRe);
-  }
-  _isSkippedByDeep(basePath, entryPath) {
-    if (this._settings.deep === Infinity) {
-      return false;
+    _getNegativePatternsRe(patterns) {
+      const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+      return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
     }
-    return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
-  }
-  _getEntryLevel(basePath, entryPath) {
-    const entryPathDepth = entryPath.split("/").length;
-    if (basePath === "") {
-      return entryPathDepth;
+    _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);
     }
-    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;
 }
-deep.default = DeepFilter;
+
+export { requireDeep as __require };

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

@@ -1,64 +1,71 @@
 import { __exports as entry } from '../../../../../../../../_virtual/entry.esnext';
-import '../../utils/index.esnext';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.esnext';
+import { __require as requireUtils } from '../../utils/index.esnext';
 
-Object.defineProperty(entry, "__esModule", { value: true });
-const utils = utils$1;
-class EntryFilter {
-  constructor(_settings, _micromatchOptions) {
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-    this.index = /* @__PURE__ */ new Map();
-  }
-  getFilter(positive, negative) {
-    const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-    const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
-    return (entry2) => this._filter(entry2, positiveRe, negativeRe);
-  }
-  _filter(entry2, positiveRe, negativeRe) {
-    if (this._settings.unique && this._isDuplicateEntry(entry2)) {
-      return false;
+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();
     }
-    if (this._onlyFileFilter(entry2) || this._onlyDirectoryFilter(entry2)) {
-      return false;
+    getFilter(positive, negative) {
+      const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+      const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+      return (entry2) => this._filter(entry2, positiveRe, negativeRe);
     }
-    if (this._isSkippedByAbsoluteNegativePatterns(entry2.path, negativeRe)) {
-      return false;
+    _filter(entry2, positiveRe, negativeRe) {
+      if (this._settings.unique && this._isDuplicateEntry(entry2)) {
+        return false;
+      }
+      if (this._onlyFileFilter(entry2) || this._onlyDirectoryFilter(entry2)) {
+        return false;
+      }
+      if (this._isSkippedByAbsoluteNegativePatterns(entry2.path, negativeRe)) {
+        return false;
+      }
+      const filepath = this._settings.baseNameMatch ? entry2.name : entry2.path;
+      const isDirectory = entry2.dirent.isDirectory();
+      const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry2.path, negativeRe, isDirectory);
+      if (this._settings.unique && isMatched) {
+        this._createIndexRecord(entry2);
+      }
+      return isMatched;
     }
-    const filepath = this._settings.baseNameMatch ? entry2.name : entry2.path;
-    const isDirectory = entry2.dirent.isDirectory();
-    const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry2.path, negativeRe, isDirectory);
-    if (this._settings.unique && isMatched) {
-      this._createIndexRecord(entry2);
+    _isDuplicateEntry(entry2) {
+      return this.index.has(entry2.path);
     }
-    return isMatched;
-  }
-  _isDuplicateEntry(entry2) {
-    return this.index.has(entry2.path);
-  }
-  _createIndexRecord(entry2) {
-    this.index.set(entry2.path, void 0);
-  }
-  _onlyFileFilter(entry2) {
-    return this._settings.onlyFiles && !entry2.dirent.isFile();
-  }
-  _onlyDirectoryFilter(entry2) {
-    return this._settings.onlyDirectories && !entry2.dirent.isDirectory();
-  }
-  _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
-    if (!this._settings.absolute) {
-      return false;
+    _createIndexRecord(entry2) {
+      this.index.set(entry2.path, void 0);
     }
-    const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
-    return utils.pattern.matchAny(fullpath, patternsRe);
-  }
-  _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
-    const filepath = utils.path.removeLeadingDotSegment(entryPath);
-    const isMatched = utils.pattern.matchAny(filepath, patternsRe);
-    if (!isMatched && isDirectory) {
-      return utils.pattern.matchAny(filepath + "/", patternsRe);
+    _onlyFileFilter(entry2) {
+      return this._settings.onlyFiles && !entry2.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry2) {
+      return this._settings.onlyDirectories && !entry2.dirent.isDirectory();
+    }
+    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+      if (!this._settings.absolute) {
+        return false;
+      }
+      const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
+      return utils.pattern.matchAny(fullpath, patternsRe);
+    }
+    _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
+      const filepath = utils.path.removeLeadingDotSegment(entryPath);
+      const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+      if (!isMatched && isDirectory) {
+        return utils.pattern.matchAny(filepath + "/", patternsRe);
+      }
+      return isMatched;
     }
-    return isMatched;
   }
+  entry.default = EntryFilter;
+  return entry;
 }
-entry.default = EntryFilter;
+
+export { requireEntry as __require };

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

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

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

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

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

@@ -1,34 +1,41 @@
 import { __exports as partial } from '../../../../../../../../_virtual/partial.esnext';
-import './matcher.esnext';
-import { __exports as matcher } from '../../../../../../../../_virtual/matcher.esnext';
+import { __require as requireMatcher } from './matcher.esnext';
 
-Object.defineProperty(partial, "__esModule", { value: true });
-const matcher_1 = matcher;
-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)) {
+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;
         }
-        if (!segment.dynamic && segment.pattern === part) {
+        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;
-      });
-      if (match) {
-        return true;
       }
+      return false;
     }
-    return false;
   }
+  partial.default = PartialMatcher;
+  return partial;
 }
-partial.default = PartialMatcher;
+
+export { requirePartial as __require };

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

@@ -1,58 +1,62 @@
 import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
 import path__default from 'node:path';
-import './filters/deep.esnext';
-import './filters/entry.esnext';
-import './filters/error.esnext';
-import './transformers/entry.esnext';
-import { __exports as deep } from '../../../../../../../_virtual/deep.esnext';
-import { __exports as entry } from '../../../../../../../_virtual/entry.esnext';
-import { __exports as error } from '../../../../../../../_virtual/error.esnext';
-import { __exports as entry$1 } from '../../../../../../../_virtual/entry2.esnext';
+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';
 
-Object.defineProperty(provider, "__esModule", { value: true });
-const path = path__default;
-const deep_1 = deep;
-const entry_1 = entry;
-const error_1 = error;
-const entry_2 = entry$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
-    };
+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;
 }
-provider.default = Provider;
+
+export { requireProvider as __require };

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

@@ -1,34 +1,40 @@
 import { __exports as stream } from '../../../../../../../_virtual/stream.esnext';
 import require$$0 from 'node:stream';
-import '../readers/stream.esnext';
-import './provider.esnext';
-import { __exports as stream$1 } from '../../../../../../../_virtual/stream2.esnext';
-import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+import { __require as requireStream$1 } from '../readers/stream.esnext';
+import { __require as requireProvider } from './provider.esnext';
 
-Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1 = require$$0;
-const stream_2 = stream$1;
-const provider_1 = provider;
-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);
+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);
     }
-    return this._reader.static(task.patterns, options);
   }
+  stream.default = ProviderStream;
+  return stream;
 }
-stream.default = ProviderStream;
+
+export { requireStream as __require };