@quilted/create 0.1.89 → 0.2.0

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.esnext

@@ -2,4 +2,4 @@ import TemplateTag from '../TemplateTag/TemplateTag.esnext';
 import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 
-new TemplateTag(stripIndentTransformer('all'), trimResultTransformer);
+new TemplateTag(stripIndentTransformer("all"), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/trimResultTransformer/trimResultTransformer.esnext

@@ -1,27 +1,18 @@
-/**
- * TemplateTag transformer that trims whitespace on the end result of a tagged template
- * @param  {String} side = '' - The side of the string to trim. Can be 'start' or 'end' (alternatively 'left' or 'right')
- * @return {Object}           - a TemplateTag transformer
- */
-var trimResultTransformer = function trimResultTransformer() {
-  var side = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+var trimResultTransformer = function trimResultTransformer2() {
+  var side = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
   return {
     onEndResult: function onEndResult(endResult) {
-      if (side === '') {
+      if (side === "") {
         return endResult.trim();
       }
-
       side = side.toLowerCase();
-
-      if (side === 'start' || side === 'left') {
-        return endResult.replace(/^\s*/, '');
+      if (side === "start" || side === "left") {
+        return endResult.replace(/^\s*/, "");
       }
-
-      if (side === 'end' || side === 'right') {
-        return endResult.replace(/\s*$/, '');
+      if (side === "end" || side === "right") {
+        return endResult.replace(/\s*$/, "");
       }
-
-      throw new Error('Side not supported: ' + side);
+      throw new Error("Side not supported: " + side);
     }
   };
 };

package/build/esnext/node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.esnext

@@ -1,85 +1,66 @@
 import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.esnext';
-import { __module as dirGlob$1 } from '../../../../../_virtual/index3.esnext';
-import path__default from 'node:path';
+import { __module as dirGlob$1 } from '../../../../../_virtual/index2.esnext';
+import path__default from 'path';
 import '../../../path-type@4.0.0/node_modules/path-type/index.esnext';
-import { __exports as pathType$1 } from '../../../../../_virtual/index4.esnext';
+import { __exports as pathType$1 } from '../../../../../_virtual/index3.esnext';
 
 const path = path__default;
 const pathType = pathType$1;
-
-const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
-
+const getExtensions = (extensions) => extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0];
 const getPath = (filepath, cwd) => {
-	const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
-	return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
+  const pth = filepath[0] === "!" ? filepath.slice(1) : filepath;
+  return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
 };
-
 const addExtensions = (file, extensions) => {
-	if (path.extname(file)) {
-		return `**/${file}`;
-	}
-
-	return `**/${file}.${getExtensions(extensions)}`;
+  if (path.extname(file)) {
+    return `**/${file}`;
+  }
+  return `**/${file}.${getExtensions(extensions)}`;
 };
-
 const getGlob = (directory, options) => {
-	if (options.files && !Array.isArray(options.files)) {
-		throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
-	}
-
-	if (options.extensions && !Array.isArray(options.extensions)) {
-		throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
-	}
-
-	if (options.files && options.extensions) {
-		return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
-	}
-
-	if (options.files) {
-		return options.files.map(x => path.posix.join(directory, `**/${x}`));
-	}
-
-	if (options.extensions) {
-		return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
-	}
-
-	return [path.posix.join(directory, '**')];
+  if (options.files && !Array.isArray(options.files)) {
+    throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+  }
+  if (options.extensions && !Array.isArray(options.extensions)) {
+    throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+  }
+  if (options.files && options.extensions) {
+    return options.files.map((x) => path.posix.join(directory, addExtensions(x, options.extensions)));
+  }
+  if (options.files) {
+    return options.files.map((x) => path.posix.join(directory, `**/${x}`));
+  }
+  if (options.extensions) {
+    return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+  }
+  return [path.posix.join(directory, "**")];
 };
-
 dirGlob$1.exports = async (input, options) => {
-	options = {
-		cwd: process.cwd(),
-		...options
-	};
-
-	if (typeof options.cwd !== 'string') {
-		throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-	}
-
-	const globs = await Promise.all([].concat(input).map(async x => {
-		const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
-		return isDirectory ? getGlob(x, options) : x;
-	}));
-
-	return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+  options = {
+    cwd: process.cwd(),
+    ...options
+  };
+  if (typeof options.cwd !== "string") {
+    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+  }
+  const globs = await Promise.all([].concat(input).map(async (x) => {
+    const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+    return isDirectory ? getGlob(x, options) : x;
+  }));
+  return [].concat.apply([], globs);
 };
-
 dirGlob$1.exports.sync = (input, options) => {
-	options = {
-		cwd: process.cwd(),
-		...options
-	};
-
-	if (typeof options.cwd !== 'string') {
-		throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-	}
-
-	const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
-
-	return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+  options = {
+    cwd: process.cwd(),
+    ...options
+  };
+  if (typeof options.cwd !== "string") {
+    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+  }
+  const globs = [].concat(input).map((x) => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+  return [].concat.apply([], globs);
 };
-
 var dirGlobExports = dirGlob$1.exports;
-var dirGlob = /*@__PURE__*/getDefaultExportFromCjs(dirGlobExports);
+const dirGlob = /* @__PURE__ */ getDefaultExportFromCjs(dirGlobExports);
 
 export { dirGlob as default };

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

@@ -12,76 +12,68 @@ import { __exports as async } from '../../../../../../_virtual/async.esnext';
 import { __exports as stream } from '../../../../../../_virtual/stream.esnext';
 import { __exports as sync } from '../../../../../../_virtual/sync.esnext';
 import { __exports as settings } from '../../../../../../_virtual/settings.esnext';
-import { __exports as utils$1 } from '../../../../../../_virtual/index2.esnext';
+import { __exports as utils$1 } from '../../../../../../_virtual/index.esnext';
 
-const taskManager = tasks;
-const patternManager = patterns;
-const async_1 = async;
-const stream_1 = stream;
-const sync_1 = sync;
-const settings_1 = settings;
-const utils = utils$1;
-async function FastGlob(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, async_1.default, options);
-    const result = await Promise.all(works);
-    return utils.array.flatten(result);
-}
-// https://github.com/typescript-eslint/typescript-eslint/issues/60
-// eslint-disable-next-line no-redeclare
-(function (FastGlob) {
-    function sync(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, sync_1.default, options);
-        return utils.array.flatten(works);
-    }
-    FastGlob.sync = sync;
-    function stream(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, stream_1.default, options);
-        /**
-         * The stream returned by the provider cannot work with an asynchronous iterator.
-         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-         * This affects performance (+25%). I don't see best solution right now.
-         */
-        return utils.stream.merge(works);
-    }
-    FastGlob.stream = stream;
-    function generateTasks(source, options) {
-        assertPatternsInput(source);
-        const patterns = patternManager.transform([].concat(source));
-        const settings = new settings_1.default(options);
-        return taskManager.generate(patterns, settings);
-    }
-    FastGlob.generateTasks = generateTasks;
-    function isDynamicPattern(source, options) {
-        assertPatternsInput(source);
-        const settings = new settings_1.default(options);
-        return utils.pattern.isDynamicPattern(source, settings);
-    }
-    FastGlob.isDynamicPattern = isDynamicPattern;
-    function escapePath(source) {
-        assertPatternsInput(source);
-        return utils.path.escape(source);
-    }
-    FastGlob.escapePath = escapePath;
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-    const patterns = patternManager.transform([].concat(source));
-    const settings = new settings_1.default(options);
-    const tasks = taskManager.generate(patterns, settings);
-    const provider = new _Provider(settings);
-    return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-    const source = [].concat(input);
-    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
-    if (!isValidSource) {
-        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
-    }
-}
+const taskManager = tasks;
+const patternManager = patterns;
+const async_1 = async;
+const stream_1 = stream;
+const sync_1 = sync;
+const settings_1 = settings;
+const utils = utils$1;
+async function FastGlob(source, options) {
+  assertPatternsInput(source);
+  const works = getWorks(source, async_1.default, options);
+  const result = await Promise.all(works);
+  return utils.array.flatten(result);
+}
+(function(FastGlob2) {
+  function sync(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, sync_1.default, options);
+    return utils.array.flatten(works);
+  }
+  FastGlob2.sync = sync;
+  function stream(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, stream_1.default, options);
+    return utils.stream.merge(works);
+  }
+  FastGlob2.stream = stream;
+  function generateTasks(source, options) {
+    assertPatternsInput(source);
+    const patterns = patternManager.transform([].concat(source));
+    const settings = new settings_1.default(options);
+    return taskManager.generate(patterns, settings);
+  }
+  FastGlob2.generateTasks = generateTasks;
+  function isDynamicPattern(source, options) {
+    assertPatternsInput(source);
+    const settings = new settings_1.default(options);
+    return utils.pattern.isDynamicPattern(source, settings);
+  }
+  FastGlob2.isDynamicPattern = isDynamicPattern;
+  function escapePath(source) {
+    assertPatternsInput(source);
+    return utils.path.escape(source);
+  }
+  FastGlob2.escapePath = escapePath;
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+  const patterns = patternManager.transform([].concat(source));
+  const settings = new settings_1.default(options);
+  const tasks = taskManager.generate(patterns, settings);
+  const provider = new _Provider(settings);
+  return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+  const source = [].concat(input);
+  const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+  if (!isValidSource) {
+    throw new TypeError("Patterns must be a string (non empty) or an array of strings");
+  }
+}
 var out = FastGlob;
-
-var fastGlob = /*@__PURE__*/getDefaultExportFromCjs(out);
+const fastGlob = /* @__PURE__ */ getDefaultExportFromCjs(out);
 
 export { fastGlob as default };

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/patterns.esnext

@@ -1,24 +1,15 @@
 import { __exports as patterns } from '../../../../../../../_virtual/patterns.esnext';
 
-Object.defineProperty(patterns, "__esModule", { value: true });
-patterns.removeDuplicateSlashes = patterns.transform = void 0;
-/**
- * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
- * The latter is due to the presence of the device path at the beginning of the UNC path.
- * @todo rewrite to negative lookbehind with the next major release.
- */
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns) {
-    return patterns.map((pattern) => removeDuplicateSlashes(pattern));
-}
-patterns.transform = transform;
-/**
- * This package only works with forward slashes as a path separator.
- * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
- */
-function removeDuplicateSlashes(pattern) {
-    return pattern.replace(DOUBLE_SLASH_RE, '/');
-}
+Object.defineProperty(patterns, "__esModule", { value: true });
+patterns.removeDuplicateSlashes = patterns.transform = void 0;
+const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+function transform(patterns2) {
+  return patterns2.map((pattern) => removeDuplicateSlashes(pattern));
+}
+patterns.transform = transform;
+function removeDuplicateSlashes(pattern) {
+  return pattern.replace(DOUBLE_SLASH_RE, "/");
+}
 patterns.removeDuplicateSlashes = removeDuplicateSlashes;
 
 export { patterns as default };

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

@@ -1,85 +1,83 @@
 import { __exports as tasks } from '../../../../../../../_virtual/tasks.esnext';
 import '../utils/index.esnext';
-import { __exports as utils$1 } from '../../../../../../../_virtual/index2.esnext';
+import { __exports as utils$1 } from '../../../../../../../_virtual/index.esnext';
 
-Object.defineProperty(tasks, "__esModule", { value: true });
-tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils = utils$1;
-function generate(patterns, settings) {
-    const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.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;
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-function convertPatternsToTasks(positive, negative, dynamic) {
-    const tasks = [];
-    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
-    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
-    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-    /*
-     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
-     */
-    if ('.' in insideCurrentDirectoryGroup) {
-        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
-    }
-    else {
-        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
-    }
-    return tasks;
-}
-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))
-    };
-}
+Object.defineProperty(tasks, "__esModule", { value: true });
+tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+const utils = utils$1;
+function generate(patterns, settings) {
+  const positivePatterns = getPositivePatterns(patterns);
+  const negativePatterns = getNegativePatternsAsPositive(patterns, settings.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 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;
 
 export { tasks as default };

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

@@ -4,25 +4,25 @@ import './provider.esnext';
 import { __exports as async$1 } from '../../../../../../../_virtual/async2.esnext';
 import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
 
-Object.defineProperty(async, "__esModule", { value: true });
-const async_1 = async$1;
-const provider_1 = provider;
-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);
-    }
-}
+Object.defineProperty(async, "__esModule", { value: true });
+const async_1 = async$1;
+const provider_1 = provider;
+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;