@quilted/create 0.1.56 → 0.1.57

package/build/esnext/help.esnext

@@ -0,0 +1,110 @@
+import stripIndent from './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.esnext';
+import { bold as bold_1, magenta as magenta_1, green as green_1, cyan as cyan_1, dim as dim_1 } from './node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.esnext';
+
+function printHelp({
+  kind,
+  options: customOptions,
+  packageManager
+} = {}) {
+  const command = createCommand(packageManager);
+  const usage = stripIndent`
+    ${bold_1('Usage:')}   ${command} ${kind ? magenta_1(kind) : magenta_1('[kind]')} ${green_1('[name]')} ${cyan_1('[options]')}
+  `;
+  console.log(usage);
+  const example = stripIndent`
+    ${bold_1('Example:')} ${command} ${magenta_1(kind ?? 'app')} ${green_1(`my-${kind ?? 'app'}`)} ${cyan_1('--install')}
+  `;
+  console.log(dim_1(example));
+  if (!kind) {
+    const kindSection = stripIndent`
+    ${bold_1(magenta_1('kind'))} can be one of the following project types:
+
+     - ${magenta_1('app')}, a web application
+     - ${magenta_1('package')}, a shared library of code
+     - ${magenta_1('module')}, a standalone JavaScript module for a browser
+
+    You’ll be asked a few additional questions based on the kind you choose.
+  `;
+    console.log();
+    console.log(kindSection);
+  }
+  const optionsSection = stripIndent`
+    ${cyan_1('--name')}
+    The name of the project. When creating a package, you should use the public name you
+    want for the package, including any scope you want to use (example: ${bold_1('@my-org/my-package')}).
+    If you don’t provide a name with this flag, this command will ask you for one later.
+
+    ${cyan_1('--directory')}
+    The directory to create the project in. If you don’t provide this flag, Quilt will pick
+    a default directory based on the kind of the project and the name you provided.
+
+    ${cyan_1(`--monorepo`)}, ${cyan_1(`--no-monorepo`)}
+    If you aren’t already in a monorepo, this flag will create your new project with some
+    additional structure that allows it to be a monorepo — that is, you will be able to add
+    multiple projects to a single repository.
+
+    ${cyan_1(`--install`)}, ${cyan_1(`--no-install`)}
+    Whether to install dependencies in the newly created project. If you do not provide this
+    flag, Quilt will ask you about it later.
+
+    ${cyan_1('--package-manager')}
+    The package manager to use for your new project. This choice will be used to populate
+    some commands, and will be used to install dependencies if the ${cyan_1('--install')} flag is set.
+
+    Must be one of the following: ${bold_1('pnpm')}, ${bold_1('npm')}, or ${bold_1('yarn')}.
+
+    ${cyan_1(`--extras`)}, ${cyan_1(`--no-extras`)}
+    Extra developer tools to configure when creating your new project. This option only
+    applies when creating a brand new project, not when adding a project to an existing
+    workspace. You can include this flag multiple times to add multiple tools. You can
+    enable any of the following tools:
+
+     - ${bold_1('github')}, which adds a continuous integration (CI) GitHub Action to your project.
+     - ${bold_1('vscode')}, which adds some basic VSCode settings to your project.
+
+    ${cyan_1('--yes')}, ${cyan_1('-y')}
+    Answers “yes” to any question this command would have asked.
+
+    ${cyan_1('--help')}, ${cyan_1('-h')}
+    Prints this help documentation.
+  `;
+  console.log();
+  console.log(`${bold_1(cyan_1('options'))} can include any of these flags:`);
+  if (customOptions) {
+    console.log();
+    console.log(printOptionsSection(customOptions));
+  }
+  console.log();
+  console.log(printOptionsSection(optionsSection));
+}
+function printOptionsSection(section) {
+  return section.split('\n').map(line => line.length > 0 ? ` ${line}` : line).join('\n');
+}
+function createCommand(explicitPackageManager) {
+  let packageManager;
+  const npmUserAgent = process.env['npm_config_user_agent'] ?? 'npm';
+  if (npmUserAgent.includes('pnpm') || explicitPackageManager === 'pnpm') {
+    packageManager = 'pnpm';
+  } else if (npmUserAgent.includes('yarn') || explicitPackageManager === 'yarn') {
+    packageManager = 'yarn';
+  } else {
+    packageManager = 'npm';
+  }
+  return `${packageManager} create @quilted`;
+}
+
+export { printHelp };

package/build/esnext/index.esnext

@@ -0,0 +1,3 @@
+export { createApp } from './app.esnext';
+export { createProject } from './package.esnext';
+export { createModule } from './module.esnext';

package/build/esnext/module.esnext

@@ -0,0 +1,311 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import arg_1 from './node_modules/.pnpm/arg@5.0.1/node_modules/arg/index.esnext';
+import { cyan as cyan_1, dim as dim_1, underline as underline_1, magenta as magenta_1, bold as bold_1 } from './node_modules/.pnpm/colorette@2.0.16/node_modules/colorette/index.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.esnext';
+import stripIndent from './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.esnext';
+import { printHelp } from './help.esnext';
+import { emptyDirectory, relativeDirectoryForDisplay, toValidPackageName, format, mergeWorkspaceAndProjectPackageJsons, loadTemplate, isEmpty, createOutputTarget } from './shared.esnext';
+import { getInWorkspace, getCreateAsMonorepo, getExtrasToSetup, getShouldInstall, getPackageManager } from './shared/prompts.esnext';
+import { addToTsConfig } from './shared/tsconfig.esnext';
+import { addToPackageManagerWorkspaces } from './shared/package-manager.esnext';
+import { prompt } from './packages/cli-kit/source/prompt.esnext';
+
+async function createModule() {
+  const argv = getArgv();
+  if (argv['--help']) {
+    printHelp({
+      kind: 'module',
+      packageManager: argv['--package-manager']?.toLowerCase()
+    });
+    return;
+  }
+  const inWorkspace = await getInWorkspace(argv);
+  const name = await getName(argv);
+  const directory = await getDirectory(argv, {
+    name
+  });
+  const entry = await getEntry(argv, {
+    name
+  });
+  const useReact = await getReact(argv);
+  const createAsMonorepo = !inWorkspace && (await getCreateAsMonorepo(argv, {
+    type: 'module',
+    default: false
+  }));
+  const setupExtras = await getExtrasToSetup(argv, {
+    inWorkspace
+  });
+  const shouldInstall = await getShouldInstall(argv, {
+    type: 'module'
+  });
+  const packageManager = await getPackageManager(argv, {
+    root: directory
+  });
+  const partOfMonorepo = inWorkspace || createAsMonorepo;
+  const moduleDirectory = createAsMonorepo ? path.join(directory, 'app') : directory;
+  if (fs.existsSync(directory)) {
+    await emptyDirectory(directory);
+    if (moduleDirectory !== directory) {
+      fs.mkdirSync(moduleDirectory, {
+        recursive: true
+      });
+    }
+  } else {
+    fs.mkdirSync(moduleDirectory, {
+      recursive: true
+    });
+  }
+  const rootDirectory = inWorkspace ? process.cwd() : directory;
+  const outputRoot = createOutputTarget(rootDirectory);
+  const moduleTemplate = loadTemplate('module');
+  const workspaceTemplate = loadTemplate('workspace');
+
+  // If we aren’t already in a workspace, copy the workspace files over, which
+  // are needed if we are making a monorepo or not.
+  if (!inWorkspace) {
+    await workspaceTemplate.copy(directory, file => {
+      // When this is a single project, we use the project’s Quilt  configuration as the base.
+      if (file === 'quilt.workspace.ts') return createAsMonorepo;
+
+      // We need to make some adjustments to the root package.json
+      if (file === 'package.json') return false;
+      return true;
+    });
+
+    // If we are creating a monorepo, we need to add the root package.json and
+    // package manager workspace configuration.
+    if (createAsMonorepo) {
+      const moduleRelativeToRoot = relativeDirectoryForDisplay(path.relative(directory, moduleDirectory));
+      const workspacePackageJson = JSON.parse(await workspaceTemplate.read('package.json'));
+      workspacePackageJson.name = toValidPackageName(name);
+      workspacePackageJson.workspaces = [moduleRelativeToRoot, './packages/*'];
+      if (packageManager.type === 'pnpm') {
+        await outputRoot.write('pnpm-workspace.yaml', await format(`
+              packages:
+              - '${moduleRelativeToRoot}'
+              - './packages/*'
+            `, {
+          as: 'yaml'
+        }));
+      }
+      await outputRoot.write('package.json', await format(JSON.stringify(workspacePackageJson), {
+        as: 'json-stringify'
+      }));
+    } else {
+      const [projectPackageJson, projectTSConfig, workspacePackageJson] = await Promise.all([moduleTemplate.read('package.json').then(content => JSON.parse(content)), moduleTemplate.read('tsconfig.json').then(content => JSON.parse(content)), workspaceTemplate.read('package.json').then(content => JSON.parse(content))]);
+      const combinedPackageJson = mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson);
+      adjustPackageJson(combinedPackageJson, {
+        name,
+        entry,
+        react: useReact
+      });
+      delete combinedPackageJson.workspaces;
+      let quiltProject = await moduleTemplate.read('quilt.project.ts');
+      quiltProject = quiltProject.replace('quiltModule', 'quiltWorkspace, quiltModule').replace('quiltModule(', 'quiltWorkspace(), quiltModule(');
+      if (!useReact) {
+        quiltProject = quiltProject.replace('quiltPackage()', 'quiltPackage({react: false})');
+      }
+      await outputRoot.write('quilt.project.ts', await format(quiltProject, {
+        as: 'typescript'
+      }));
+      await outputRoot.write('package.json', await format(JSON.stringify(combinedPackageJson), {
+        as: 'json-stringify'
+      }));
+      await outputRoot.write('tsconfig.json', await format(JSON.stringify(projectTSConfig), {
+        as: 'json'
+      }));
+    }
+    if (setupExtras.has('github')) {
+      await loadTemplate('github').copy(directory);
+    }
+    if (setupExtras.has('vscode')) {
+      await loadTemplate('vscode').copy(directory);
+    }
+  }
+  await moduleTemplate.copy(moduleDirectory, file => {
+    // If we are in a monorepo, we can use all the template files as they are
+    if (file === 'quilt.project.ts' || file === 'tsconfig.json') {
+      return partOfMonorepo;
+    }
+
+    // We will adjust the entry file
+    if (file === 'module.ts') {
+      return false;
+    }
+
+    // We need to make some adjustments the project’s package.json
+    return file !== 'package.json';
+  });
+  await outputRoot.write(path.join(moduleDirectory, entry), await moduleTemplate.read('module.ts'));
+  if (partOfMonorepo) {
+    // Write the app’s package.json (the root one was already created)
+    const projectPackageJson = JSON.parse(await moduleTemplate.read('package.json'));
+    adjustPackageJson(projectPackageJson, {
+      name,
+      entry,
+      react: useReact
+    });
+    await outputRoot.write(path.join(moduleDirectory, 'package.json'), await format(JSON.stringify(projectPackageJson), {
+      as: 'json-stringify'
+    }));
+    await Promise.all([addToTsConfig(moduleDirectory, outputRoot), addToPackageManagerWorkspaces(moduleDirectory, outputRoot, packageManager.type)]);
+  }
+  if (shouldInstall) {
+    console.log();
+    // TODO: better loading, handle errors
+    await packageManager.install();
+  }
+  const commands = [];
+  if (!inWorkspace && directory !== process.cwd()) {
+    commands.push(`cd ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory)))} ${dim_1('# Move into your new module’s directory')}`);
+  }
+  if (!shouldInstall) {
+    commands.push(`${packageManager.commands.install()} ${dim_1('# Install all your dependencies')}`);
+  }
+  if (commands.length === 0) {
+    console.log();
+    console.log('Your new module is ready to go!');
+  } else {
+    const whatsNext = stripIndent`
+      Your new module is ready to go! There’s just ${commands.length > 1 ? 'a few more steps' : 'one more step'} you’ll need to take
+      in order to start developing:
+    `;
+    console.log();
+    console.log(whatsNext);
+    console.log();
+    console.log(commands.map(command => `  ${command}`).join('\n'));
+  }
+  const followUp = stripIndent`
+    Quilt can also help you build, test, lint, and type-check your new module.
+    You can learn more about building modules with Quilt by reading the documentation:
+    ${underline_1(magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation'))}
+
+    Have fun! 🎉
+  `;
+  console.log();
+  console.log(followUp);
+}
+
+// Argument handling
+
+function getArgv() {
+  const argv = arg_1({
+    '--yes': Boolean,
+    '-y': '--yes',
+    '--name': String,
+    '--directory': String,
+    '--entry': String,
+    '--install': Boolean,
+    '--no-install': Boolean,
+    '--monorepo': Boolean,
+    '--no-monorepo': Boolean,
+    '--package-manager': String,
+    '--extras': [String],
+    '--no-extras': Boolean,
+    '--react': Boolean,
+    '--no-react': Boolean,
+    '--help': Boolean,
+    '-h': '--help'
+  }, {
+    permissive: true
+  });
+  return argv;
+}
+async function getName(argv) {
+  let {
+    '--name': name
+  } = argv;
+  if (name == null) {
+    name = await prompt({
+      type: 'text',
+      message: 'What would you like to name your new module?',
+      initial: 'my-module'
+    });
+  }
+  return name;
+}
+async function getEntry(argv, {
+  name
+}) {
+  if (argv['--entry']) {
+    return argv['--entry'];
+  }
+  const entry = await prompt({
+    type: 'text',
+    message: 'What do you want to name your entry file?',
+    initial: `${toValidPackageName(name)}.ts`
+  });
+  return entry;
+}
+async function getDirectory(argv, {
+  name
+}) {
+  let directory = path.resolve(argv['--directory'] ?? toValidPackageName(name));
+  while (!argv['--yes']) {
+    if (fs.existsSync(directory) && !(await isEmpty(directory))) {
+      const relativeDirectory = path.relative(process.cwd(), directory);
+      const empty = await prompt({
+        type: 'confirm',
+        message: `Directory ${bold_1(relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
+        initial: true
+      });
+      if (empty) break;
+      const promptDirectory = await prompt({
+        type: 'text',
+        message: 'What directory do you want to create your new module in?'
+      });
+      directory = path.resolve(promptDirectory);
+    } else {
+      break;
+    }
+  }
+  return directory;
+}
+async function getReact(args) {
+  let useReact;
+  if (args['--react'] || args['--yes']) {
+    useReact = true;
+  } else if (args['--no-react']) {
+    useReact = false;
+  } else {
+    useReact = await prompt({
+      type: 'confirm',
+      message: 'Will this module depend on React?',
+      initial: false
+    });
+  }
+  return useReact;
+}
+function adjustPackageJson(packageJson, {
+  name,
+  entry,
+  react
+}) {
+  packageJson.name = name;
+  packageJson.main = `./${entry}`;
+  if (!react) {
+    delete packageJson.devDependencies['@types/react'];
+    delete packageJson.devDependencies['@types/react-dom'];
+    delete packageJson.devDependencies['preact'];
+    delete packageJson.devDependencies['react'];
+    delete packageJson.devDependencies['react-dom'];
+    packageJson.eslintConfig.extends = packageJson.eslintConfig.extends.filter(extend => !extend.includes('react'));
+  }
+  return packageJson;
+}
+
+export { createModule };

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/adapters/fs.esnext

@@ -0,0 +1,23 @@
+import { __exports as fs } from '../../../../../../../../_virtual/fs3.esnext';
+import fs__default from 'node:fs';
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs__default;
+	exports.FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    stat: fs.stat,
+	    lstatSync: fs.lstatSync,
+	    statSync: fs.statSync,
+	    readdir: fs.readdir,
+	    readdirSync: fs.readdirSync
+	};
+	function createFileSystemAdapter(fsMethods) {
+	    if (fsMethods === undefined) {
+	        return exports.FILE_SYSTEM_ADAPTER;
+	    }
+	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+	}
+	exports.createFileSystemAdapter = createFileSystemAdapter;
+} (fs));

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/constants.esnext

@@ -0,0 +1,19 @@
+import { __exports as constants } from '../../../../../../../_virtual/constants.esnext';
+export { __exports as default } from '../../../../../../../_virtual/constants.esnext';
+
+Object.defineProperty(constants, "__esModule", { value: true });
+constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+}
+const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext

@@ -0,0 +1,34 @@
+import { __exports as out } from '../../../../../../../_virtual/index10.esnext';
+export { __exports as default } from '../../../../../../../_virtual/index10.esnext';
+import './providers/async.esnext';
+import './providers/sync.esnext';
+import './settings.esnext';
+import { __exports as settings } from '../../../../../../../_virtual/settings4.esnext';
+import { __exports as async$1 } from '../../../../../../../_virtual/async5.esnext';
+import { __exports as sync$1 } from '../../../../../../../_virtual/sync6.esnext';
+
+Object.defineProperty(out, "__esModule", { value: true });
+out.Settings = out.scandirSync = out.scandir = void 0;
+const async = async$1;
+const sync = sync$1;
+const settings_1 = settings;
+out.Settings = settings_1.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        async.read(path, getSettings(), optionsOrSettingsOrCallback);
+        return;
+    }
+    async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+out.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    return sync.read(path, settings);
+}
+out.scandirSync = scandirSync;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/async.esnext

@@ -0,0 +1,115 @@
+import { __exports as async } from '../../../../../../../../_virtual/async5.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/async5.esnext';
+import '../../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import runParallel_1 from '../../../../../../run-parallel@1.2.0/node_modules/run-parallel/index.esnext';
+import '../constants.esnext';
+import '../utils/index.esnext';
+import './common.esnext';
+import { __exports as out } from '../../../../../../../../_virtual/index7.esnext';
+import { __exports as constants } from '../../../../../../../../_virtual/constants.esnext';
+import { __exports as utils$1 } from '../../../../../../../../_virtual/index11.esnext';
+import { __exports as common$1 } from '../../../../../../../../_virtual/common2.esnext';
+
+Object.defineProperty(async, "__esModule", { value: true });
+async.readdir = async.readdirWithFileTypes = async.read = void 0;
+const fsStat = out;
+const rpl = runParallel_1;
+const constants_1 = constants;
+const utils = utils$1;
+const common = common$1;
+function read(directory, settings, callback) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        readdirWithFileTypes(directory, settings, callback);
+        return;
+    }
+    readdir(directory, settings, callback);
+}
+async.read = read;
+function readdirWithFileTypes(directory, settings, callback) {
+    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+            callFailureCallback(callback, readdirError);
+            return;
+        }
+        const entries = dirents.map((dirent) => ({
+            dirent,
+            name: dirent.name,
+            path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        }));
+        if (!settings.followSymbolicLinks) {
+            callSuccessCallback(callback, entries);
+            return;
+        }
+        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+            if (rplError !== null) {
+                callFailureCallback(callback, rplError);
+                return;
+            }
+            callSuccessCallback(callback, rplEntries);
+        });
+    });
+}
+async.readdirWithFileTypes = readdirWithFileTypes;
+function makeRplTaskEntry(entry, settings) {
+    return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+            done(null, entry);
+            return;
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    done(statError);
+                    return;
+                }
+                done(null, entry);
+                return;
+            }
+            entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+            done(null, entry);
+        });
+    };
+}
+function readdir(directory, settings, callback) {
+    settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+            callFailureCallback(callback, readdirError);
+            return;
+        }
+        const tasks = names.map((name) => {
+            const path = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+            return (done) => {
+                fsStat.stat(path, settings.fsStatSettings, (error, stats) => {
+                    if (error !== null) {
+                        done(error);
+                        return;
+                    }
+                    const entry = {
+                        name,
+                        path,
+                        dirent: utils.fs.createDirentFromStats(name, stats)
+                    };
+                    if (settings.stats) {
+                        entry.stats = stats;
+                    }
+                    done(null, entry);
+                });
+            };
+        });
+        rpl(tasks, (rplError, entries) => {
+            if (rplError !== null) {
+                callFailureCallback(callback, rplError);
+                return;
+            }
+            callSuccessCallback(callback, entries);
+        });
+    });
+}
+async.readdir = readdir;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, result) {
+    callback(null, result);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/common.esnext

@@ -0,0 +1,15 @@
+import { __exports as common } from '../../../../../../../../_virtual/common2.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/common2.esnext';
+
+Object.defineProperty(common, "__esModule", { value: true });
+common.joinPathSegments = void 0;
+function joinPathSegments(a, b, separator) {
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+common.joinPathSegments = joinPathSegments;