@quilted/create 0.1.56 → 0.1.58

package/build/cjs/module.cjs

@@ -2,14 +2,29 @@
 
 var fs = require('node:fs');
 var path = require('node:path');
-var index$1 = require('./index2.cjs');
+var index$1 = require('./node_modules/.pnpm/arg@5.0.1/node_modules/arg/index.cjs');
+var index = require('./node_modules/.pnpm/colorette@2.0.16/node_modules/colorette/index.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.cjs');
+var stripIndent = require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.cjs');
+require('./node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.cjs');
+var help = require('./help.cjs');
+var shared = require('./shared.cjs');
+var prompts = require('./shared/prompts.cjs');
+var tsconfig = require('./shared/tsconfig.cjs');
 var packageManager = require('./shared/package-manager.cjs');
-var index = require('./index.cjs');
-require('node:tty');
-require('node:child_process');
-require('node:url');
-require('node:readline');
-require('node:events');
+var prompt = require('./packages/cli-kit/source/prompt.cjs');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -34,13 +49,13 @@ var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 async function createModule() {
   const argv = getArgv();
   if (argv['--help']) {
-    index.printHelp({
+    help.printHelp({
       kind: 'module',
       packageManager: argv['--package-manager']?.toLowerCase()
     });
     return;
   }
-  const inWorkspace = await packageManager.getInWorkspace(argv);
+  const inWorkspace = await prompts.getInWorkspace(argv);
   const name = await getName(argv);
   const directory = await getDirectory(argv, {
     name
@@ -49,23 +64,23 @@ async function createModule() {
     name
   });
   const useReact = await getReact(argv);
-  const createAsMonorepo = !inWorkspace && (await packageManager.getCreateAsMonorepo(argv, {
+  const createAsMonorepo = !inWorkspace && (await prompts.getCreateAsMonorepo(argv, {
     type: 'module',
     default: false
   }));
-  const setupExtras = await packageManager.getExtrasToSetup(argv, {
+  const setupExtras = await prompts.getExtrasToSetup(argv, {
     inWorkspace
   });
-  const shouldInstall = await packageManager.getShouldInstall(argv, {
+  const shouldInstall = await prompts.getShouldInstall(argv, {
     type: 'module'
   });
-  const packageManager$1 = await packageManager.getPackageManager(argv, {
+  const packageManager$1 = await prompts.getPackageManager(argv, {
     root: directory
   });
   const partOfMonorepo = inWorkspace || createAsMonorepo;
   const moduleDirectory = createAsMonorepo ? path__namespace.join(directory, 'app') : directory;
   if (fs__namespace.existsSync(directory)) {
-    await packageManager.emptyDirectory(directory);
+    await shared.emptyDirectory(directory);
     if (moduleDirectory !== directory) {
       fs__namespace.mkdirSync(moduleDirectory, {
         recursive: true
@@ -77,9 +92,9 @@ async function createModule() {
     });
   }
   const rootDirectory = inWorkspace ? process.cwd() : directory;
-  const outputRoot = packageManager.createOutputTarget(rootDirectory);
-  const moduleTemplate = packageManager.loadTemplate('module');
-  const workspaceTemplate = packageManager.loadTemplate('workspace');
+  const outputRoot = shared.createOutputTarget(rootDirectory);
+  const moduleTemplate = shared.loadTemplate('module');
+  const workspaceTemplate = shared.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.
@@ -96,12 +111,12 @@ async function createModule() {
     // If we are creating a monorepo, we need to add the root package.json and
     // package manager workspace configuration.
     if (createAsMonorepo) {
-      const moduleRelativeToRoot = packageManager.relativeDirectoryForDisplay(path__namespace.relative(directory, moduleDirectory));
+      const moduleRelativeToRoot = shared.relativeDirectoryForDisplay(path__namespace.relative(directory, moduleDirectory));
       const workspacePackageJson = JSON.parse(await workspaceTemplate.read('package.json'));
-      workspacePackageJson.name = packageManager.toValidPackageName(name);
+      workspacePackageJson.name = shared.toValidPackageName(name);
       workspacePackageJson.workspaces = [moduleRelativeToRoot, './packages/*'];
       if (packageManager$1.type === 'pnpm') {
-        await outputRoot.write('pnpm-workspace.yaml', await packageManager.format(`
+        await outputRoot.write('pnpm-workspace.yaml', await shared.format(`
               packages:
               - '${moduleRelativeToRoot}'
               - './packages/*'
@@ -109,12 +124,12 @@ async function createModule() {
           as: 'yaml'
         }));
       }
-      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(workspacePackageJson), {
+      await outputRoot.write('package.json', await shared.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 = packageManager.mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson);
+      const combinedPackageJson = shared.mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson);
       adjustPackageJson(combinedPackageJson, {
         name,
         entry,
@@ -126,21 +141,21 @@ async function createModule() {
       if (!useReact) {
         quiltProject = quiltProject.replace('quiltPackage()', 'quiltPackage({react: false})');
       }
-      await outputRoot.write('quilt.project.ts', await packageManager.format(quiltProject, {
+      await outputRoot.write('quilt.project.ts', await shared.format(quiltProject, {
         as: 'typescript'
       }));
-      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(combinedPackageJson), {
+      await outputRoot.write('package.json', await shared.format(JSON.stringify(combinedPackageJson), {
         as: 'json-stringify'
       }));
-      await outputRoot.write('tsconfig.json', await packageManager.format(JSON.stringify(projectTSConfig), {
+      await outputRoot.write('tsconfig.json', await shared.format(JSON.stringify(projectTSConfig), {
         as: 'json'
       }));
     }
     if (setupExtras.has('github')) {
-      await packageManager.loadTemplate('github').copy(directory);
+      await shared.loadTemplate('github').copy(directory);
     }
     if (setupExtras.has('vscode')) {
-      await packageManager.loadTemplate('vscode').copy(directory);
+      await shared.loadTemplate('vscode').copy(directory);
     }
   }
   await moduleTemplate.copy(moduleDirectory, file => {
@@ -166,10 +181,10 @@ async function createModule() {
       entry,
       react: useReact
     });
-    await outputRoot.write(path__namespace.join(moduleDirectory, 'package.json'), await packageManager.format(JSON.stringify(projectPackageJson), {
+    await outputRoot.write(path__namespace.join(moduleDirectory, 'package.json'), await shared.format(JSON.stringify(projectPackageJson), {
       as: 'json-stringify'
     }));
-    await Promise.all([packageManager.addToTsConfig(moduleDirectory, outputRoot), packageManager.addToPackageManagerWorkspaces(moduleDirectory, outputRoot, packageManager$1.type)]);
+    await Promise.all([tsconfig.addToTsConfig(moduleDirectory, outputRoot), packageManager.addToPackageManagerWorkspaces(moduleDirectory, outputRoot, packageManager$1.type)]);
   }
   if (shouldInstall) {
     console.log();
@@ -178,16 +193,16 @@ async function createModule() {
   }
   const commands = [];
   if (!inWorkspace && directory !== process.cwd()) {
-    commands.push(`cd ${packageManager.cyan_1(packageManager.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory)))} ${packageManager.dim_1('# Move into your new module’s directory')}`);
+    commands.push(`cd ${index.cyan(shared.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory)))} ${index.dim('# Move into your new module’s directory')}`);
   }
   if (!shouldInstall) {
-    commands.push(`${packageManager$1.commands.install()} ${packageManager.dim_1('# Install all your dependencies')}`);
+    commands.push(`${packageManager$1.commands.install()} ${index.dim('# Install all your dependencies')}`);
   }
   if (commands.length === 0) {
     console.log();
     console.log('Your new module is ready to go!');
   } else {
-    const whatsNext = index.stripIndent`
+    const whatsNext = stripIndent["default"]`
       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:
     `;
@@ -196,10 +211,10 @@ async function createModule() {
     console.log();
     console.log(commands.map(command => `  ${command}`).join('\n'));
   }
-  const followUp = index.stripIndent`
+  const followUp = stripIndent["default"]`
     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:
-    ${packageManager.underline_1(packageManager.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation'))}
+    ${index.underline(index.magenta('https://github.com/lemonmade/quilt/tree/main/documentation'))}
 
     Have fun! 🎉
   `;
@@ -210,7 +225,7 @@ async function createModule() {
 // Argument handling
 
 function getArgv() {
-  const argv = index$1.arg_1({
+  const argv = index$1["default"]({
     '--yes': Boolean,
     '-y': '--yes',
     '--name': String,
@@ -237,7 +252,7 @@ async function getName(argv) {
     '--name': name
   } = argv;
   if (name == null) {
-    name = await index.prompt({
+    name = await prompt.prompt({
       type: 'text',
       message: 'What would you like to name your new module?',
       initial: 'my-module'
@@ -251,27 +266,27 @@ async function getEntry(argv, {
   if (argv['--entry']) {
     return argv['--entry'];
   }
-  const entry = await index.prompt({
+  const entry = await prompt.prompt({
     type: 'text',
     message: 'What do you want to name your entry file?',
-    initial: `${packageManager.toValidPackageName(name)}.ts`
+    initial: `${shared.toValidPackageName(name)}.ts`
   });
   return entry;
 }
 async function getDirectory(argv, {
   name
 }) {
-  let directory = path__namespace.resolve(argv['--directory'] ?? packageManager.toValidPackageName(name));
+  let directory = path__namespace.resolve(argv['--directory'] ?? shared.toValidPackageName(name));
   while (!argv['--yes']) {
-    if (fs__namespace.existsSync(directory) && !(await packageManager.isEmpty(directory))) {
+    if (fs__namespace.existsSync(directory) && !(await shared.isEmpty(directory))) {
       const relativeDirectory = path__namespace.relative(process.cwd(), directory);
-      const empty = await index.prompt({
+      const empty = await prompt.prompt({
         type: 'confirm',
-        message: `Directory ${packageManager.bold_1(packageManager.relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
+        message: `Directory ${index.bold(shared.relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
         initial: true
       });
       if (empty) break;
-      const promptDirectory = await index.prompt({
+      const promptDirectory = await prompt.prompt({
         type: 'text',
         message: 'What directory do you want to create your new module in?'
       });
@@ -289,7 +304,7 @@ async function getReact(args) {
   } else if (args['--no-react']) {
     useReact = false;
   } else {
-    useReact = await index.prompt({
+    useReact = await prompt.prompt({
       type: 'confirm',
       message: 'Will this module depend on React?',
       initial: false

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

@@ -0,0 +1,25 @@
+'use strict';
+
+var fs = require('../../../../../../../../_virtual/fs3.cjs');
+var fs$1 = require('node:fs');
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs$1;
+	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.__exports));

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

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../../../../../../../_virtual/constants.cjs');
+
+Object.defineProperty(constants.__exports, "__esModule", { value: true });
+constants.__exports.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.__exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
+
+exports["default"] = constants.__exports;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../../../../../_virtual/index10.cjs');
+require('./providers/async.cjs');
+require('./providers/sync.cjs');
+require('./settings.cjs');
+var settings = require('../../../../../../../_virtual/settings4.cjs');
+var async$1 = require('../../../../../../../_virtual/async5.cjs');
+var sync$1 = require('../../../../../../../_virtual/sync6.cjs');
+
+Object.defineProperty(index.__exports, "__esModule", { value: true });
+index.__exports.Settings = index.__exports.scandirSync = index.__exports.scandir = void 0;
+const async = async$1.__exports;
+const sync = sync$1.__exports;
+const settings_1 = settings.__exports;
+index.__exports.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);
+}
+index.__exports.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    return sync.read(path, settings);
+}
+index.__exports.scandirSync = scandirSync;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}
+
+exports["default"] = index.__exports;

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

@@ -0,0 +1,120 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var async = require('../../../../../../../../_virtual/async5.cjs');
+require('../../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.cjs');
+var index$1 = require('../../../../../../run-parallel@1.2.0/node_modules/run-parallel/index.cjs');
+require('../constants.cjs');
+require('../utils/index.cjs');
+require('./common.cjs');
+var index = require('../../../../../../../../_virtual/index7.cjs');
+var constants = require('../../../../../../../../_virtual/constants.cjs');
+var index$2 = require('../../../../../../../../_virtual/index11.cjs');
+var common$1 = require('../../../../../../../../_virtual/common2.cjs');
+
+Object.defineProperty(async.__exports, "__esModule", { value: true });
+async.__exports.readdir = async.__exports.readdirWithFileTypes = async.__exports.read = void 0;
+const fsStat = index.__exports;
+const rpl = index$1["default"];
+const constants_1 = constants.__exports;
+const utils = index$2.__exports;
+const common = common$1.__exports;
+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.__exports.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.__exports.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.__exports.readdir = readdir;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, result) {
+    callback(null, result);
+}
+
+exports["default"] = async.__exports;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('../../../../../../../../_virtual/common2.cjs');
+
+Object.defineProperty(common.__exports, "__esModule", { value: true });
+common.__exports.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.__exports.joinPathSegments = joinPathSegments;
+
+exports["default"] = common.__exports;

package/build/cjs/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sync = require('../../../../../../../../_virtual/sync6.cjs');
+require('../../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.cjs');
+require('../constants.cjs');
+require('../utils/index.cjs');
+require('./common.cjs');
+var index = require('../../../../../../../../_virtual/index7.cjs');
+var constants = require('../../../../../../../../_virtual/constants.cjs');
+var index$1 = require('../../../../../../../../_virtual/index11.cjs');
+var common$1 = require('../../../../../../../../_virtual/common2.cjs');
+
+Object.defineProperty(sync.__exports, "__esModule", { value: true });
+sync.__exports.readdir = sync.__exports.readdirWithFileTypes = sync.__exports.read = void 0;
+const fsStat = index.__exports;
+const constants_1 = constants.__exports;
+const utils = index$1.__exports;
+const common = common$1.__exports;
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir(directory, settings);
+}
+sync.__exports.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+sync.__exports.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+        const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
+sync.__exports.readdir = readdir;
+
+exports["default"] = sync.__exports;

package/build/cjs/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var settings = require('../../../../../../../_virtual/settings4.cjs');
+var path$1 = require('node:path');
+require('../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.cjs');
+require('./adapters/fs.cjs');
+var index = require('../../../../../../../_virtual/index7.cjs');
+var fs$1 = require('../../../../../../../_virtual/fs3.cjs');
+
+Object.defineProperty(settings.__exports, "__esModule", { value: true });
+const path = path$1;
+const fsStat = index.__exports;
+const fs = fs$1.__exports;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+settings.__exports.default = Settings;

package/build/cjs/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('../../../../../../../../_virtual/fs4.cjs');
+
+Object.defineProperty(fs.__exports, "__esModule", { value: true });
+fs.__exports.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+fs.__exports.createDirentFromStats = createDirentFromStats;
+
+exports["default"] = fs.__exports;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../../../../../../_virtual/index11.cjs');
+require('./fs.cjs');
+var fs$1 = require('../../../../../../../../_virtual/fs4.cjs');
+
+Object.defineProperty(index.__exports, "__esModule", { value: true });
+index.__exports.fs = void 0;
+const fs = fs$1.__exports;
+index.__exports.fs = fs;
+
+exports["default"] = index.__exports;

package/build/cjs/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var fs = require('../../../../../../../../_virtual/fs2.cjs');
+var fs$1 = require('node:fs');
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs$1;
+	exports.FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    stat: fs.stat,
+	    lstatSync: fs.lstatSync,
+	    statSync: fs.statSync
+	};
+	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.__exports));