@form8ion/javascript 6.0.9 → 6.1.0-alpha.3

package/lib/index.mjs

@@ -8,7 +8,7 @@ import { promises } from 'fs';
 import { fileExists, applyEnhancers, fileTypes } from '@form8ion/core';
 import { info, error, warn } from '@travi/cli-messages';
 import * as commitConventionPlugin from '@form8ion/commit-convention';
-import { scaffold as scaffold$4 } from '@form8ion/commit-convention';
+import { scaffold as scaffold$5 } from '@form8ion/commit-convention';
 import hoek from '@hapi/hoek';
 import execa from '@form8ion/execa-wrapper';
 import npmConf from 'npm-conf';
@@ -25,49 +25,9 @@ import filedirname from 'filedirname';
 import * as huskyPlugin from '@form8ion/husky';
 import { scaffold as scaffold$2 } from '@form8ion/husky';
 import { write } from '@form8ion/config-file';
+import { scaffold as scaffold$4 } from '@form8ion/prettier';
 import { lift as lift$4, scaffold as scaffold$3 } from '@form8ion/eslint';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  return target;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
 const questionNames$1 = {
   UNIT_TEST_FRAMEWORK: 'unitTestFramework',
   NODE_VERSION_CATEGORY: 'nodeVersionCategory',
@@ -85,113 +45,74 @@ const questionNames$1 = {
   DIALECT: 'dialect'
 };
 
-async function scaffoldC8 ({
-  projectRoot
-}) {
-  await promises.writeFile(`${projectRoot}/.c8rc.json`, JSON.stringify({
-    reporter: ['lcov', 'text-summary', 'html'],
-    exclude: ['src/**/*-test.js', 'test/', 'thirdparty-wrappers/', 'vendor/']
-  }));
+async function scaffoldC8 ({projectRoot}) {
+  await promises.writeFile(
+    `${projectRoot}/.c8rc.json`,
+    JSON.stringify({
+      reporter: ['lcov', 'text-summary', 'html'],
+      exclude: ['src/**/*-test.js', 'test/', 'thirdparty-wrappers/', 'vendor/']
+    })
+  );
+
   return {
     devDependencies: ['cross-env', 'c8'],
-    vcsIgnore: {
-      files: [],
-      directories: ['/coverage/']
-    },
-    eslint: {
-      ignore: {
-        directories: ['/coverage/']
-      }
-    }
+    vcsIgnore: {files: [], directories: ['/coverage/']},
+    eslint: {ignore: {directories: ['/coverage/']}}
   };
 }
 
-async function scaffoldCoverage ({
-  projectRoot,
-  vcs,
-  visibility,
-  pathWithinParent
-}) {
-  return deepmerge(await scaffoldC8({
-    projectRoot
-  }), await scaffold({
-    vcs,
-    visibility,
-    pathWithinParent
-  }));
+async function scaffoldCoverage ({projectRoot, vcs, visibility, pathWithinParent}) {
+  return deepmerge(await scaffoldC8({projectRoot}), await scaffold({vcs, visibility, pathWithinParent}));
 }
 
-function nycIsConfigured ({
-  projectRoot
-}) {
+function nycIsConfigured ({projectRoot}) {
   return fileExists(`${projectRoot}/.nycrc`);
 }
 
-async function removeDependencies ({
-  packageManager,
-  dependencies
-}) {
+async function removeDependencies ({packageManager, dependencies}) {
   await execa(packageManager, ['remove', ...dependencies]);
 }
 
-async function removeNyc ({
-  projectRoot,
-  packageManager
-}) {
-  await Promise.all([promises.unlink(`${projectRoot}/.nycrc`), promises.rm(`${projectRoot}/.nyc_output`, {
-    recursive: true,
-    force: true
-  }), removeDependencies({
-    packageManager,
-    dependencies: ['nyc', '@istanbuljs/nyc-config-babel', 'babel-plugin-istanbul']
-  })]);
-}
-
-async function lift$2({
-  projectRoot,
-  packageManager
-}) {
-  const codecovResults = await lift$3({
-    projectRoot,
-    packageManager
-  });
-
-  if (await nycIsConfigured({
-    projectRoot
-  })) {
-    const [c8Results] = await Promise.all([scaffoldC8({
-      projectRoot
-    }), removeNyc({
-      projectRoot,
-      packageManager
-    })]);
-    return deepmerge.all([c8Results, codecovResults, {
-      scripts: {
-        'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'
-      },
-      nextSteps: [{
-        summary: 'Remove use of `@istanbuljs/nyc-config-babel` from your babel config, if present,' + ' after the migration away from `nyc`'
-      }]
-    }]);
+async function removeNyc ({projectRoot, packageManager}) {
+  await Promise.all([
+    promises.unlink(`${projectRoot}/.nycrc`),
+    promises.rm(`${projectRoot}/.nyc_output`, {recursive: true, force: true}),
+    removeDependencies({packageManager, dependencies: ['nyc', '@istanbuljs/nyc-config-babel', 'babel-plugin-istanbul']})
+  ]);
+}
+
+async function lift$2({projectRoot, packageManager}) {
+  const codecovResults = await lift$3({projectRoot, packageManager});
+
+  if (await nycIsConfigured({projectRoot})) {
+    const [c8Results] = await Promise.all([
+      scaffoldC8({projectRoot}),
+      removeNyc({projectRoot, packageManager})
+    ]);
+
+    return deepmerge.all([
+      c8Results,
+      codecovResults,
+      {
+        scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'},
+        nextSteps: [{
+          summary: 'Remove use of `@istanbuljs/nyc-config-babel` from your babel config, if present,'
+            + ' after the migration away from `nyc`'
+        }]
+      }
+    ]);
   }
 
   return {};
 }
 
-function c8IsConfigured ({
-  projectRoot
-}) {
+function c8IsConfigured ({projectRoot}) {
   return fileExists(`${projectRoot}/.c8rc.json`);
 }
 
-async function tester ({
-  projectRoot
-}) {
-  const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({
-    projectRoot
-  }), nycIsConfigured({
-    projectRoot
-  })]);
+async function tester ({projectRoot}) {
+  const [c8Exists, nycExists] = await Promise.all([c8IsConfigured({projectRoot}), nycIsConfigured({projectRoot})]);
+
   return c8Exists || nycExists;
 }
 
@@ -206,76 +127,47 @@ const unitTestFrameworksSchema = joi.object().required().pattern(/^/, joi.object
   scaffolder: joi.func().arity(1).required()
 }));
 
-async function chooseFramework ({
-  frameworks,
-  decisions
-}) {
+async function chooseFramework ({frameworks, decisions}) {
   if (!Object.keys(frameworks).length) return 'Other';
+
   const answers = await prompt$1([{
     name: questionNames$1.UNIT_TEST_FRAMEWORK,
     type: 'list',
     message: 'Which type of unit testing framework should be used?',
     choices: [...Object.keys(frameworks), new Separator(), 'Other']
   }], decisions);
+
   return answers[questionNames$1.UNIT_TEST_FRAMEWORK];
 }
 
-async function scaffoldUnitTesting ({
-  projectRoot,
-  frameworks,
-  decisions,
-  visibility,
-  vcs,
-  pathWithinParent,
-  dialect
-}) {
+async function scaffoldUnitTesting ({projectRoot, frameworks, decisions, visibility, vcs, pathWithinParent, dialect}) {
   const validatedFrameworks = validateOptions(unitTestFrameworksSchema, frameworks);
-  const [framework, coverage] = await Promise.all([chooseFramework({
-    frameworks: validatedFrameworks,
-    decisions
-  }).then(chosenFramework => scaffoldChoice(validatedFrameworks, chosenFramework, {
-    projectRoot,
-    dialect
-  })), scaffoldCoverage({
-    projectRoot,
-    vcs,
-    visibility,
-    pathWithinParent
-  })]);
-  return deepmerge.all([{
-    scripts: {
-      'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'
-    }
-  }, framework, coverage]);
+  const [framework, coverage] = await Promise.all([
+    chooseFramework({frameworks: validatedFrameworks, decisions})
+      .then(chosenFramework => scaffoldChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
+    scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent})
+  ]);
+
+  return deepmerge.all([
+    {scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'}},
+    framework,
+    coverage
+  ]);
 }
 
-async function test$1({
-  projectRoot
-}) {
-  const {
-    engines
-  } = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
-  return !!(engines !== null && engines !== void 0 && engines.node);
+async function test$1({projectRoot}) {
+  const {engines} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+
+  return !!engines?.node;
 }
-async function lift$1({
-  projectRoot
-}) {
-  const {
-    name
-  } = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+
+async function lift$1({projectRoot}) {
+  const {name} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+
   return {
     devDependencies: ['ls-engines'],
-    scripts: {
-      'lint:engines': 'ls-engines'
-    },
-    badges: {
-      consumer: {
-        node: {
-          img: `https://img.shields.io/node/v/${name}?logo=node.js`,
-          text: 'node'
-        }
-      }
-    }
+    scripts: {'lint:engines': 'ls-engines'},
+    badges: {consumer: {node: {img: `https://img.shields.io/node/v/${name}?logo=node.js`, text: 'node'}}}
   };
 }
 
@@ -298,27 +190,33 @@ function projectShouldBeBuiltForVerification(scripts) {
 }
 
 function updateTestScript (scripts) {
-  return _objectSpread2(_objectSpread2({}, scripts), {}, {
-    test: `npm-run-all --print-label${projectShouldBeBuiltForVerification(scripts) ? ' build' : ''} --parallel lint:*${projectWillBeTested(scripts) ? ' --parallel test:*' : ''}`
-  });
+  return {
+    ...scripts,
+    test: `npm-run-all --print-label${
+      projectShouldBeBuiltForVerification(scripts) ? ' build' : ''
+    } --parallel lint:*${
+      projectWillBeTested(scripts) ? ' --parallel test:*' : ''
+    }`
+  };
 }
 
-function liftScripts ({
-  existingScripts,
-  scripts
-}) {
-  return updateTestScript(_objectSpread2(_objectSpread2({}, existingScripts), scripts));
+function liftScripts ({existingScripts, scripts}) {
+  return updateTestScript({...existingScripts, ...scripts});
 }
 
 function defineVcsHostDetails(vcs, packageType, packageName, pathWithinParent) {
   return vcs && 'github' === vcs.host && {
-    repository: pathWithinParent ? {
-      type: 'git',
-      url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
-      directory: pathWithinParent
-    } : `${vcs.owner}/${vcs.name}`,
+    repository: pathWithinParent
+      ? {
+        type: 'git',
+        url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
+        directory: pathWithinParent
+      }
+      : `${vcs.owner}/${vcs.name}`,
     bugs: `https://github.com/${vcs.owner}/${vcs.name}/issues`,
-    homepage: projectTypes.PACKAGE === packageType ? `https://npm.im/${packageName}` : `https://github.com/${vcs.owner}/${vcs.name}#readme`
+    homepage: (projectTypes.PACKAGE === packageType)
+      ? `https://npm.im/${packageName}`
+      : `https://github.com/${vcs.owner}/${vcs.name}#readme`
   };
 }
 
@@ -332,15 +230,15 @@ function buildPackageDetails ({
   description,
   pathWithinParent
 }) {
-  return _objectSpread2(_objectSpread2({
+  return {
     name: packageName,
     description,
     license,
-    type: dialects.ESM === dialect ? 'module' : 'commonjs'
-  }, defineVcsHostDetails(vcs, projectType, packageName, pathWithinParent)), {}, {
+    type: dialects.ESM === dialect ? 'module' : 'commonjs',
+    ...defineVcsHostDetails(vcs, projectType, packageName, pathWithinParent),
     author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
     scripts: scaffoldScripts()
-  });
+  };
 }
 
 async function scaffoldPackage ({
@@ -355,6 +253,7 @@ async function scaffoldPackage ({
   pathWithinParent
 }) {
   info('Configuring package.json');
+
   const packageData = await buildPackageDetails({
     packageName,
     projectType,
@@ -365,13 +264,10 @@ async function scaffoldPackage ({
     description,
     pathWithinParent
   });
-  await writePackageJson({
-    projectRoot,
-    config: packageData
-  });
-  return {
-    homepage: packageData.homepage
-  };
+
+  await writePackageJson({projectRoot, config: packageData});
+
+  return {homepage: packageData.homepage};
 }
 
 async function liftPackage ({
@@ -383,21 +279,21 @@ async function liftPackage ({
   packageManager
 }) {
   if (scripts || tags) {
-    info('Updating `package.json`', {
-      level: 'secondary'
-    });
+    info('Updating `package.json`', {level: 'secondary'});
+
     const pathToPackageJson = `${projectRoot}/package.json`;
+
     const existingPackageJsonContents = JSON.parse(await promises.readFile(pathToPackageJson, 'utf8'));
+
     await writePackageJson({
       projectRoot,
-      config: _objectSpread2(_objectSpread2({}, existingPackageJsonContents), {}, {
-        scripts: liftScripts({
-          existingScripts: existingPackageJsonContents.scripts,
-          scripts
-        })
-      }, tags && {
-        keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
-      })
+      config: {
+        ...existingPackageJsonContents,
+        scripts: liftScripts({existingScripts: existingPackageJsonContents.scripts, scripts}),
+        ...tags && {
+          keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
+        }
+      }
     });
   }
 
@@ -405,16 +301,13 @@ async function liftPackage ({
 
   try {
     await installDependencies(dependencies || [], PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
-    await installDependencies([...(devDependencies || [])], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await installDependencies([...devDependencies || []], DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
   } catch (e) {
     error('Failed to install dependencies');
   }
 }
 
-async function resolvePackageManager ({
-  projectRoot,
-  packageManager
-}) {
+async function resolvePackageManager ({projectRoot, packageManager}) {
   if (packageManager) return packageManager;
 
   if (await fileExists(`${projectRoot}/package-lock.json`)) {
@@ -428,46 +321,28 @@ async function resolvePackageManager ({
   throw new Error('Package-manager could not be determined');
 }
 
-async function lift ({
-  projectRoot,
-  vcs,
-  results
-}) {
+async function lift ({projectRoot, vcs, results}) {
   info('Lifting JavaScript-specific details');
-  const {
-    scripts,
-    tags,
-    eslintConfigs,
-    eslint,
-    dependencies,
-    devDependencies,
-    packageManager: manager
-  } = results;
-  const packageManager = await resolvePackageManager({
-    projectRoot,
-    packageManager: manager
-  });
-  const eslintResults = await lift$4({
-    projectRoot,
-    configs: [...(eslintConfigs || []), ...((eslint === null || eslint === void 0 ? void 0 : eslint.configs) || [])]
-  });
+
+  const {scripts, tags, eslintConfigs, eslint, dependencies, devDependencies, packageManager: manager} = results;
+
+  const packageManager = await resolvePackageManager({projectRoot, packageManager: manager});
+
+  const eslintResults = await lift$4({projectRoot, configs: [...eslintConfigs || [], ...eslint?.configs || []]});
   const enhancerResults = await applyEnhancers({
     results,
     enhancers: [huskyPlugin, enginesEnhancer, coveragePlugin, commitConventionPlugin],
-    options: {
-      packageManager,
-      projectRoot,
-      vcs
-    }
+    options: {packageManager, projectRoot, vcs}
   });
-  await liftPackage(deepmerge.all([{
-    projectRoot,
-    scripts,
-    tags,
-    dependencies,
-    devDependencies,
-    packageManager
-  }, enhancerResults, eslintResults]));
+
+  await liftPackage(
+    deepmerge.all([
+      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager},
+      enhancerResults,
+      eslintResults
+    ])
+  );
+
   return enhancerResults;
 }
 
@@ -476,106 +351,94 @@ const packageBundlersSchema = joi.object().pattern(/^/, joi.object({
 })).default({});
 
 function validate(options) {
-  const schema = joi.object().required().keys({
-    projectRoot: joi.string().required(),
-    projectName: joi.string().regex(/^@\w*\//, {
-      invert: true
-    }).required(),
-    visibility: joi.string().valid('Public', 'Private').required(),
-    license: joi.string().required(),
-    description: joi.string(),
-    pathWithinParent: joi.string()
-  }).keys({
-    vcs: joi.object({
-      host: joi.string().required(),
-      owner: joi.string().required(),
-      name: joi.string().required()
+  const schema = joi.object().required()
+    .keys({
+      projectRoot: joi.string().required(),
+      projectName: joi.string().regex(/^@\w*\//, {invert: true}).required(),
+      visibility: joi.string().valid('Public', 'Private').required(),
+      license: joi.string().required(),
+      description: joi.string(),
+      pathWithinParent: joi.string()
     })
-  }).keys({
-    configs: joi.object({
-      eslint: joi.object({
-        scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()
-      }),
-      typescript: joi.object({
-        scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()
-      }),
-      commitlint: joi.object({
-        packageName: joi.string().required(),
-        name: joi.string().required()
-      }),
-      babelPreset: joi.object({
-        packageName: joi.string().required(),
+    .keys({
+      vcs: joi.object({
+        host: joi.string().required(),
+        owner: joi.string().required(),
         name: joi.string().required()
-      }),
-      remark: joi.string()
-    }).default({})
-  }).keys({
-    overrides: joi.object({
-      npmAccount: joi.string(),
-      author: joi.object({
-        name: joi.string().required(),
-        email: joi.string().email(),
-        url: joi.string().uri()
       })
-    }).default({})
-  }).keys({
-    ciServices: joi.object().pattern(/^/, joi.object({
-      scaffolder: joi.func().arity(1).required(),
-      public: joi.boolean(),
-      private: joi.boolean()
-    })).default({})
-  }).keys({
-    hosts: joi.object().pattern(/^/, joi.object({
-      scaffolder: joi.func().arity(1).required(),
-      projectTypes: joi.array().items(joi.string().valid('static', 'node')).default([])
-    })).default({})
-  }).keys({
-    applicationTypes: joi.object().pattern(/^/, joi.object({
-      scaffolder: joi.func().arity(1).required()
-    })).default({}),
-    packageTypes: joi.object().pattern(/^/, joi.object({
-      scaffolder: joi.func().arity(1).required()
-    })).default({}),
-    monorepoTypes: joi.object().pattern(/^/, joi.object({
-      scaffolder: joi.func().arity(1).required()
-    }))
-  }).keys({
-    unitTestFrameworks: unitTestFrameworksSchema,
-    packageBundlers: packageBundlersSchema
-  }).keys({
-    decisions: joi.object()
-  }).keys({
-    registries: joi.object().pattern(joi.string(), joi.string().uri()).default({})
-  });
-  const {
-    error,
-    value
-  } = schema.validate(options);
+    })
+    .keys({
+      configs: joi.object({
+        eslint: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
+        typescript: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
+        prettier: joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()}),
+        commitlint: joi.object({
+          packageName: joi.string().required(),
+          name: joi.string().required()
+        }),
+        babelPreset: joi.object({
+          packageName: joi.string().required(),
+          name: joi.string().required()
+        }),
+        remark: joi.string()
+      }).default({})
+    })
+    .keys({
+      overrides: joi.object({
+        npmAccount: joi.string(),
+        author: joi.object({
+          name: joi.string().required(),
+          email: joi.string().email(),
+          url: joi.string().uri()
+        })
+      }).default({})
+    })
+    .keys({
+      ciServices: joi.object().pattern(/^/, joi.object({
+        scaffolder: joi.func().arity(1).required(),
+        public: joi.boolean(),
+        private: joi.boolean()
+      })).default({})
+    })
+    .keys({
+      hosts: joi.object().pattern(/^/, joi.object({
+        scaffolder: joi.func().arity(1).required(),
+        projectTypes: joi.array().items(joi.string().valid('static', 'node')).default([])
+      })).default({})
+    })
+    .keys({
+      applicationTypes: joi.object().pattern(/^/, joi.object({
+        scaffolder: joi.func().arity(1).required()
+      })).default({}),
+      packageTypes: joi.object().pattern(/^/, joi.object({
+        scaffolder: joi.func().arity(1).required()
+      })).default({}),
+      monorepoTypes: joi.object().pattern(/^/, joi.object({
+        scaffolder: joi.func().arity(1).required()
+      }))
+    })
+    .keys({
+      unitTestFrameworks: unitTestFrameworksSchema,
+      packageBundlers: packageBundlersSchema
+    })
+    .keys({
+      decisions: joi.object()
+    })
+    .keys({registries: joi.object().pattern(joi.string(), joi.string().uri()).default({})});
+  const {error, value} = schema.validate(options);
+
   hoek.assert(!error, error);
+
   return value;
 }
 
-function buildDialectChoices ({
-  babelPreset,
-  typescript
-}) {
-  return [{
-    name: 'Common JS (no transpilation)',
-    value: dialects.COMMON_JS,
-    short: 'cjs'
-  }, ...(babelPreset ? [{
-    name: 'Modern JavaScript (transpiled)',
-    value: dialects.BABEL,
-    short: 'modern'
-  }] : []), {
-    name: 'ESM-only (no transpilation)',
-    value: dialects.ESM,
-    short: 'esm'
-  }, ...(typescript ? [{
-    name: 'TypeScript',
-    value: dialects.TYPESCRIPT,
-    short: 'ts'
-  }] : [])];
+function buildDialectChoices ({babelPreset, typescript}) {
+  return [
+    {name: 'Common JS (no transpilation)', value: dialects.COMMON_JS, short: 'cjs'},
+    ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: dialects.BABEL, short: 'modern'}] : [],
+    {name: 'ESM-only (no transpilation)', value: dialects.ESM, short: 'esm'},
+    ...typescript ? [{name: 'TypeScript', value: dialects.TYPESCRIPT, short: 'ts'}] : []
+  ];
 }
 
 function projectIsPackage(answers) {
@@ -601,9 +464,11 @@ function willBePublishedToNpm(answers) {
 function shouldBeScopedPromptShouldBePresented(answers) {
   return willBePublishedToNpm(answers);
 }
+
 function scopePromptShouldBePresentedFactory(visibility) {
   return answers => willBePublishedToNpm(answers) && packageShouldBeScoped(visibility, answers);
 }
+
 function lintingPromptShouldBePresented({
   [questionNames$2.UNIT_TESTS]: unitTested,
   [questionNames$2.INTEGRATION_TESTS]: integrationTested
@@ -621,38 +486,45 @@ function scope(visibility) {
   };
 }
 
-function authorQuestions({
-  name,
-  email,
-  url
-}) {
-  return [{
-    name: questionNames$1.AUTHOR_NAME,
-    message: 'What is the author\'s name?',
-    default: name
-  }, {
-    name: questionNames$1.AUTHOR_EMAIL,
-    message: 'What is the author\'s email?',
-    default: email
-  }, {
-    name: questionNames$1.AUTHOR_URL,
-    message: 'What is the author\'s website url?',
-    default: url
-  }];
-}
-
-async function prompt({
-  npmAccount,
-  author
-}, ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent) {
+function authorQuestions({name, email, url}) {
+  return [
+    {
+      name: questionNames$1.AUTHOR_NAME,
+      message: 'What is the author\'s name?',
+      default: name
+    },
+    {
+      name: questionNames$1.AUTHOR_EMAIL,
+      message: 'What is the author\'s email?',
+      default: email
+    },
+    {
+      name: questionNames$1.AUTHOR_URL,
+      message: 'What is the author\'s website url?',
+      default: url
+    }
+  ];
+}
+
+async function prompt(
+  {npmAccount, author},
+  ciServices,
+  hosts,
+  visibility,
+  vcs,
+  decisions,
+  configs,
+  pathWithinParent
+) {
   const npmConf$1 = npmConf();
-  let maybeLoggedInNpmUsername;
 
+  let maybeLoggedInNpmUsername;
   try {
     maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
   } catch (failedExecutionResult) {
     if (!decisions[questionNames$1.SCOPE]) {
-      warn('No logged in user found with `npm whoami`. Login with `npm login` ' + 'to use your npm account name as the package scope default.');
+      warn('No logged in user found with `npm whoami`. Login with `npm login` '
+        + 'to use your npm account name as the package scope default.');
     }
   }
 
@@ -670,89 +542,85 @@ async function prompt({
     [questionNames$1.CONFIGURE_LINTING]: configureLinting,
     [questionNames$1.PACKAGE_MANAGER]: packageManager,
     [questionNames$1.DIALECT]: dialect
-  } = await prompt$1([{
-    name: questionNames$1.DIALECT,
-    message: 'Which JavaScript dialect should this project follow?',
-    type: 'list',
-    choices: buildDialectChoices(configs),
-    default: 'babel'
-  }, ...(pathWithinParent ? [] : [{
-    name: questionNames$1.NODE_VERSION_CATEGORY,
-    message: 'What node.js version should be used?',
-    type: 'list',
-    choices: ['LTS', 'Latest'],
-    default: 'LTS'
-  }]), {
-    name: questionNames$1.PACKAGE_MANAGER,
-    message: 'Which package manager will be used with this project?',
-    type: 'list',
-    choices: Object.values(packageManagers),
-    default: packageManagers.NPM
-  }, {
-    name: questionNames$1.PROJECT_TYPE,
-    message: 'What type of JavaScript project is this?',
-    type: 'list',
-    choices: [...Object.values(projectTypes), new Separator(), 'Other'],
-    default: projectTypes.PACKAGE
-  }, ...('Private' === visibility ? [] : [{
-    name: questionNames$1.SHOULD_BE_SCOPED,
-    message: 'Should this package be scoped?',
-    type: 'confirm',
-    when: shouldBeScopedPromptShouldBePresented,
-    default: true
-  }]), {
-    name: questionNames$1.SCOPE,
-    message: 'What is the scope?',
-    when: scopePromptShouldBePresentedFactory(visibility),
-    validate: scope(visibility),
-    default: npmAccount || maybeLoggedInNpmUsername
-  }, ...authorQuestions(author || {
-    name: npmConf$1.get('init.author.name'),
-    email: npmConf$1.get('init.author.email'),
-    url: npmConf$1.get('init.author.url')
-  }), ...questions({
-    vcs,
-    ciServices,
-    visibility,
-    pathWithinParent
-  }), {
-    name: questionNames$1.CONFIGURE_LINTING,
-    message: 'Will there be source code that should be linted?',
-    type: 'confirm',
-    when: lintingPromptShouldBePresented
-  }, {
-    name: questionNames$1.HOST,
-    type: 'list',
-    message: 'Where will the application be hosted?',
-    when: projectIsApplication,
-    choices: [...Object.keys(hosts), new Separator(), 'Other']
-  }], decisions);
-  return {
-    tests: {
-      unit: unitTested,
-      integration: integrationTested
+  } = await prompt$1([
+    {
+      name: questionNames$1.DIALECT,
+      message: 'Which JavaScript dialect should this project follow?',
+      type: 'list',
+      choices: buildDialectChoices(configs),
+      default: 'babel'
+    },
+    ...pathWithinParent ? [] : [{
+      name: questionNames$1.NODE_VERSION_CATEGORY,
+      message: 'What node.js version should be used?',
+      type: 'list',
+      choices: ['LTS', 'Latest'],
+      default: 'LTS'
+    }],
+    {
+      name: questionNames$1.PACKAGE_MANAGER,
+      message: 'Which package manager will be used with this project?',
+      type: 'list',
+      choices: Object.values(packageManagers),
+      default: packageManagers.NPM
+    },
+    {
+      name: questionNames$1.PROJECT_TYPE,
+      message: 'What type of JavaScript project is this?',
+      type: 'list',
+      choices: [...Object.values(projectTypes), new Separator(), 'Other'],
+      default: projectTypes.PACKAGE
+    },
+    ...'Private' === visibility ? [] : [{
+      name: questionNames$1.SHOULD_BE_SCOPED,
+      message: 'Should this package be scoped?',
+      type: 'confirm',
+      when: shouldBeScopedPromptShouldBePresented,
+      default: true
+    }],
+    {
+      name: questionNames$1.SCOPE,
+      message: 'What is the scope?',
+      when: scopePromptShouldBePresentedFactory(visibility),
+      validate: scope(visibility),
+      default: npmAccount || maybeLoggedInNpmUsername
+    },
+    ...authorQuestions(author || {
+      name: npmConf$1.get('init.author.name'),
+      email: npmConf$1.get('init.author.email'),
+      url: npmConf$1.get('init.author.url')
+    }),
+    ...questions(({vcs, ciServices, visibility, pathWithinParent})),
+    {
+      name: questionNames$1.CONFIGURE_LINTING,
+      message: 'Will there be source code that should be linted?',
+      type: 'confirm',
+      when: lintingPromptShouldBePresented
     },
+    {
+      name: questionNames$1.HOST,
+      type: 'list',
+      message: 'Where will the application be hosted?',
+      when: projectIsApplication,
+      choices: [...Object.keys(hosts), new Separator(), 'Other']
+    }
+  ], decisions);
+
+  return {
+    tests: {unit: unitTested, integration: integrationTested},
     projectType,
     ci,
     chosenHost,
     scope: scope$1,
     nodeVersionCategory,
-    author: {
-      name: authorName,
-      email: authorEmail,
-      url: authorUrl
-    },
+    author: {name: authorName, email: authorEmail, url: authorUrl},
     configureLinting: false !== configureLinting,
     packageManager,
     dialect
   };
 }
 
-async function scaffoldBabel ({
-  projectRoot,
-  preset,
-  buildDirectory
-}) {
+async function scaffoldBabel ({projectRoot, preset, buildDirectory}) {
   if (!preset) {
     throw new Error('No babel preset provided. Cannot configure babel transpilation');
   }
@@ -761,74 +629,50 @@ async function scaffoldBabel ({
     path: projectRoot,
     name: 'babel',
     format: fileTypes.JSON,
-    config: {
-      presets: [preset.name],
-      ignore: [`./${buildDirectory}/`]
-    }
+    config: {presets: [preset.name], ignore: [`./${buildDirectory}/`]}
   });
+
   return {
     devDependencies: ['@babel/register', preset.packageName],
     eslint: {}
   };
 }
 
-async function scaffoldTypescript ({
-  config,
-  projectType,
-  projectRoot,
-  testFilenamePattern
-}) {
+async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
   const eslintConfigs = ['typescript'];
   const shareableTsConfigPackage = `${config.scope}/tsconfig`;
-  await promises.writeFile(`${projectRoot}/tsconfig.json`, JSON.stringify(_objectSpread2({
-    $schema: 'https://json.schemastore.org/tsconfig',
-    extends: shareableTsConfigPackage,
-    compilerOptions: _objectSpread2({
-      rootDir: 'src'
-    }, projectTypes.PACKAGE === projectType && {
-      outDir: 'lib',
-      declaration: true
-    }),
-    include: ['src/**/*.ts']
-  }, testFilenamePattern && {
-    exclude: [testFilenamePattern]
-  })));
+
+  await promises.writeFile(
+    `${projectRoot}/tsconfig.json`,
+    JSON.stringify({
+      $schema: 'https://json.schemastore.org/tsconfig',
+      extends: shareableTsConfigPackage,
+      compilerOptions: {
+        rootDir: 'src',
+        ...projectTypes.PACKAGE === projectType && {
+          outDir: 'lib',
+          declaration: true
+        }
+      },
+      include: ['src/**/*.ts'],
+      ...testFilenamePattern && {exclude: [testFilenamePattern]}
+    })
+  );
+
   return {
-    eslint: {
-      configs: eslintConfigs
-    },
+    eslint: {configs: eslintConfigs},
     eslintConfigs,
     devDependencies: ['typescript', shareableTsConfigPackage],
-    vcsIgnore: {
-      files: ['tsconfig.tsbuildinfo']
-    }
+    vcsIgnore: {files: ['tsconfig.tsbuildinfo']}
   };
 }
 
-function scaffoldDialect ({
-  dialect,
-  projectType,
-  projectRoot,
-  configs,
-  buildDirectory,
-  testFilenamePattern
-}) {
+function scaffoldDialect ({dialect, projectType, projectRoot, configs, buildDirectory, testFilenamePattern}) {
   switch (dialect) {
     case dialects.BABEL:
-      return scaffoldBabel({
-        preset: configs.babelPreset,
-        projectRoot,
-        buildDirectory
-      });
-
+      return scaffoldBabel({preset: configs.babelPreset, projectRoot, buildDirectory});
     case dialects.TYPESCRIPT:
-      return scaffoldTypescript({
-        config: configs.typescript,
-        projectType,
-        projectRoot,
-        testFilenamePattern
-      });
-
+      return scaffoldTypescript({config: configs.typescript, projectType, projectRoot, testFilenamePattern});
     default:
       return {};
   }
@@ -843,34 +687,38 @@ async function scaffoldNpmConfig ({
   projectType,
   registries
 }) {
-  await promises.writeFile(`${projectRoot}/.npmrc`, stringify(_objectSpread2(_objectSpread2({
-    'update-notifier': false
-  }, projectWillNotBeConsumed(projectType) && {
-    'save-exact': true
-  }), Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope).map(([scope, url]) => {
-    if ('registry' === scope) return ['registry', url];
-    return [`@${scope}:registry`, url];
-  })))));
-  return {
-    scripts: {
-      'lint:peer': 'npm ls >/dev/null'
-    }
-  };
+  await promises.writeFile(
+    `${projectRoot}/.npmrc`,
+    stringify({
+      'update-notifier': false,
+      ...projectWillNotBeConsumed(projectType) && {'save-exact': true},
+      ...Object.fromEntries(Object.entries(registries)
+        .filter(([scope]) => 'publish' !== scope)
+        .map(([scope, url]) => {
+          if ('registry' === scope) return ['registry', url];
+
+          return [`@${scope}:registry`, url];
+        }))
+    })
+  );
+
+  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
 }
 
 function buildDocumentationCommand (packageManager) {
   if (packageManagers.NPM === packageManager) return 'npm run generate:md';
   if (packageManagers.YARN === packageManager) return 'yarn generate:md';
-  throw new Error(`The ${packageManager} package manager is currently not supported. ` + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`);
+
+  throw new Error(
+    `The ${packageManager} package manager is currently not supported. `
+    + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`
+  );
 }
 
-function scaffoldDocumentation ({
-  projectTypeResults,
-  packageManager
-}) {
-  return _objectSpread2(_objectSpread2({
-    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`
-  }, projectTypeResults.documentation), {}, {
+function scaffoldDocumentation ({projectTypeResults, packageManager}) {
+  return {
+    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`,
+    ...projectTypeResults.documentation,
     contributing: `### Dependencies
 
 \`\`\`sh
@@ -883,43 +731,43 @@ $ ${packageManager} install
 \`\`\`sh
 $ ${packageManager} test
 \`\`\``
-  });
+  };
 }
 
 async function determineLatestVersionOf(nodeVersionCategory) {
-  info('Determining version of node', {
-    level: 'secondary'
-  });
-  const {
-    stdout: nvmLsOutput
-  } = await execa(`. ~/.nvm/nvm.sh && nvm ls-remote${'LTS' === nodeVersionCategory ? ' --lts' : ''}`, {
-    shell: true
-  });
+  info('Determining version of node', {level: 'secondary'});
+
+  const {stdout: nvmLsOutput} = await execa(
+    `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
+    {shell: true}
+  );
+
   const lsLines = nvmLsOutput.split('\n');
   const lsLine = lsLines[lsLines.length - 2];
+
   return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
 }
+
 function install(nodeVersionCategory) {
-  info(`Installing ${nodeVersionCategory} version of node using nvm`, {
-    level: 'secondary'
-  });
-  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {
-    shell: true
-  });
+  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
+
+  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
   subprocess.stdout.pipe(process.stdout);
   return subprocess;
 }
 
-async function scaffoldNodeVersion ({
-  projectRoot,
-  nodeVersionCategory
-}) {
+async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
   if (!nodeVersionCategory) return undefined;
+
   const lowerCaseCategory = nodeVersionCategory.toLowerCase();
   info(`Configuring ${lowerCaseCategory} version of node`);
+
   const version = await determineLatestVersionOf(nodeVersionCategory);
+
   await promises.writeFile(`${projectRoot}/.nvmrc`, version);
+
   await install(nodeVersionCategory);
+
   return version;
 }
 
@@ -930,54 +778,52 @@ function buildBadgesDetails (contributors) {
 function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
   return {
     files: vcsIgnoreLists.files || [],
-    directories: ['/node_modules/', ...(vcsIgnoreLists.directories || [])]
+    directories: ['/node_modules/', ...vcsIgnoreLists.directories || []]
   };
 }
 
 function buildPackageName (projectName, scope) {
   const name = `${scope ? `@${scope}/` : ''}${projectName}`;
-  const {
-    validForNewPackages,
-    errors
-  } = validatePackageName(name);
+
+  const {validForNewPackages, errors} = validatePackageName(name);
+
   if (validForNewPackages) return name;
   if (1 === errors.length && errors.includes('name cannot start with a period')) return projectName.slice(1);
+
   throw new Error(`The package name ${name} is invalid:${EOL}\t* ${errors.join(`${EOL}\t* `)}`);
 }
 
-async function chooseApplicationType ({
-  types,
-  projectType,
-  decisions
-}) {
+async function chooseApplicationType ({types, projectType, decisions}) {
   if (!Object.keys(types).length) return 'Other';
+
   const answers = await prompt$1([{
     name: questionNames$1.PROJECT_TYPE_CHOICE,
     type: 'list',
     message: `What type of ${projectType} is this?`,
     choices: [...Object.keys(types), new Separator(), 'Other']
   }], decisions);
+
   return answers[questionNames$1.PROJECT_TYPE_CHOICE];
 }
 
 function getInstallationCommand(packageManager) {
   if (packageManagers.NPM === packageManager) return 'npm install';
   if (packageManagers.YARN === packageManager) return 'yarn add';
-  throw new Error(`The ${packageManager} package manager is currently not supported. ` + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`);
+
+  throw new Error(
+    `The ${packageManager} package manager is currently not supported. `
+    + `Only ${Object.values(packageManagers).join(' and ')} are currently supported.`
+  );
 }
 
-function scaffoldPackageDocumentation ({
-  scope,
-  packageName,
-  packageManager,
-  visibility
-}) {
+function scaffoldPackageDocumentation ({scope, packageName, packageManager, visibility}) {
   return {
     usage: `### Installation
 ${'Private' === visibility ? `
 :warning: this is a private package, so you will need to use an npm token with
 access to private packages under \`@${scope}\`
-` : ''}
+` : ''
+}
 \`\`\`sh
 $ ${getInstallationCommand(packageManager)} ${packageName}
 \`\`\`
@@ -990,49 +836,56 @@ run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example
 
 function defineBadges (packageName, visibility) {
   return {
-    consumer: _objectSpread2({}, 'Public' === visibility && {
-      npm: {
-        img: `https://img.shields.io/npm/v/${packageName}?logo=npm`,
-        text: 'npm',
-        link: `https://www.npmjs.com/package/${packageName}`
+    consumer: {
+      ...'Public' === visibility && {
+        npm: {
+          img: `https://img.shields.io/npm/v/${packageName}?logo=npm`,
+          text: 'npm',
+          link: `https://www.npmjs.com/package/${packageName}`
+        }
       }
-    }),
+    },
     status: {}
   };
 }
 
-async function chooseBundler ({
-  bundlers,
-  decisions
-}) {
+async function chooseBundler ({bundlers, decisions}) {
   if (!Object.keys(bundlers).length) return 'Other';
+
   const answers = await prompt$1([{
     name: questionNames$1.PACKAGE_BUNDLER,
     type: 'list',
     message: 'Which bundler should be used?',
     choices: [...Object.keys(bundlers), new Separator(), 'Other']
   }], decisions);
+
   return answers[questionNames$1.PACKAGE_BUNDLER];
 }
 
 function determinePathToTemplateFile (fileName) {
   const [, __dirname] = filedirname();
+
   return resolve(__dirname, '..', 'templates', fileName);
 }
 
 const defaultBuildDirectory$2 = 'lib';
 
 async function createExample(projectRoot, projectName) {
-  return promises.writeFile(`${projectRoot}/example.js`, mustache.render(await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'), {
-    projectName: camelcase(projectName)
-  }));
+  return promises.writeFile(
+    `${projectRoot}/example.js`,
+    mustache.render(
+      await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'),
+      {projectName: camelcase(projectName)}
+    )
+  );
 }
 
-async function buildDetailsForCommonJsProject({
-  projectRoot,
-  projectName
-}) {
-  await Promise.all([touch(`${projectRoot}/index.js`), promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)]);
+async function buildDetailsForCommonJsProject({projectRoot, projectName}) {
+  await Promise.all([
+    touch(`${projectRoot}/index.js`),
+    promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)
+  ]);
+
   return {};
 }
 
@@ -1045,42 +898,42 @@ async function buildDetails ({
   dialect,
   decisions
 }) {
-  if (dialects.COMMON_JS === dialect) return buildDetailsForCommonJsProject({
-    projectRoot,
-    projectName
-  });
-  const chosenBundler = await chooseBundler({
-    bundlers: packageBundlers,
-    decisions
-  });
+  if (dialects.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName});
+
+  const chosenBundler = await chooseBundler({bundlers: packageBundlers, decisions});
+
   const pathToCreatedSrcDirectory = await makeDir(`${projectRoot}/src`);
-  const [bundlerResults] = await Promise.all([scaffoldChoice(packageBundlers, chosenBundler, {
-    projectRoot,
-    dialect,
-    projectType: projectTypes.PACKAGE
-  }), await createExample(projectRoot, projectName), touch(`${pathToCreatedSrcDirectory}/index.js`)]);
-  return deepmerge(bundlerResults, {
-    devDependencies: ['rimraf'],
-    scripts: {
-      clean: `rimraf ./${defaultBuildDirectory$2}`,
-      prebuild: 'run-s clean',
-      build: 'npm-run-all --print-label --parallel build:*',
-      prepack: 'run-s build'
-    },
-    vcsIgnore: {
-      directories: [`/${defaultBuildDirectory$2}/`]
-    },
-    buildDirectory: defaultBuildDirectory$2,
-    badges: {
-      consumer: _objectSpread2({}, 'Public' === visibility && {
-        runkit: {
-          img: `https://badge.runkitcdn.com/${packageName}.svg`,
-          text: `Try ${packageName} on RunKit`,
-          link: `https://npm.runkit.com/${packageName}`
+  const [bundlerResults] = await Promise.all([
+    scaffoldChoice(packageBundlers, chosenBundler, {projectRoot, dialect, projectType: projectTypes.PACKAGE}),
+    await createExample(projectRoot, projectName),
+    touch(`${pathToCreatedSrcDirectory}/index.js`)
+  ]);
+
+  return deepmerge(
+    bundlerResults,
+    {
+      devDependencies: ['rimraf'],
+      scripts: {
+        clean: `rimraf ./${defaultBuildDirectory$2}`,
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build'
+      },
+      vcsIgnore: {directories: [`/${defaultBuildDirectory$2}/`]},
+      buildDirectory: defaultBuildDirectory$2,
+      badges: {
+        consumer: {
+          ...'Public' === visibility && {
+            runkit: {
+              img: `https://badge.runkitcdn.com/${packageName}.svg`,
+              text: `Try ${packageName} on RunKit`,
+              link: `https://npm.runkit.com/${packageName}`
+            }
+          }
         }
-      })
+      }
     }
-  });
+  );
 }
 
 async function scaffoldPackageType ({
@@ -1098,78 +951,70 @@ async function scaffoldPackageType ({
   publishRegistry
 }) {
   info('Scaffolding Package Details');
-  const [detailsForBuild] = await Promise.all([buildDetails({
-    projectRoot,
-    projectName,
-    packageBundlers,
-    visibility,
-    packageName,
-    dialect,
-    decisions
-  }), mergeIntoExistingPackageJson({
-    projectRoot,
-    config: _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
-      files: ['example.js', ...(dialects.COMMON_JS === dialect ? ['index.js'] : ['lib/'])],
-      publishConfig: _objectSpread2({
-        access: 'Public' === visibility ? 'public' : 'restricted'
-      }, publishRegistry && {
-        registry: publishRegistry
-      }),
-      sideEffects: false
-    }, 'Public' === visibility && {
-      runkitExampleFilename: './example.js'
-    }), dialects.BABEL === dialect && {
-      main: './lib/index.cjs.js',
-      module: './lib/index.es.js',
-      exports: {
-        require: './lib/index.cjs.js',
-        import: './lib/index.es.js'
-      }
-    }), dialects.ESM === dialect && {
-      main: './lib/index.es.js',
-      exports: './lib/index.es.js'
-    }), dialects.TYPESCRIPT === dialect && {
-      main: './lib/index.cjs.js',
-      module: './lib/index.es.js',
-      types: './lib/index.d.ts',
-      exports: {
-        types: './lib/index.d.ts',
-        require: './lib/index.cjs.js',
-        import: './lib/index.es.js'
+
+  const [detailsForBuild] = await Promise.all([
+    buildDetails({projectRoot, projectName, packageBundlers, visibility, packageName, dialect, decisions}),
+    mergeIntoExistingPackageJson({
+      projectRoot,
+      config: {
+        files: ['example.js', ...dialects.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
+        publishConfig: {
+          access: 'Public' === visibility ? 'public' : 'restricted',
+          ...publishRegistry && {registry: publishRegistry}
+        },
+        sideEffects: false,
+        ...'Public' === visibility && {runkitExampleFilename: './example.js'},
+        ...dialects.BABEL === dialect && {
+          main: './lib/index.cjs.js',
+          module: './lib/index.es.js',
+          exports: {
+            require: './lib/index.cjs.js',
+            import: './lib/index.es.js'
+          }
+        },
+        ...dialects.ESM === dialect && {
+          main: './lib/index.es.js',
+          exports: './lib/index.es.js'
+        },
+        ...dialects.TYPESCRIPT === dialect && {
+          main: './lib/index.cjs.js',
+          module: './lib/index.es.js',
+          types: './lib/index.d.ts',
+          exports: {
+            types: './lib/index.d.ts',
+            require: './lib/index.cjs.js',
+            import: './lib/index.es.js'
+          }
+        }
       }
     })
-  })]);
-  const chosenType = await chooseApplicationType({
-    types: packageTypes,
-    projectType: 'package',
-    decisions
-  });
-  const results = await scaffoldChoice(packageTypes, chosenType, {
-    projectRoot,
-    projectName,
-    packageName,
-    tests,
-    scope
-  });
-  return deepmerge.all([{
-    documentation: scaffoldPackageDocumentation({
-      packageName,
-      visibility,
-      scope,
-      packageManager
-    }),
-    eslintConfigs: [],
-    nextSteps: [{
-      summary: 'Add the appropriate `save` flag to the installation instructions in the README'
-    }, {
-      summary: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'
-    }],
-    scripts: {},
-    badges: defineBadges(packageName, visibility)
-  }, detailsForBuild, results]);
+  ]);
+
+  const chosenType = await chooseApplicationType({types: packageTypes, projectType: 'package', decisions});
+  const results = await scaffoldChoice(
+    packageTypes,
+    chosenType,
+    {projectRoot, projectName, packageName, tests, scope}
+  );
+
+  return deepmerge.all([
+    {
+      documentation: scaffoldPackageDocumentation({packageName, visibility, scope, packageManager}),
+      eslintConfigs: [],
+      nextSteps: [
+        {summary: 'Add the appropriate `save` flag to the installation instructions in the README'},
+        {summary: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'}
+      ],
+      scripts: {},
+      badges: defineBadges(packageName, visibility)
+    },
+    detailsForBuild,
+    results
+  ]);
 }
 
 const defaultBuildDirectory$1 = 'lib';
+
 async function scaffoldApplicationType ({
   applicationTypes,
   projectRoot,
@@ -1180,112 +1025,94 @@ async function scaffoldApplicationType ({
   decisions
 }) {
   info('Scaffolding Application Details');
-  const [chosenType] = await Promise.all([chooseApplicationType({
-    types: applicationTypes,
-    projectType: 'application',
-    decisions
-  }), mergeIntoExistingPackageJson({
-    projectRoot,
-    config: {
-      private: true
-    }
-  })]);
-  const results = await scaffoldChoice(applicationTypes, chosenType, {
-    projectRoot,
-    projectName,
-    packageName,
-    packageManager,
-    tests
-  });
+
+  const [chosenType] = await Promise.all([
+    chooseApplicationType({types: applicationTypes, projectType: 'application', decisions}),
+    mergeIntoExistingPackageJson({projectRoot, config: {private: true}})
+  ]);
+
+  const results = await scaffoldChoice(
+    applicationTypes,
+    chosenType,
+    {projectRoot, projectName, packageName, packageManager, tests}
+  );
+
   const buildDirectory = results.buildDirectory || defaultBuildDirectory$1;
-  return deepmerge({
-    scripts: {
-      clean: `rimraf ./${buildDirectory}`,
-      start: `node ./${buildDirectory}/index.js`,
-      prebuild: 'run-s clean'
-    },
-    dependencies: [],
-    devDependencies: ['rimraf'],
-    vcsIgnore: {
-      files: ['.env'],
-      directories: [`/${buildDirectory}/`]
+
+  return deepmerge(
+    {
+      scripts: {
+        clean: `rimraf ./${buildDirectory}`,
+        start: `node ./${buildDirectory}/index.js`,
+        prebuild: 'run-s clean'
+      },
+      dependencies: [],
+      devDependencies: ['rimraf'],
+      vcsIgnore: {files: ['.env'], directories: [`/${buildDirectory}/`]},
+      buildDirectory,
+      eslintConfigs: [],
+      nextSteps: []
     },
-    buildDirectory,
-    eslintConfigs: [],
-    nextSteps: []
-  }, results);
+    results
+  );
 }
 
-async function scaffoldMonorepoType ({
-  monorepoTypes,
-  projectRoot,
-  packageManager,
-  decisions
-}) {
+async function scaffoldMonorepoType ({monorepoTypes, projectRoot, packageManager, decisions}) {
   info('Scaffolding Monorepo Details');
-  const chosenType = await chooseApplicationType({
-    types: monorepoTypes,
-    projectType: projectTypes.MONOREPO,
-    decisions
-  });
-  const results = await scaffoldChoice(monorepoTypes, chosenType, {
-    projectRoot,
-    packageManager
-  });
-  return deepmerge({
-    eslintConfigs: [],
-    packageProperties: {
-      private: true
+
+  const chosenType = await chooseApplicationType({types: monorepoTypes, projectType: projectTypes.MONOREPO, decisions});
+  const results = await scaffoldChoice(monorepoTypes, chosenType, {projectRoot, packageManager});
+
+  return deepmerge(
+    {
+      eslintConfigs: [],
+      packageProperties: {private: true},
+      nextSteps: [{
+        summary: 'Add packages to your new monorepo',
+        description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
+          + ' to scaffold new packages into your new monorepo'
+      }]
     },
-    nextSteps: [{
-      summary: 'Add packages to your new monorepo',
-      description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)' + ' to scaffold new packages into your new monorepo'
-    }]
-  }, results);
+    results
+  );
 }
 
 const defaultBuildDirectory = 'bin';
-async function scaffoldCliType ({
-  packageName,
-  visibility,
-  projectRoot,
-  dialect,
-  publishRegistry
-}) {
-  const [rollupResults] = await Promise.all([scaffold$1({
-    projectRoot,
-    dialect,
-    projectType: projectTypes.CLI
-  }), mergeIntoExistingPackageJson({
-    projectRoot,
-    config: {
-      bin: {},
-      files: [`${defaultBuildDirectory}/`],
-      publishConfig: _objectSpread2({
-        access: 'Public' === visibility ? 'public' : 'restricted'
-      }, publishRegistry && {
-        registry: publishRegistry
-      })
+
+async function scaffoldCliType ({packageName, visibility, projectRoot, dialect, publishRegistry}) {
+  const [rollupResults] = await Promise.all([
+    scaffold$1({projectRoot, dialect, projectType: projectTypes.CLI}),
+    mergeIntoExistingPackageJson({
+      projectRoot,
+      config: {
+        bin: {},
+        files: [`${defaultBuildDirectory}/`],
+        publishConfig: {
+          access: 'Public' === visibility ? 'public' : 'restricted',
+          ...publishRegistry && {registry: publishRegistry}
+        }
+      }
+    })
+  ]);
+
+  return deepmerge(
+    rollupResults,
+    {
+      scripts: {
+        clean: `rimraf ./${defaultBuildDirectory}`,
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build'
+      },
+      dependencies: ['update-notifier'],
+      devDependencies: ['rimraf'],
+      vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
+      buildDirectory: defaultBuildDirectory,
+      badges: defineBadges(packageName, visibility),
+      eslintConfigs: [],
+      nextSteps: []
     }
-  })]);
-  return deepmerge(rollupResults, {
-    scripts: {
-      clean: `rimraf ./${defaultBuildDirectory}`,
-      prebuild: 'run-s clean',
-      build: 'npm-run-all --print-label --parallel build:*',
-      prepack: 'run-s build'
-    },
-    dependencies: ['update-notifier'],
-    devDependencies: ['rimraf'],
-    vcsIgnore: {
-      files: [],
-      directories: [`/${defaultBuildDirectory}/`]
-    },
-    buildDirectory: defaultBuildDirectory,
-    badges: defineBadges(packageName, visibility),
-    eslintConfigs: [],
-    nextSteps: []
-  });
+  );
 }
 
 async function scaffoldProjectType ({
@@ -1323,7 +1150,6 @@ async function scaffoldProjectType ({
         dialect,
         publishRegistry
       });
-
     case projectTypes.APPLICATION:
       return scaffoldApplicationType({
         projectRoot,
@@ -1334,29 +1160,14 @@ async function scaffoldProjectType ({
         tests,
         decisions
       });
-
     case projectTypes.CLI:
-      return scaffoldCliType({
-        packageName,
-        visibility,
-        projectRoot,
-        dialect,
-        publishRegistry
-      });
-
+      return scaffoldCliType({packageName, visibility, projectRoot, dialect, publishRegistry});
     case projectTypes.MONOREPO:
-      return scaffoldMonorepoType({
-        monorepoTypes,
-        projectRoot,
-        packageManager,
-        decisions
-      });
-
+      return scaffoldMonorepoType({monorepoTypes, projectRoot, packageManager, decisions});
     case 'Other':
       return {
         eslintConfigs: []
       };
-
     default:
       throw new Error(`The project-type of ${projectType} is invalid`);
   }
@@ -1365,48 +1176,39 @@ async function scaffoldProjectType ({
 async function scaffoldTesting ({
   projectRoot,
   visibility,
-  tests: {
-    unit,
-    integration
-  },
+  tests: {unit, integration},
   vcs,
   unitTestFrameworks,
   decisions,
   dialect,
   pathWithinParent
 }) {
-  const unitResults = unit ? await scaffoldUnitTesting({
-    projectRoot,
-    visibility,
-    vcs,
-    frameworks: unitTestFrameworks,
-    decisions,
-    dialect,
-    pathWithinParent
-  }) : {};
-  return deepmerge({
-    devDependencies: [...(unit || integration ? ['@travi/any'] : [])],
-    eslint: {}
-  }, unitResults);
+  const unitResults = unit
+    ? await scaffoldUnitTesting({
+      projectRoot,
+      visibility,
+      vcs,
+      frameworks: unitTestFrameworks,
+      decisions,
+      dialect,
+      pathWithinParent
+    })
+    : {};
+
+  return deepmerge({devDependencies: [...(unit || integration) ? ['@travi/any'] : []], eslint: {}}, unitResults);
 }
 
-function scaffoldBanSensitiveFiles ({
-  pathWithinParent
-}) {
+function scaffoldBanSensitiveFiles ({pathWithinParent}) {
   if (pathWithinParent) return {};
-  return {
-    scripts: {
-      'lint:sensitive': 'ban'
-    },
-    devDependencies: ['ban-sensitive-files']
-  };
+
+  return {scripts: {'lint:sensitive': 'ban'}, devDependencies: ['ban-sensitive-files']};
 }
 
-function buildAllowedHostsList ({
-  packageManager,
-  registries
-}) {
-  return [...(!registries || registries && !registries.registry ? [packageManager] : []), ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))];
+function buildAllowedHostsList ({packageManager, registries}) {
+  return [
+    ...(!registries || (registries && !registries.registry)) ? [packageManager] : [],
+    ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
+  ];
 }
 
 const lockfileLintSupportedPackageManagers = [packageManagers.NPM, packageManagers.YARN];
@@ -1416,6 +1218,7 @@ function determineLockfilePathFor(packageManager) {
     [packageManagers.NPM]: 'package-lock.json',
     [packageManagers.YARN]: 'yarn.lock'
   };
+
   return lockfilePaths[packageManager];
 }
 
@@ -1423,46 +1226,35 @@ function lockfileLintSupports(packageManager) {
   return lockfileLintSupportedPackageManagers.includes(packageManager);
 }
 
-async function scaffoldLockfileLint ({
-  projectRoot,
-  packageManager,
-  registries
-}) {
+async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
   if (!lockfileLintSupports(packageManager)) {
-    throw new Error(`The ${packageManager} package manager is currently not supported by lockfile-lint. ` + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`);
+    throw new Error(
+      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
+      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
+    );
   }
 
-  await promises.writeFile(`${projectRoot}/.lockfile-lintrc.json`, JSON.stringify({
-    path: determineLockfilePathFor(packageManager),
-    type: packageManager,
-    'validate-https': true,
-    'allowed-hosts': buildAllowedHostsList({
-      packageManager,
-      registries
+  await promises.writeFile(
+    `${projectRoot}/.lockfile-lintrc.json`,
+    JSON.stringify({
+      path: determineLockfilePathFor(packageManager),
+      type: packageManager,
+      'validate-https': true,
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
     })
-  }));
+  );
+
   return {
     devDependencies: ['lockfile-lint'],
-    scripts: {
-      'lint:lockfile': 'lockfile-lint'
-    }
+    scripts: {'lint:lockfile': 'lockfile-lint'}
   };
 }
 
-async function scaffoldLinting ({
-  projectRoot,
-  packageManager,
-  registries,
-  vcs,
-  pathWithinParent
-}) {
-  return deepmerge.all(await Promise.all([scaffoldLockfileLint({
-    projectRoot,
-    packageManager,
-    registries
-  }), vcs ? scaffoldBanSensitiveFiles({
-    pathWithinParent
-  }) : {}]));
+async function scaffoldLinting ({projectRoot, packageManager, registries, vcs, pathWithinParent}) {
+  return deepmerge.all(await Promise.all([
+    scaffoldLockfileLint({projectRoot, packageManager, registries}),
+    vcs ? scaffoldBanSensitiveFiles({pathWithinParent}) : {}
+  ]));
 }
 
 async function scaffoldVerification({
@@ -1477,60 +1269,33 @@ async function scaffoldVerification({
   decisions,
   pathWithinParent
 }) {
-  const [testingResults, lintingResults, huskyResults] = await Promise.all([scaffoldTesting({
-    projectRoot,
-    tests,
-    visibility,
-    vcs,
-    unitTestFrameworks,
-    decisions,
-    dialect,
-    pathWithinParent
-  }), scaffoldLinting({
-    projectRoot,
-    packageManager,
-    registries,
-    vcs,
-    pathWithinParent
-  }), scaffold$2({
-    projectRoot,
-    packageManager,
-    pathWithinParent
-  })]);
+  const [testingResults, lintingResults, huskyResults] = await Promise.all([
+    scaffoldTesting({
+      projectRoot,
+      tests,
+      visibility,
+      vcs,
+      unitTestFrameworks,
+      decisions,
+      dialect,
+      pathWithinParent
+    }),
+    scaffoldLinting({projectRoot, packageManager, registries, vcs, pathWithinParent}),
+    scaffold$2({projectRoot, packageManager, pathWithinParent})
+  ]);
+
   return deepmerge.all([testingResults, lintingResults, huskyResults]);
 }
 
-async function scaffoldEslint ({
-  config,
-  projectRoot,
-  buildDirectory,
-  additionalConfiguration
-}) {
-  const {
-    scope
-  } = config;
-  const {
-    ignore
-  } = additionalConfiguration;
-  const ignores = deepmerge(ignore, {
-    directories: [`/${buildDirectory}/`]
-  });
-  return scaffold$3({
-    scope,
-    projectRoot,
-    ignore: {
-      directories: ignores.directories
-    }
-  });
+async function scaffoldEslint ({config, projectRoot, buildDirectory, additionalConfiguration}) {
+  const {scope} = config;
+  const {ignore} = additionalConfiguration;
+  const ignores = deepmerge(ignore, {directories: [`/${buildDirectory}/`]});
+
+  return scaffold$3({scope, projectRoot, ignore: {directories: ignores.directories}});
 }
 
-async function scaffoldRemark ({
-  config,
-  projectRoot,
-  projectType,
-  vcs,
-  dialect
-}) {
+async function scaffoldRemark ({config, projectRoot, projectType, vcs, dialect}) {
   await write({
     format: fileTypes.JSON,
     path: projectRoot,
@@ -1543,28 +1308,30 @@ async function scaffoldRemark ({
         bullet: '*',
         incrementListMarker: false
       },
-      plugins: [config, ['remark-toc', {
-        tight: true
-      }], ...(projectTypes.PACKAGE === projectType ? [['remark-usage', {
-        heading: 'example'
-      }]] : []), ...(!vcs ? [['validate-links', {
-        repository: false
-      }]] : [])]
+      plugins: [
+        config,
+        ['remark-toc', {tight: true}],
+        ...projectTypes.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
+        ...!vcs ? [['validate-links', {repository: false}]] : []
+      ]
     }
   });
-  return deepmerge({
-    devDependencies: [config, 'remark-cli', 'remark-toc'],
-    scripts: {
-      'lint:md': 'remark . --frail',
-      'generate:md': 'remark . --output'
-    }
-  }, _objectSpread2({}, projectTypes.PACKAGE === projectType && _objectSpread2({
-    devDependencies: ['remark-usage']
-  }, dialects.COMMON_JS !== dialect && {
-    scripts: {
-      'pregenerate:md': 'run-s build'
+
+  return deepmerge(
+    {
+      devDependencies: [config, 'remark-cli', 'remark-toc'],
+      scripts: {
+        'lint:md': 'remark . --frail',
+        'generate:md': 'remark . --output'
+      }
+    },
+    {
+      ...projectTypes.PACKAGE === projectType && {
+        devDependencies: ['remark-usage'],
+        ...dialects.COMMON_JS !== dialect && {scripts: {'pregenerate:md': 'run-s build'}}
+      }
     }
-  })));
+  );
 }
 
 async function scaffoldCodeStyle ({
@@ -1577,22 +1344,28 @@ async function scaffoldCodeStyle ({
   buildDirectory,
   eslint
 }) {
-  return deepmerge.all(await Promise.all([configs.eslint && configureLinting ? scaffoldEslint({
-    projectRoot,
-    config: configs.eslint,
-    buildDirectory,
-    additionalConfiguration: eslint
-  }) : {}, scaffoldRemark({
-    projectRoot,
-    projectType,
-    dialect,
-    vcs,
-    config: configs.remark || '@form8ion/remark-lint-preset'
-  })]));
+  return deepmerge.all(await Promise.all([
+    configs.eslint && configureLinting
+      && scaffoldEslint({
+        projectRoot,
+        config: configs.eslint,
+        buildDirectory,
+        additionalConfiguration: eslint
+      }),
+    scaffoldRemark({
+      projectRoot,
+      projectType,
+      dialect,
+      vcs,
+      config: configs.remark || '@form8ion/remark-lint-preset'
+    }),
+    scaffold$4({projectRoot, config: configs.prettier})
+  ].filter(Boolean)));
 }
 
 async function scaffolder (options) {
   info('Initializing JavaScript project');
+
   const {
     projectRoot,
     projectName,
@@ -1613,6 +1386,7 @@ async function scaffolder (options) {
     pathWithinParent,
     registries
   } = validate(options);
+
   const {
     tests,
     projectType,
@@ -1625,13 +1399,11 @@ async function scaffolder (options) {
     packageManager,
     dialect
   } = await prompt(overrides, ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
-  info('Writing project files', {
-    level: 'secondary'
-  });
+
+  info('Writing project files', {level: 'secondary'});
+
   const packageName = buildPackageName(projectName, scope);
-  const {
-    homepage: projectHomepage
-  } = await scaffoldPackage({
+  const {homepage: projectHomepage} = await scaffoldPackage({
     projectRoot,
     projectType,
     dialect,
@@ -1642,111 +1414,106 @@ async function scaffolder (options) {
     description,
     pathWithinParent
   });
-  const [projectTypeResults, verificationResults] = await Promise.all([scaffoldProjectType({
-    projectType,
-    projectRoot,
-    projectName,
-    packageName,
-    packageManager,
-    visibility,
-    applicationTypes,
-    packageTypes,
-    packageBundlers,
-    monorepoTypes,
-    scope,
-    tests,
-    vcs,
-    decisions,
-    dialect,
-    publishRegistry: registries.publish
-  }), scaffoldVerification({
-    projectRoot,
-    dialect,
-    visibility,
-    packageManager,
-    vcs,
-    registries,
-    tests,
-    unitTestFrameworks,
-    decisions,
-    pathWithinParent
-  })]);
-  const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([scaffoldNodeVersion({
-    projectRoot,
-    nodeVersionCategory
-  }), scaffoldNpmConfig({
-    projectType,
-    projectRoot,
-    registries
-  }), scaffoldDialect({
-    dialect,
-    configs,
-    projectRoot,
-    projectType,
-    buildDirectory: projectTypeResults.buildDirectory,
-    testFilenamePattern: verificationResults.testFilenamePattern
-  }), scaffoldCodeStyle({
-    projectRoot,
-    projectType,
-    dialect,
-    configs,
-    vcs,
-    configureLinting,
-    buildDirectory: projectTypeResults.buildDirectory,
-    eslint: verificationResults.eslint
-  })]);
-  const mergedContributions = deepmerge.all([...(await Promise.all([scaffoldChoice(hosts, chosenHost, {
-    buildDirectory: `./${projectTypeResults.buildDirectory}`,
-    projectRoot,
-    projectName,
-    nodeVersion
-  }), scaffoldChoice(ciServices, ci, {
-    projectRoot,
-    vcs,
-    visibility,
-    projectType,
-    projectName,
-    nodeVersion,
-    tests
-  }), scaffold$4({
-    projectRoot,
-    projectType,
-    configs,
-    pathWithinParent
-  })])), projectTypeResults, verificationResults, codeStyleResults, npmResults, dialectResults]);
+  const [projectTypeResults, verificationResults] = await Promise.all([
+    scaffoldProjectType({
+      projectType,
+      projectRoot,
+      projectName,
+      packageName,
+      packageManager,
+      visibility,
+      applicationTypes,
+      packageTypes,
+      packageBundlers,
+      monorepoTypes,
+      scope,
+      tests,
+      vcs,
+      decisions,
+      dialect,
+      publishRegistry: registries.publish
+    }),
+    scaffoldVerification({
+      projectRoot,
+      dialect,
+      visibility,
+      packageManager,
+      vcs,
+      registries,
+      tests,
+      unitTestFrameworks,
+      decisions,
+      pathWithinParent
+    })
+  ]);
+  const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([
+    scaffoldNodeVersion({projectRoot, nodeVersionCategory}),
+    scaffoldNpmConfig({projectType, projectRoot, registries}),
+    scaffoldDialect({
+      dialect,
+      configs,
+      projectRoot,
+      projectType,
+      buildDirectory: projectTypeResults.buildDirectory,
+      testFilenamePattern: verificationResults.testFilenamePattern
+    }),
+    scaffoldCodeStyle({
+      projectRoot,
+      projectType,
+      dialect,
+      configs,
+      vcs,
+      configureLinting,
+      buildDirectory: projectTypeResults.buildDirectory,
+      eslint: verificationResults.eslint
+    })
+  ]);
+  const mergedContributions = deepmerge.all([
+    ...(await Promise.all([
+      scaffoldChoice(
+        hosts,
+        chosenHost,
+        {buildDirectory: `./${projectTypeResults.buildDirectory}`, projectRoot, projectName, nodeVersion}
+      ),
+      scaffoldChoice(ciServices, ci, {projectRoot, vcs, visibility, projectType, projectName, nodeVersion, tests}),
+      scaffold$5({projectRoot, projectType, configs, pathWithinParent})
+    ])),
+    projectTypeResults,
+    verificationResults,
+    codeStyleResults,
+    npmResults,
+    dialectResults
+  ]);
+
   const liftResults = await lift({
-    results: deepmerge({
-      devDependencies: ['npm-run-all'],
-      packageManager
-    }, mergedContributions),
+    results: deepmerge({devDependencies: ['npm-run-all'], packageManager}, mergedContributions),
     projectRoot,
     configs,
     vcs
   });
+
   return {
     badges: buildBadgesDetails([mergedContributions, liftResults]),
-    documentation: scaffoldDocumentation({
-      projectTypeResults,
-      packageManager
-    }),
+    documentation: scaffoldDocumentation({projectTypeResults, packageManager}),
     tags: projectTypeResults.tags,
     vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
     verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`,
-    projectDetails: _objectSpread2({}, projectHomepage && {
-      homepage: projectHomepage
-    }),
+    projectDetails: {...projectHomepage && {homepage: projectHomepage}},
     nextSteps: mergedContributions.nextSteps
   };
 }
 
-async function test ({
-  projectRoot
-}) {
-  const [nvmIsConfigured, packageLockExists, yarnLockExists] = await Promise.all([fileExists(`${projectRoot}/.nvmrc`), fileExists(`${projectRoot}/package-lock.json`), fileExists(`${projectRoot}/yarn.lock`)]);
+async function test ({projectRoot}) {
+  const [nvmIsConfigured, packageLockExists, yarnLockExists] = await Promise.all([
+    fileExists(`${projectRoot}/.nvmrc`),
+    fileExists(`${projectRoot}/package-lock.json`),
+    fileExists(`${projectRoot}/yarn.lock`)
+  ]);
+
   return nvmIsConfigured || packageLockExists || yarnLockExists;
 }
 
-const questionNames = _objectSpread2(_objectSpread2({}, questionNames$2), questionNames$1);
+const questionNames = {...questionNames$2, ...questionNames$1};
 
 export { lift, questionNames, scaffolder as scaffold, scaffoldUnitTesting, test };
 //# sourceMappingURL=index.mjs.map