@quilted/create 0.1.21 → 0.1.24

package/build/esm/package-manager.mjs

@@ -1,299 +1,87 @@
-import { _ as _asyncToGenerator, r as regenerator } from './index.mjs';
-import * as path from 'path';
-import { relative } from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
-  if (_i == null) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-
-  var _s, _e;
-
-  try {
-    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-
-  return _arr;
-}
+import * as path from 'node:path';
+import { relative } from 'node:path';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import './index.mjs';
 
-function _arrayLikeToArray$3(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
-
-  return arr2;
-}
-
-function _unsupportedIterableToArray$3(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray$3(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$3(arr, i) || _nonIterableRest();
-}
-
-function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen); }
-
-function _arrayLikeToArray$2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 function loadTemplate(name) {
-  var templateRootPromise;
+  let templateRootPromise;
   return {
-    copy: function copy(to, handleFile) {
-      return _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
-        var _templateRootPromise;
-
-        var templateRoot, targetRoot, files, _iterator, _step, _file, targetPath;
-
-        return regenerator.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                (_templateRootPromise = templateRootPromise) !== null && _templateRootPromise !== void 0 ? _templateRootPromise : templateRootPromise = templateDirectory(name);
-                _context.next = 3;
-                return templateRootPromise;
-
-              case 3:
-                templateRoot = _context.sent;
-                targetRoot = path.resolve(to);
-                files = fs.readdirSync(templateRoot).filter(function (file) {
-                  return !path.basename(file).startsWith('.');
-                });
-                _iterator = _createForOfIteratorHelper$2(files);
-                _context.prev = 7;
-
-                _iterator.s();
-
-              case 9:
-                if ((_step = _iterator.n()).done) {
-                  _context.next = 18;
-                  break;
-                }
-
-                _file = _step.value;
-
-                if (!handleFile) {
-                  _context.next = 14;
-                  break;
-                }
-
-                if (handleFile(_file)) {
-                  _context.next = 14;
-                  break;
-                }
-
-                return _context.abrupt("continue", 16);
-
-              case 14:
-                targetPath = path.join(targetRoot, _file.startsWith('_') ? ".".concat(_file.slice(1)) : _file);
-
-                _copy(path.join(templateRoot, _file), targetPath);
-
-              case 16:
-                _context.next = 9;
-                break;
-
-              case 18:
-                _context.next = 23;
-                break;
-
-              case 20:
-                _context.prev = 20;
-                _context.t0 = _context["catch"](7);
-
-                _iterator.e(_context.t0);
-
-              case 23:
-                _context.prev = 23;
+    async copy(to, handleFile) {
+      var _templateRootPromise;
+
+      (_templateRootPromise = templateRootPromise) !== null && _templateRootPromise !== void 0 ? _templateRootPromise : templateRootPromise = templateDirectory(name);
+      const templateRoot = await templateRootPromise;
+      const targetRoot = path.resolve(to);
+      const files = fs.readdirSync(templateRoot).filter(file => !path.basename(file).startsWith('.'));
+
+      for (const file of files) {
+        if (handleFile) {
+          if (!handleFile(file)) {
+            continue;
+          }
+        }
 
-                _iterator.f();
+        const targetPath = path.join(targetRoot, file.startsWith('_') ? `.${file.slice(1)}` : file);
+        copy(path.join(templateRoot, file), targetPath);
+      }
+    },
 
-                return _context.finish(23);
+    async read(file) {
+      var _templateRootPromise2;
 
-              case 26:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, null, [[7, 20, 23, 26]]);
-      }))();
-    },
-    read: function read(file) {
-      return _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
-        var _templateRootPromise2;
-
-        var templateRoot;
-        return regenerator.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                (_templateRootPromise2 = templateRootPromise) !== null && _templateRootPromise2 !== void 0 ? _templateRootPromise2 : templateRootPromise = templateDirectory(name);
-                _context2.next = 3;
-                return templateRootPromise;
-
-              case 3:
-                templateRoot = _context2.sent;
-                return _context2.abrupt("return", fs.readFileSync(path.join(templateRoot, file), {
-                  encoding: 'utf8'
-                }));
-
-              case 5:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }))();
+      (_templateRootPromise2 = templateRootPromise) !== null && _templateRootPromise2 !== void 0 ? _templateRootPromise2 : templateRootPromise = templateDirectory(name);
+      const templateRoot = await templateRootPromise;
+      return fs.readFileSync(path.join(templateRoot, file), {
+        encoding: 'utf8'
+      });
     }
+
   };
 }
 function createOutputTarget(target) {
   return {
     root: target,
-    read: function read(file) {
+
+    read(file) {
       return fs.promises.readFile(path.resolve(target, file), {
         encoding: 'utf8'
       });
     },
-    write: function write(file, content) {
-      return _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3() {
-        return regenerator.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                _context3.next = 2;
-                return writeFile(path.resolve(target, file), content);
-
-              case 2:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3);
-      }))();
+
+    async write(file, content) {
+      await writeFile(path.resolve(target, file), content);
     }
-  };
-}
-var packageRootPromise;
 
-function templateDirectory(_x) {
-  return _templateDirectory.apply(this, arguments);
+  };
 }
+let packageRootPromise;
 
-function _templateDirectory() {
-  _templateDirectory = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(name) {
-    return regenerator.wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            _context4.t0 = path;
-            _context4.next = 3;
-            return getPackageRoot();
-
-          case 3:
-            _context4.t1 = _context4.sent;
-            _context4.t2 = name;
-            return _context4.abrupt("return", _context4.t0.join.call(_context4.t0, _context4.t1, 'templates', _context4.t2));
-
-          case 6:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee4);
-  }));
-  return _templateDirectory.apply(this, arguments);
+async function templateDirectory(name) {
+  return path.join(await getPackageRoot(), 'templates', name);
 }
 
-function getPackageRoot() {
-  return _getPackageRoot.apply(this, arguments);
-}
+async function getPackageRoot() {
+  if (!packageRootPromise) {
+    packageRootPromise = (async () => {
+      const {
+        packageDirectory
+      } = await import('./index2.mjs');
+      return packageDirectory({
+        cwd: path.dirname(fileURLToPath(import.meta.url))
+      });
+    })();
+  }
 
-function _getPackageRoot() {
-  _getPackageRoot = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6() {
-    return regenerator.wrap(function _callee6$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            if (!packageRootPromise) {
-              packageRootPromise = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5() {
-                var _yield$import, packageDirectory;
-
-                return regenerator.wrap(function _callee5$(_context5) {
-                  while (1) {
-                    switch (_context5.prev = _context5.next) {
-                      case 0:
-                        _context5.next = 2;
-                        return import('./index2.mjs');
-
-                      case 2:
-                        _yield$import = _context5.sent;
-                        packageDirectory = _yield$import.packageDirectory;
-                        return _context5.abrupt("return", packageDirectory({
-                          cwd: path.dirname(fileURLToPath(import.meta.url))
-                        }));
-
-                      case 5:
-                      case "end":
-                        return _context5.stop();
-                    }
-                  }
-                }, _callee5);
-              }))();
-            }
-
-            return _context6.abrupt("return", packageRootPromise);
-
-          case 2:
-          case "end":
-            return _context6.stop();
-        }
-      }
-    }, _callee6);
-  }));
-  return _getPackageRoot.apply(this, arguments);
+  return packageRootPromise;
 }
 
 function toValidPackageName(projectName) {
   return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@/]+/g, '-');
 }
 
-function _copy(source, destination) {
-  var stat = fs.statSync(source);
+function copy(source, destination) {
+  const stat = fs.statSync(source);
 
   if (stat.isDirectory()) {
     copyDirectory(source, destination);
@@ -302,575 +90,210 @@ function _copy(source, destination) {
   }
 }
 
-function copyDirectory(_x2, _x3) {
-  return _copyDirectory.apply(this, arguments);
-}
-
-function _copyDirectory() {
-  _copyDirectory = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7(source, destination) {
-    var _iterator2, _step2, _file2, srcFile, destFile;
-
-    return regenerator.wrap(function _callee7$(_context7) {
-      while (1) {
-        switch (_context7.prev = _context7.next) {
-          case 0:
-            fs.mkdirSync(destination, {
-              recursive: true
-            });
-            _iterator2 = _createForOfIteratorHelper$2(fs.readdirSync(source));
-
-            try {
-              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                _file2 = _step2.value;
-                srcFile = path.resolve(source, _file2);
-                destFile = path.resolve(destination, _file2);
-
-                _copy(srcFile, destFile);
-              }
-            } catch (err) {
-              _iterator2.e(err);
-            } finally {
-              _iterator2.f();
-            }
-
-          case 3:
-          case "end":
-            return _context7.stop();
-        }
-      }
-    }, _callee7);
-  }));
-  return _copyDirectory.apply(this, arguments);
-}
-
-function writeFile(_x4, _x5) {
-  return _writeFile.apply(this, arguments);
-}
-
-function _writeFile() {
-  _writeFile = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee8(file, content) {
-    return regenerator.wrap(function _callee8$(_context8) {
-      while (1) {
-        switch (_context8.prev = _context8.next) {
-          case 0:
-            _context8.next = 2;
-            return fs.promises.writeFile(file, content);
-
-          case 2:
-          case "end":
-            return _context8.stop();
-        }
-      }
-    }, _callee8);
-  }));
-  return _writeFile.apply(this, arguments);
-}
+async function copyDirectory(source, destination) {
+  fs.mkdirSync(destination, {
+    recursive: true
+  });
 
-function isEmpty(_x6) {
-  return _isEmpty.apply(this, arguments);
+  for (const file of fs.readdirSync(source)) {
+    const srcFile = path.resolve(source, file);
+    const destFile = path.resolve(destination, file);
+    copy(srcFile, destFile);
+  }
 }
 
-function _isEmpty() {
-  _isEmpty = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee9(path) {
-    return regenerator.wrap(function _callee9$(_context9) {
-      while (1) {
-        switch (_context9.prev = _context9.next) {
-          case 0:
-            return _context9.abrupt("return", fs.readdirSync(path).length === 0);
-
-          case 1:
-          case "end":
-            return _context9.stop();
-        }
-      }
-    }, _callee9);
-  }));
-  return _isEmpty.apply(this, arguments);
+async function writeFile(file, content) {
+  await fs.promises.writeFile(file, content);
 }
-
-function emptyDirectory(_x7) {
-  return _emptyDirectory.apply(this, arguments);
+async function isEmpty(path) {
+  return fs.readdirSync(path).length === 0;
 }
+async function emptyDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
 
-function _emptyDirectory() {
-  _emptyDirectory = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee10(dir) {
-    var _iterator3, _step3, _file3;
-
-    return regenerator.wrap(function _callee10$(_context10) {
-      while (1) {
-        switch (_context10.prev = _context10.next) {
-          case 0:
-            if (fs.existsSync(dir)) {
-              _context10.next = 2;
-              break;
-            }
-
-            return _context10.abrupt("return");
-
-          case 2:
-            _iterator3 = _createForOfIteratorHelper$2(fs.readdirSync(dir));
-
-            try {
-              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                _file3 = _step3.value;
-                fs.rmSync(path.resolve(dir, _file3), {
-                  force: true,
-                  recursive: true
-                });
-              }
-            } catch (err) {
-              _iterator3.e(err);
-            } finally {
-              _iterator3.f();
-            }
-
-          case 4:
-          case "end":
-            return _context10.stop();
-        }
-      }
-    }, _callee10);
-  }));
-  return _emptyDirectory.apply(this, arguments);
+  for (const file of fs.readdirSync(dir)) {
+    fs.rmSync(path.resolve(dir, file), {
+      force: true,
+      recursive: true
+    });
+  }
 }
-
 function relativeDirectoryForDisplay(relativeDirectory) {
-  return relativeDirectory.startsWith('.') ? relativeDirectory : ".".concat(path.sep).concat(relativeDirectory);
-}
-function format(_x8, _x9) {
-  return _format.apply(this, arguments);
-}
-
-function _format() {
-  _format = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee11(content, _ref) {
-    var parser, _yield$Promise$all, _yield$Promise$all2, format, babel, yaml;
-
-    return regenerator.wrap(function _callee11$(_context11) {
-      while (1) {
-        switch (_context11.prev = _context11.next) {
-          case 0:
-            parser = _ref.as;
-            _context11.next = 3;
-            return Promise.all([import('./standalone.mjs').then(function (n) { return n.s; }), import('./parser-babel.mjs').then(function (n) { return n.p; }), import('./parser-yaml.mjs').then(function (n) { return n.p; })]);
-
-          case 3:
-            _yield$Promise$all = _context11.sent;
-            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 3);
-            format = _yield$Promise$all2[0].format;
-            babel = _yield$Promise$all2[1]["default"];
-            yaml = _yield$Promise$all2[2]["default"];
-            return _context11.abrupt("return", format(content, {
-              arrowParens: 'always',
-              bracketSpacing: false,
-              singleQuote: true,
-              trailingComma: 'all',
-              parser: parser,
-              plugins: [babel, yaml]
-            }));
-
-          case 9:
-          case "end":
-            return _context11.stop();
-        }
-      }
-    }, _callee11);
-  }));
-  return _format.apply(this, arguments);
-}
-
-function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+  return relativeDirectory.startsWith('.') ? relativeDirectory : `.${path.sep}${relativeDirectory}`;
+}
+async function format(content, {
+  as: parser
+}) {
+  const [{
+    format
+  }, {
+    default: babel
+  }, {
+    default: typescript
+  }, {
+    default: yaml
+  }] = await Promise.all([import('./standalone.mjs').then(function (n) { return n.s; }), import('./parser-babel.mjs').then(function (n) { return n.p; }), import('./parser-typescript.mjs').then(function (n) { return n.p; }), import('./parser-yaml.mjs').then(function (n) { return n.p; })]);
+  return format(content, {
+    arrowParens: 'always',
+    bracketSpacing: false,
+    singleQuote: true,
+    trailingComma: 'all',
+    parser,
+    plugins: [babel, typescript, yaml]
+  });
+}
+function mergeDependencies(first = {}, second = {}) {
+  const all = { ...first,
+    ...second
+  };
+  const merged = {};
 
-function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+  for (const [key, value] of Object.entries(all).sort(([keyOne], [keyTwo]) => keyOne.localeCompare(keyTwo))) {
+    merged[key] = value;
+  }
 
-function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-var ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
-function addToTsConfig(_x, _x2) {
-  return _addToTsConfig.apply(this, arguments);
+  return merged;
 }
 
-function _addToTsConfig() {
-  _addToTsConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(directory, output) {
-    var _tsconfig$references;
-
-    var tsconfig, relativePath, relativeForDisplay, hasExistingReference, referenceFormat, _iterator, _step, _path, path;
-
-    return regenerator.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.t0 = JSON;
-            _context.next = 3;
-            return output.read('tsconfig.json');
-
-          case 3:
-            _context.t1 = _context.sent;
-            tsconfig = _context.t0.parse.call(_context.t0, _context.t1);
-            (_tsconfig$references = tsconfig.references) !== null && _tsconfig$references !== void 0 ? _tsconfig$references : tsconfig.references = [];
-            relativePath = relative(output.root, directory);
-            relativeForDisplay = relativeDirectoryForDisplay(relativePath);
-
-            if (!(tsconfig.references.length === 0)) {
-              _context.next = 12;
-              break;
-            }
-
-            tsconfig.references.push({
-              path: relativeForDisplay
-            });
-            _context.next = 53;
-            break;
-
-          case 12:
-            hasExistingReference = false;
-            referenceFormat = 'pretty-relative';
-            _iterator = _createForOfIteratorHelper$1(tsconfig.references);
-            _context.prev = 15;
-
-            _iterator.s();
+const ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
+async function addToTsConfig(directory, output) {
+  var _tsconfig$references;
 
-          case 17:
-            if ((_step = _iterator.n()).done) {
-              _context.next = 44;
-              break;
-            }
+  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
+  (_tsconfig$references = tsconfig.references) !== null && _tsconfig$references !== void 0 ? _tsconfig$references : tsconfig.references = [];
+  const relativePath = relative(output.root, directory);
+  const relativeForDisplay = relativeDirectoryForDisplay(relativePath);
 
-            _path = _step.value.path;
-
-            if (!_path.startsWith('./')) {
-              _context.next = 31;
-              break;
-            }
-
-            if (!ENDS_WITH_TSCONFIG.test(_path)) {
-              _context.next = 25;
-              break;
-            }
-
-            referenceFormat = 'pretty-tsconfig';
-
-            if (!(_path === "".concat(relativeForDisplay, "/tsconfig.json"))) {
-              _context.next = 25;
-              break;
-            }
-
-            hasExistingReference = true;
-            return _context.abrupt("break", 44);
-
-          case 25:
-            referenceFormat = 'pretty-relative';
-
-            if (!(_path === relativeForDisplay)) {
-              _context.next = 29;
-              break;
-            }
-
-            hasExistingReference = true;
-            return _context.abrupt("break", 44);
-
-          case 29:
-            _context.next = 42;
-            break;
-
-          case 31:
-            if (!ENDS_WITH_TSCONFIG.test(_path)) {
-              _context.next = 38;
-              break;
-            }
-
-            referenceFormat = 'tsconfig';
+  if (tsconfig.references.length === 0) {
+    tsconfig.references.push({
+      path: relativeForDisplay
+    });
+  } else {
+    let hasExistingReference = false;
+    let referenceFormat = 'pretty-relative';
 
-            if (!(_path === "".concat(relativePath, "/tsconfig.json"))) {
-              _context.next = 36;
-              break;
-            }
+    for (const {
+      path
+    } of tsconfig.references) {
+      if (path.startsWith('./')) {
+        if (ENDS_WITH_TSCONFIG.test(path)) {
+          referenceFormat = 'pretty-tsconfig';
 
+          if (path === `${relativeForDisplay}/tsconfig.json`) {
             hasExistingReference = true;
-            return _context.abrupt("break", 44);
-
-          case 36:
-            _context.next = 42;
             break;
+          }
+        }
 
-          case 38:
-            referenceFormat = 'relative';
-
-            if (!(_path === relativePath)) {
-              _context.next = 42;
-              break;
-            }
+        referenceFormat = 'pretty-relative';
 
-            hasExistingReference = true;
-            return _context.abrupt("break", 44);
-
-          case 42:
-            _context.next = 17;
-            break;
+        if (path === relativeForDisplay) {
+          hasExistingReference = true;
+          break;
+        }
+      } else if (ENDS_WITH_TSCONFIG.test(path)) {
+        referenceFormat = 'tsconfig';
 
-          case 44:
-            _context.next = 49;
-            break;
+        if (path === `${relativePath}/tsconfig.json`) {
+          hasExistingReference = true;
+          break;
+        }
+      } else {
+        referenceFormat = 'relative';
 
-          case 46:
-            _context.prev = 46;
-            _context.t2 = _context["catch"](15);
-
-            _iterator.e(_context.t2);
-
-          case 49:
-            _context.prev = 49;
-
-            _iterator.f();
-
-            return _context.finish(49);
-
-          case 52:
-            if (!hasExistingReference) {
-              if (referenceFormat === 'pretty-tsconfig') {
-                path = "".concat(relativeForDisplay, "/tsconfig.json");
-              } else if (referenceFormat === 'pretty-relative') {
-                path = relativeForDisplay;
-              } else if (referenceFormat === 'tsconfig') {
-                path = "".concat(relativePath, "/tsconfig.json");
-              } else {
-                path = relativePath;
-              }
-
-              tsconfig.references.push({
-                path: path
-              });
-            }
-
-          case 53:
-            tsconfig.references = tsconfig.references.sort(function (_ref, _ref2) {
-              var pathOne = _ref.path;
-              var pathTwo = _ref2.path;
-              return pathOne.localeCompare(pathTwo);
-            });
-            _context.t3 = output;
-            _context.next = 57;
-            return format(JSON.stringify(tsconfig), {
-              as: 'json'
-            });
-
-          case 57:
-            _context.t4 = _context.sent;
-            _context.next = 60;
-            return _context.t3.write.call(_context.t3, 'tsconfig.json', _context.t4);
-
-          case 60:
-          case "end":
-            return _context.stop();
+        if (path === relativePath) {
+          hasExistingReference = true;
+          break;
         }
       }
-    }, _callee, null, [[15, 46, 49, 52]]);
-  }));
-  return _addToTsConfig.apply(this, arguments);
-}
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray$3(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$3(arr) || _nonIterableSpread();
-}
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+    }
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-function addToPackageManagerWorkspaces(_x, _x2, _x3) {
-  return _addToPackageManagerWorkspaces.apply(this, arguments);
-}
+    if (!hasExistingReference) {
+      let path;
+
+      if (referenceFormat === 'pretty-tsconfig') {
+        path = `${relativeForDisplay}/tsconfig.json`;
+      } else if (referenceFormat === 'pretty-relative') {
+        path = relativeForDisplay;
+      } else if (referenceFormat === 'tsconfig') {
+        path = `${relativePath}/tsconfig.json`;
+      } else {
+        path = relativePath;
+      }
 
-function _addToPackageManagerWorkspaces() {
-  _addToPackageManagerWorkspaces = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(directory, output, packageManager) {
-    var _workspaceYaml$packag, _yield$import, parse, stringify, workspaceYaml, _packageJson$workspac, packageJson;
-
-    return regenerator.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            if (!(packageManager === 'pnpm')) {
-              _context.next = 22;
-              break;
-            }
-
-            _context.next = 3;
-            return import('./index3.mjs');
-
-          case 3:
-            _yield$import = _context.sent;
-            parse = _yield$import.parse;
-            stringify = _yield$import.stringify;
-            _context.t0 = parse;
-            _context.next = 9;
-            return output.read('pnpm-workspace.yaml');
-
-          case 9:
-            _context.t1 = _context.sent;
-            workspaceYaml = (0, _context.t0)(_context.t1);
-            _context.next = 13;
-            return addToWorkspaces(relative(output.root, directory), (_workspaceYaml$packag = workspaceYaml.packages) !== null && _workspaceYaml$packag !== void 0 ? _workspaceYaml$packag : []);
-
-          case 13:
-            workspaceYaml.packages = _context.sent;
-            _context.t2 = output;
-            _context.next = 17;
-            return format(stringify(workspaceYaml), {
-              as: 'yaml'
-            });
-
-          case 17:
-            _context.t3 = _context.sent;
-            _context.next = 20;
-            return _context.t2.write.call(_context.t2, 'pnpm-workspace.yaml', _context.t3);
-
-          case 20:
-            _context.next = 36;
-            break;
+      tsconfig.references.push({
+        path
+      });
+    }
+  }
 
-          case 22:
-            _context.t4 = JSON;
-            _context.next = 25;
-            return output.read('package.json');
-
-          case 25:
-            _context.t5 = _context.sent;
-            packageJson = _context.t4.parse.call(_context.t4, _context.t5);
-            _context.next = 29;
-            return addToWorkspaces(relative(output.root, directory), (_packageJson$workspac = packageJson.workspaces) !== null && _packageJson$workspac !== void 0 ? _packageJson$workspac : []);
-
-          case 29:
-            packageJson.workspaces = _context.sent;
-            _context.t6 = output;
-            _context.next = 33;
-            return format(JSON.stringify(packageJson), {
-              as: 'json-stringify'
-            });
-
-          case 33:
-            _context.t7 = _context.sent;
-            _context.next = 36;
-            return _context.t6.write.call(_context.t6, 'package.json', _context.t7);
-
-          case 36:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
+  tsconfig.references = tsconfig.references.sort(({
+    path: pathOne
+  }, {
+    path: pathTwo
+  }) => pathOne.localeCompare(pathTwo));
+  await output.write('tsconfig.json', await format(JSON.stringify(tsconfig), {
+    as: 'json'
   }));
-  return _addToPackageManagerWorkspaces.apply(this, arguments);
 }
 
-function addToWorkspaces(_x4, _x5) {
-  return _addToWorkspaces.apply(this, arguments);
-}
+async function addToPackageManagerWorkspaces(directory, output, packageManager) {
+  if (packageManager === 'pnpm') {
+    var _workspaceYaml$packag;
 
-function _addToWorkspaces() {
-  _addToWorkspaces = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(relative, workspaces) {
-    var pretty, hasMatch, _yield$import2, minimatch, _iterator, _step, pattern, normalizedPattern;
-
-    return regenerator.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            if (!(workspaces.length === 0)) {
-              _context2.next = 2;
-              break;
-            }
-
-            return _context2.abrupt("return", [relative]);
-
-          case 2:
-            // Default documentation seems to generally exclude leading `./` on paths
-            pretty = false;
-            hasMatch = false;
-            _context2.next = 6;
-            return import('./minimatch.mjs').then(function (n) { return n.m; });
-
-          case 6:
-            _yield$import2 = _context2.sent;
-            minimatch = _yield$import2["default"];
-            _iterator = _createForOfIteratorHelper(workspaces);
-            _context2.prev = 9;
-
-            _iterator.s();
-
-          case 11:
-            if ((_step = _iterator.n()).done) {
-              _context2.next = 20;
-              break;
-            }
-
-            pattern = _step.value;
-            normalizedPattern = pattern;
-
-            if (pattern.startsWith('./')) {
-              pretty = true;
-              normalizedPattern = pattern.slice(2);
-            }
-
-            if (!minimatch(relative, normalizedPattern)) {
-              _context2.next = 18;
-              break;
-            }
-
-            hasMatch = true;
-            return _context2.abrupt("break", 20);
-
-          case 18:
-            _context2.next = 11;
-            break;
-
-          case 20:
-            _context2.next = 25;
-            break;
+    const {
+      parse,
+      stringify
+    } = await import('./index3.mjs').then(function (n) { return n.i; });
+    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
+    workspaceYaml.packages = await addToWorkspaces(relative(output.root, directory), (_workspaceYaml$packag = workspaceYaml.packages) !== null && _workspaceYaml$packag !== void 0 ? _workspaceYaml$packag : []);
+    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
+      as: 'yaml'
+    }));
+  } else {
+    var _packageJson$workspac;
 
-          case 22:
-            _context2.prev = 22;
-            _context2.t0 = _context2["catch"](9);
+    const packageJson = JSON.parse(await output.read('package.json'));
+    packageJson.workspaces = await addToWorkspaces(relative(output.root, directory), (_packageJson$workspac = packageJson.workspaces) !== null && _packageJson$workspac !== void 0 ? _packageJson$workspac : []);
+    await output.write('package.json', await format(JSON.stringify(packageJson), {
+      as: 'json-stringify'
+    }));
+  }
+}
 
-            _iterator.e(_context2.t0);
+async function addToWorkspaces(relative, workspaces) {
+  if (workspaces.length === 0) {
+    return [relative];
+  } // Default documentation seems to generally exclude leading `./` on paths
 
-          case 25:
-            _context2.prev = 25;
 
-            _iterator.f();
+  let pretty = false;
+  let hasMatch = false;
+  const {
+    default: minimatch
+  } = await import('./minimatch.mjs').then(function (n) { return n.m; });
 
-            return _context2.finish(25);
+  for (const pattern of workspaces) {
+    let normalizedPattern = pattern;
 
-          case 28:
-            if (!hasMatch) {
-              _context2.next = 30;
-              break;
-            }
+    if (pattern.startsWith('./')) {
+      pretty = true;
+      normalizedPattern = pattern.slice(2);
+    }
 
-            return _context2.abrupt("return", workspaces);
+    if (minimatch(relative, normalizedPattern)) {
+      hasMatch = true;
+      break;
+    }
+  }
 
-          case 30:
-            return _context2.abrupt("return", [].concat(_toConsumableArray(workspaces), [pretty ? relativeDirectoryForDisplay(relative) : relative]).sort(function (patternOne, patternTwo) {
-              return patternOne.localeCompare(patternTwo);
-            }));
+  if (hasMatch) {
+    return workspaces;
+  }
 
-          case 31:
-          case "end":
-            return _context2.stop();
-        }
-      }
-    }, _callee2, null, [[9, 22, 25, 28]]);
-  }));
-  return _addToWorkspaces.apply(this, arguments);
+  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
 }
 
-export { _slicedToArray as _, addToTsConfig as a, addToPackageManagerWorkspaces as b, createOutputTarget as c, emptyDirectory as e, format as f, isEmpty as i, loadTemplate as l, relativeDirectoryForDisplay as r, toValidPackageName as t };
+export { addToTsConfig as a, addToPackageManagerWorkspaces as b, createOutputTarget as c, emptyDirectory as e, format as f, isEmpty as i, loadTemplate as l, mergeDependencies as m, relativeDirectoryForDisplay as r, toValidPackageName as t };