create-docusaurus 2.0.0-beta.9 → 2.0.1

package/lib/index.js

@@ -1,235 +1,427 @@
-"use strict";
 /**
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
-const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
-const child_process_1 = require("child_process");
-const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
-const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const shelljs_1 = (0, tslib_1.__importDefault)(require("shelljs"));
-const lodash_1 = require("lodash");
-const supports_color_1 = (0, tslib_1.__importDefault)(require("supports-color"));
-const RecommendedTemplate = 'classic';
-const TypeScriptTemplateSuffix = '-typescript';
-function hasYarn() {
-    try {
-        (0, child_process_1.execSync)('yarnpkg --version', { stdio: 'ignore' });
-        return true;
-    }
-    catch (e) {
-        return false;
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import _ from 'lodash';
+import logger from '@docusaurus/logger';
+import shell from 'shelljs';
+import prompts from 'prompts';
+import supportsColor from 'supports-color';
+import { escapeShellArg } from '@docusaurus/utils';
+// Only used in the rare, rare case of running globally installed create +
+// using --skip-install. We need a default name to show the tip text
+const defaultPackageManager = 'npm';
+const lockfileNames = {
+    npm: 'package-lock.json',
+    yarn: 'yarn.lock',
+    pnpm: 'pnpm-lock.yaml',
+};
+const packageManagers = Object.keys(lockfileNames);
+async function findPackageManagerFromLockFile(rootDir) {
+    for (const packageManager of packageManagers) {
+        const lockFilePath = path.join(rootDir, lockfileNames[packageManager]);
+        if (await fs.pathExists(lockFilePath)) {
+            return packageManager;
+        }
     }
+    return undefined;
 }
-function isValidGitRepoUrl(gitRepoUrl) {
-    return ['https://', 'git@'].some((item) => gitRepoUrl.startsWith(item));
+function findPackageManagerFromUserAgent() {
+    return packageManagers.find((packageManager) => process.env.npm_config_user_agent?.startsWith(packageManager));
 }
-async function updatePkg(pkgPath, obj) {
-    const content = await fs_extra_1.default.readFile(pkgPath, 'utf-8');
-    const pkg = JSON.parse(content);
-    const newPkg = Object.assign(pkg, obj);
-    await fs_extra_1.default.outputFile(pkgPath, JSON.stringify(newPkg, null, 2));
+async function askForPackageManagerChoice() {
+    const hasYarn = shell.exec('yarn --version', { silent: true }).code === 0;
+    const hasPnpm = shell.exec('pnpm --version', { silent: true }).code === 0;
+    if (!hasYarn && !hasPnpm) {
+        return 'npm';
+    }
+    const choices = ['npm', hasYarn && 'yarn', hasPnpm && 'pnpm']
+        .filter((p) => Boolean(p))
+        .map((p) => ({ title: p, value: p }));
+    return ((await prompts({
+        type: 'select',
+        name: 'packageManager',
+        message: 'Select a package manager...',
+        choices,
+    }, {
+        onCancel() {
+            logger.info `Falling back to name=${defaultPackageManager}`;
+        },
+    })).packageManager ?? defaultPackageManager);
 }
-function readTemplates(templatesDir) {
-    const templates = fs_extra_1.default
-        .readdirSync(templatesDir)
+async function getPackageManager(dest, { packageManager, skipInstall }) {
+    if (packageManager && !packageManagers.includes(packageManager)) {
+        throw new Error(`Invalid package manager choice ${packageManager}. Must be one of ${packageManagers.join(', ')}`);
+    }
+    return (
+    // If dest already contains a lockfile (e.g. if using a local template), we
+    // always use that instead
+    (await findPackageManagerFromLockFile(dest)) ??
+        packageManager ??
+        (await findPackageManagerFromLockFile('.')) ??
+        findPackageManagerFromUserAgent() ??
+        // This only happens if the user has a global installation in PATH
+        (skipInstall ? defaultPackageManager : askForPackageManagerChoice()));
+}
+const recommendedTemplate = 'classic';
+const typeScriptTemplateSuffix = '-typescript';
+const templatesDir = fileURLToPath(new URL('../templates', import.meta.url));
+async function readTemplates() {
+    const dirContents = await fs.readdir(templatesDir);
+    const templates = await Promise.all(dirContents
         .filter((d) => !d.startsWith('.') &&
         !d.startsWith('README') &&
-        !d.endsWith(TypeScriptTemplateSuffix) &&
-        d !== 'shared');
+        !d.endsWith(typeScriptTemplateSuffix) &&
+        d !== 'shared')
+        .map(async (name) => {
+        const tsVariantPath = path.join(templatesDir, `${name}${typeScriptTemplateSuffix}`);
+        return {
+            name,
+            path: path.join(templatesDir, name),
+            tsVariantPath: (await fs.pathExists(tsVariantPath))
+                ? tsVariantPath
+                : undefined,
+        };
+    }));
     // Classic should be first in list!
-    return (0, lodash_1.sortBy)(templates, (t) => t !== RecommendedTemplate);
+    return _.sortBy(templates, (t) => t.name !== recommendedTemplate);
+}
+async function copyTemplate(template, dest, typescript) {
+    await fs.copy(path.join(templatesDir, 'shared'), dest);
+    // TypeScript variants will copy duplicate resources like CSS & config from
+    // base template
+    if (typescript) {
+        await fs.copy(template.path, dest, {
+            filter: async (filePath) => (await fs.stat(filePath)).isDirectory() ||
+                path.extname(filePath) === '.css' ||
+                path.basename(filePath) === 'docusaurus.config.js',
+        });
+    }
+    await fs.copy(typescript ? template.tsVariantPath : template.path, dest, {
+        // Symlinks don't exist in published npm packages anymore, so this is only
+        // to prevent errors during local testing
+        filter: async (filePath) => !(await fs.lstat(filePath)).isSymbolicLink(),
+    });
 }
 function createTemplateChoices(templates) {
     function makeNameAndValueChoice(value) {
-        const title = value === RecommendedTemplate ? `${value} (recommended)` : value;
+        if (typeof value === 'string') {
+            return { title: value, value };
+        }
+        const title = value.name === recommendedTemplate
+            ? `${value.name} (recommended)`
+            : value.name;
         return { title, value };
     }
     return [
         ...templates.map((template) => makeNameAndValueChoice(template)),
         makeNameAndValueChoice('Git repository'),
+        makeNameAndValueChoice('Local template'),
     ];
 }
-function getTypeScriptBaseTemplate(template) {
-    if (template.endsWith(TypeScriptTemplateSuffix)) {
-        return template.replace(TypeScriptTemplateSuffix, '');
-    }
-    return undefined;
+function isValidGitRepoUrl(gitRepoUrl) {
+    return ['https://', 'git@'].some((item) => gitRepoUrl.startsWith(item));
 }
-async function copyTemplate(templatesDir, template, dest) {
-    await fs_extra_1.default.copy(path_1.default.resolve(templatesDir, 'shared'), dest);
-    // TypeScript variants will copy duplicate resources like CSS & config from base template
-    const tsBaseTemplate = getTypeScriptBaseTemplate(template);
-    if (tsBaseTemplate) {
-        const tsBaseTemplatePath = path_1.default.resolve(templatesDir, tsBaseTemplate);
-        await fs_extra_1.default.copy(tsBaseTemplatePath, dest, {
-            filter: (filePath) => fs_extra_1.default.statSync(filePath).isDirectory() ||
-                path_1.default.extname(filePath) === '.css' ||
-                path_1.default.basename(filePath) === 'docusaurus.config.js',
-        });
+const gitStrategies = ['deep', 'shallow', 'copy', 'custom'];
+async function getGitCommand(gitStrategy) {
+    switch (gitStrategy) {
+        case 'shallow':
+        case 'copy':
+            return 'git clone --recursive --depth 1';
+        case 'custom': {
+            const { command } = (await prompts({
+                type: 'text',
+                name: 'command',
+                message: 'Write your own git clone command. The repository URL and destination directory will be supplied. E.g. "git clone --depth 10"',
+            }, {
+                onCancel() {
+                    logger.info `Falling back to code=${'git clone'}`;
+                },
+            }));
+            return command ?? 'git clone';
+        }
+        case 'deep':
+        default:
+            return 'git clone';
     }
-    await fs_extra_1.default.copy(path_1.default.resolve(templatesDir, template), dest, {
-        // Symlinks don't exist in published NPM packages anymore, so this is only to prevent errors during local testing
-        filter: (filePath) => !fs_extra_1.default.lstatSync(filePath).isSymbolicLink(),
-    });
 }
-async function init(rootDir, siteName, reqTemplate, cliOptions = {}) {
-    const useYarn = cliOptions.useNpm ? false : hasYarn();
-    const templatesDir = path_1.default.resolve(__dirname, '../templates');
-    const templates = readTemplates(templatesDir);
-    const hasTS = (templateName) => fs_extra_1.default.pathExistsSync(path_1.default.resolve(templatesDir, `${templateName}${TypeScriptTemplateSuffix}`));
-    let name = siteName;
-    // Prompt if siteName is not passed from CLI.
-    if (!name) {
-        const prompt = await (0, prompts_1.default)({
-            type: 'text',
-            name: 'name',
-            message: 'What should we name this site?',
-            initial: 'website',
-        });
-        name = prompt.name;
+async function getSiteName(reqName, rootDir) {
+    async function validateSiteName(siteName) {
+        if (!siteName) {
+            return 'A website name is required.';
+        }
+        const dest = path.resolve(rootDir, siteName);
+        if (await fs.pathExists(dest)) {
+            return logger.interpolate `Directory already exists at path=${dest}!`;
+        }
+        return true;
     }
-    if (!name) {
-        throw new Error(chalk_1.default.red('A website name is required.'));
+    if (reqName) {
+        const res = validateSiteName(reqName);
+        if (typeof res === 'string') {
+            throw new Error(res);
+        }
+        return reqName;
     }
-    const dest = path_1.default.resolve(rootDir, name);
-    if (fs_extra_1.default.existsSync(dest)) {
-        throw new Error(`Directory already exists at "${dest}"!`);
+    const { siteName } = (await prompts({
+        type: 'text',
+        name: 'siteName',
+        message: 'What should we name this site?',
+        initial: 'website',
+        validate: validateSiteName,
+    }, {
+        onCancel() {
+            logger.error('A website name is required.');
+            process.exit(1);
+        },
+    }));
+    return siteName;
+}
+async function getSource(reqTemplate, templates, cliOptions) {
+    if (reqTemplate) {
+        if (isValidGitRepoUrl(reqTemplate)) {
+            if (cliOptions.gitStrategy &&
+                !gitStrategies.includes(cliOptions.gitStrategy)) {
+                logger.error `Invalid git strategy: name=${cliOptions.gitStrategy}. Value must be one of ${gitStrategies.join(', ')}.`;
+                process.exit(1);
+            }
+            return {
+                type: 'git',
+                url: reqTemplate,
+                strategy: cliOptions.gitStrategy ?? 'deep',
+            };
+        }
+        else if (await fs.pathExists(path.resolve(reqTemplate))) {
+            return {
+                type: 'local',
+                path: path.resolve(reqTemplate),
+            };
+        }
+        const template = templates.find((t) => t.name === reqTemplate);
+        if (!template) {
+            logger.error('Invalid template.');
+            process.exit(1);
+        }
+        if (cliOptions.typescript && !template.tsVariantPath) {
+            logger.error `Template name=${reqTemplate} doesn't provide the TypeScript variant.`;
+            process.exit(1);
+        }
+        return {
+            type: 'template',
+            template,
+            typescript: cliOptions.typescript ?? false,
+        };
     }
-    let template = reqTemplate;
-    let useTS = cliOptions.typescript;
-    // Prompt if template is not provided from CLI.
-    if (!template) {
-        const templatePrompt = await (0, prompts_1.default)({
+    const template = cliOptions.gitStrategy
+        ? 'Git repository'
+        : (await prompts({
             type: 'select',
             name: 'template',
             message: 'Select a template below...',
             choices: createTemplateChoices(templates),
-        });
-        template = templatePrompt.template;
-        if (template && !useTS && hasTS(template)) {
-            const tsPrompt = await (0, prompts_1.default)({
-                type: 'confirm',
-                name: 'useTS',
-                message: 'This template is available in TypeScript. Do you want to use the TS variant?',
-                initial: false,
-            });
-            useTS = tsPrompt.useTS;
-        }
-    }
-    // If user choose Git repository, we'll prompt for the url.
+        }, {
+            onCancel() {
+                logger.error('A choice is required.');
+                process.exit(1);
+            },
+        })).template;
     if (template === 'Git repository') {
-        const repoPrompt = await (0, prompts_1.default)({
+        const { gitRepoUrl } = (await prompts({
             type: 'text',
             name: 'gitRepoUrl',
             validate: (url) => {
                 if (url && isValidGitRepoUrl(url)) {
                     return true;
                 }
-                return chalk_1.default.red(`Invalid repository URL`);
+                return logger.red('Invalid repository URL');
             },
-            message: 'Enter a repository URL from GitHub, Bitbucket, GitLab, or any other public repo.\n(e.g: https://github.com/ownerName/repoName.git)',
-        });
-        template = repoPrompt.gitRepoUrl;
-    }
-    console.log(`
-${chalk_1.default.cyan('Creating new Docusaurus project...')}
-`);
-    if (template && isValidGitRepoUrl(template)) {
-        console.log(`Cloning Git template ${chalk_1.default.cyan(template)}...`);
-        if (shelljs_1.default.exec(`git clone --recursive ${template} ${dest}`, { silent: true })
-            .code !== 0) {
-            throw new Error(chalk_1.default.red(`Cloning Git template ${template} failed!`));
-        }
-    }
-    else if (template && templates.includes(template)) {
-        // Docusaurus templates.
-        if (useTS) {
-            if (!hasTS(template)) {
-                throw new Error(`Template ${template} doesn't provide the Typescript variant.`);
-            }
-            template = `${template}${TypeScriptTemplateSuffix}`;
+            message: logger.interpolate `Enter a repository URL from GitHub, Bitbucket, GitLab, or any other public repo.
+(e.g: url=${'https://github.com/ownerName/repoName.git'})`,
+        }, {
+            onCancel() {
+                logger.error('A git repo URL is required.');
+                process.exit(1);
+            },
+        }));
+        let strategy = cliOptions.gitStrategy;
+        if (!strategy) {
+            ({ strategy } = (await prompts({
+                type: 'select',
+                name: 'strategy',
+                message: 'How should we clone this repo?',
+                choices: [
+                    { title: 'Deep clone: preserve full history', value: 'deep' },
+                    { title: 'Shallow clone: clone with --depth=1', value: 'shallow' },
+                    {
+                        title: 'Copy: do a shallow clone, but do not create a git repo',
+                        value: 'copy',
+                    },
+                    {
+                        title: 'Custom: enter your custom git clone command',
+                        value: 'custom',
+                    },
+                ],
+            }, {
+                onCancel() {
+                    logger.info `Falling back to name=${'deep'}`;
+                },
+            })));
+        }
+        return {
+            type: 'git',
+            url: gitRepoUrl,
+            strategy: strategy ?? 'deep',
+        };
+    }
+    else if (template === 'Local template') {
+        const { templateDir } = (await prompts({
+            type: 'text',
+            name: 'templateDir',
+            validate: async (dir) => {
+                if (dir) {
+                    const fullDir = path.resolve(dir);
+                    if (await fs.pathExists(fullDir)) {
+                        return true;
+                    }
+                    return logger.red(logger.interpolate `path=${fullDir} does not exist.`);
+                }
+                return logger.red('Please enter a valid path.');
+            },
+            message: 'Enter a local folder path, relative to the current working directory.',
+        }, {
+            onCancel() {
+                logger.error('A file path is required.');
+                process.exit(1);
+            },
+        }));
+        return {
+            type: 'local',
+            path: templateDir,
+        };
+    }
+    let useTS = cliOptions.typescript;
+    if (!useTS && template.tsVariantPath) {
+        ({ useTS } = (await prompts({
+            type: 'confirm',
+            name: 'useTS',
+            message: 'This template is available in TypeScript. Do you want to use the TS variant?',
+            initial: false,
+        })));
+    }
+    return {
+        type: 'template',
+        template,
+        typescript: useTS ?? false,
+    };
+}
+async function updatePkg(pkgPath, obj) {
+    const pkg = (await fs.readJSON(pkgPath));
+    const newPkg = Object.assign(pkg, obj);
+    await fs.outputFile(pkgPath, `${JSON.stringify(newPkg, null, 2)}\n`);
+}
+export default async function init(rootDir, reqName, reqTemplate, cliOptions = {}) {
+    const templates = await readTemplates();
+    const siteName = await getSiteName(reqName, rootDir);
+    const dest = path.resolve(rootDir, siteName);
+    const source = await getSource(reqTemplate, templates, cliOptions);
+    logger.info('Creating new Docusaurus project...');
+    if (source.type === 'git') {
+        const gitCommand = await getGitCommand(source.strategy);
+        const gitCloneCommand = `${gitCommand} ${escapeShellArg(source.url)} ${escapeShellArg(dest)}`;
+        if (shell.exec(gitCloneCommand).code !== 0) {
+            logger.error `Cloning Git template failed!`;
+            process.exit(1);
+        }
+        if (source.strategy === 'copy') {
+            await fs.remove(path.join(dest, '.git'));
         }
+    }
+    else if (source.type === 'template') {
         try {
-            await copyTemplate(templatesDir, template, dest);
+            await copyTemplate(source.template, dest, source.typescript);
         }
         catch (err) {
-            console.log(`Copying Docusaurus template ${chalk_1.default.cyan(template)} failed!`);
+            logger.error `Copying Docusaurus template name=${source.template.name} failed!`;
             throw err;
         }
     }
     else {
-        throw new Error('Invalid template.');
+        try {
+            await fs.copy(source.path, dest);
+        }
+        catch (err) {
+            logger.error `Copying local template path=${source.path} failed!`;
+            throw err;
+        }
     }
     // Update package.json info.
     try {
-        await updatePkg(path_1.default.join(dest, 'package.json'), {
-            name: (0, lodash_1.kebabCase)(name),
+        await updatePkg(path.join(dest, 'package.json'), {
+            name: _.kebabCase(siteName),
             version: '0.0.0',
             private: true,
         });
     }
     catch (err) {
-        console.log(chalk_1.default.red('Failed to update package.json.'));
+        logger.error('Failed to update package.json.');
         throw err;
     }
     // We need to rename the gitignore file to .gitignore
-    if (!fs_extra_1.default.pathExistsSync(path_1.default.join(dest, '.gitignore')) &&
-        fs_extra_1.default.pathExistsSync(path_1.default.join(dest, 'gitignore'))) {
-        await fs_extra_1.default.move(path_1.default.join(dest, 'gitignore'), path_1.default.join(dest, '.gitignore'));
+    if (!(await fs.pathExists(path.join(dest, '.gitignore'))) &&
+        (await fs.pathExists(path.join(dest, 'gitignore')))) {
+        await fs.move(path.join(dest, 'gitignore'), path.join(dest, '.gitignore'));
     }
-    if (fs_extra_1.default.pathExistsSync(path_1.default.join(dest, 'gitignore'))) {
-        fs_extra_1.default.removeSync(path_1.default.join(dest, 'gitignore'));
+    if (await fs.pathExists(path.join(dest, 'gitignore'))) {
+        await fs.remove(path.join(dest, 'gitignore'));
     }
-    const pkgManager = useYarn ? 'yarn' : 'npm';
+    // Display the most elegant way to cd.
+    const cdpath = path.relative('.', dest);
+    const pkgManager = await getPackageManager(dest, cliOptions);
     if (!cliOptions.skipInstall) {
-        console.log(`Installing dependencies with ${chalk_1.default.cyan(pkgManager)}...`);
-        try {
-            // Use force coloring the output, since the command is invoked by shelljs, which is not the interactive shell
-            shelljs_1.default.exec(`cd "${name}" && ${useYarn ? 'yarn' : 'npm install --color always'}`, {
-                env: {
-                    ...process.env,
-                    ...(supports_color_1.default.stdout ? { FORCE_COLOR: '1' } : {}),
-                },
-            });
-        }
-        catch (err) {
-            console.log(chalk_1.default.red('Installation failed.'));
-            throw err;
+        shell.cd(dest);
+        logger.info `Installing dependencies with name=${pkgManager}...`;
+        if (shell.exec(pkgManager === 'yarn' ? 'yarn' : `${pkgManager} install --color always`, {
+            env: {
+                ...process.env,
+                // Force coloring the output, since the command is invoked by
+                // shelljs, which is not an interactive shell
+                ...(supportsColor.stdout ? { FORCE_COLOR: '1' } : {}),
+            },
+        }).code !== 0) {
+            logger.error('Dependency installation failed.');
+            logger.info `The site directory has already been created, and you can retry by typing:
+
+  code=${`cd ${cdpath}`}
+  code=${`${pkgManager} install`}`;
+            process.exit(0);
         }
     }
-    console.log();
-    // Display the most elegant way to cd.
-    const cdpath = path_1.default.join(process.cwd(), name) === dest
-        ? name
-        : path_1.default.relative(process.cwd(), name);
-    console.log(`
-Successfully created "${chalk_1.default.cyan(cdpath)}".
-Inside that directory, you can run several commands:
+    const useNpm = pkgManager === 'npm';
+    logger.success `Created name=${cdpath}.`;
+    logger.info `Inside that directory, you can run several commands:
 
-  ${chalk_1.default.cyan(`${pkgManager} start`)}
+  code=${`${pkgManager} start`}
     Starts the development server.
 
-  ${chalk_1.default.cyan(`${pkgManager} ${useYarn ? '' : 'run '}build`)}
+  code=${`${pkgManager} ${useNpm ? 'run ' : ''}build`}
     Bundles your website into static files for production.
 
-  ${chalk_1.default.cyan(`${pkgManager} ${useYarn ? '' : 'run '}serve`)}
+  code=${`${pkgManager} ${useNpm ? 'run ' : ''}serve`}
     Serves the built website locally.
 
-  ${chalk_1.default.cyan(`${pkgManager} deploy`)}
+  code=${`${pkgManager} deploy`}
     Publishes the website to GitHub pages.
 
 We recommend that you begin by typing:
 
-  ${chalk_1.default.cyan('cd')} ${cdpath}
-  ${chalk_1.default.cyan(`${pkgManager} start`)}
+  code=${`cd ${cdpath}`}
+  code=${`${pkgManager} start`}
 
 Happy building awesome websites!
-`);
+`;
 }
-exports.default = init;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "create-docusaurus",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.1",
   "description": "Create Docusaurus apps easily.",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/docusaurus.git",
@@ -12,32 +13,31 @@
   },
   "scripts": {
     "create-docusaurus": "create-docusaurus",
-    "build": "tsc",
-    "watch": "tsc --watch"
-  },
-  "bin": {
-    "create-docusaurus": "bin/index.js"
+    "build": "tsc --build",
+    "watch": "tsc --build --watch"
   },
+  "bin": "bin/index.js",
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
   "dependencies": {
-    "chalk": "^4.1.2",
+    "@docusaurus/logger": "2.0.1",
+    "@docusaurus/utils": "2.0.1",
     "commander": "^5.1.0",
-    "fs-extra": "^10.0.0",
-    "lodash": "^4.17.20",
-    "prompts": "^2.4.1",
-    "semver": "^7.3.4",
-    "shelljs": "^0.8.4",
-    "supports-color": "^8.1.1",
-    "tslib": "^2.3.1"
-  },
-  "engines": {
-    "node": ">=14"
+    "fs-extra": "^10.1.0",
+    "lodash": "^4.17.21",
+    "prompts": "^2.4.2",
+    "semver": "^7.3.7",
+    "shelljs": "^0.8.5",
+    "supports-color": "^9.2.2",
+    "tslib": "^2.4.0"
   },
   "devDependencies": {
     "@types/supports-color": "^8.1.1"
   },
-  "gitHead": "8a491fc29ad002f90e97f5b5fe4178ac8fa0c4d7"
+  "engines": {
+    "node": ">=16.14"
+  },
+  "gitHead": "1ddee1c29cabf9bb52e4d78af6ebfaaabb1bc1f9"
 }