@quilted/create 0.1.18 → 0.1.21

package/build/cjs/package-manager.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
+var index = require('./index.cjs');
 var path = require('path');
 var fs = require('fs');
 var url = require('url');
-require('./index.cjs');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -26,80 +26,296 @@ function _interopNamespace(e) {
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
+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;
+}
+
+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) {
-  let templateRootPromise;
+  var templateRootPromise;
   return {
-    async copy(to, handleFile) {
-      templateRootPromise ?? (templateRootPromise = templateDirectory(name));
-      const templateRoot = await templateRootPromise;
-      const targetRoot = path__namespace.resolve(to);
-      const files = fs__namespace.readdirSync(templateRoot).filter(file => !path__namespace.basename(file).startsWith('.'));
-
-      for (const file of files) {
-        if (handleFile) {
-          if (!handleFile(file)) {
-            continue;
-          }
-        }
+    copy: function copy(to, handleFile) {
+      return index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee() {
+        var _templateRootPromise;
 
-        const targetPath = path__namespace.join(targetRoot, file.startsWith('_') ? `.${file.slice(1)}` : file);
-        copy(path__namespace.join(templateRoot, file), targetPath);
-      }
-    },
+        var templateRoot, targetRoot, files, _iterator, _step, _file, targetPath;
 
-    async read(file) {
-      templateRootPromise ?? (templateRootPromise = templateDirectory(name));
-      const templateRoot = await templateRootPromise;
-      return fs__namespace.readFileSync(path__namespace.join(templateRoot, file), {
-        encoding: 'utf8'
-      });
-    }
+        return index.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__namespace.resolve(to);
+                files = fs__namespace.readdirSync(templateRoot).filter(function (file) {
+                  return !path__namespace.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__namespace.join(targetRoot, _file.startsWith('_') ? ".".concat(_file.slice(1)) : _file);
+
+                _copy(path__namespace.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;
+
+                _iterator.f();
+
+                return _context.finish(23);
+
+              case 26:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[7, 20, 23, 26]]);
+      }))();
+    },
+    read: function read(file) {
+      return index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee2() {
+        var _templateRootPromise2;
+
+        var templateRoot;
+        return index.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__namespace.readFileSync(path__namespace.join(templateRoot, file), {
+                  encoding: 'utf8'
+                }));
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }))();
+    }
   };
 }
 function createOutputTarget(target) {
   return {
     root: target,
-
-    read(file) {
+    read: function read(file) {
       return fs__namespace.promises.readFile(path__namespace.resolve(target, file), {
         encoding: 'utf8'
       });
     },
-
-    async write(file, content) {
-      await writeFile(path__namespace.resolve(target, file), content);
+    write: function write(file, content) {
+      return index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee3() {
+        return index.regenerator.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return writeFile(path__namespace.resolve(target, file), content);
+
+              case 2:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }))();
     }
-
   };
 }
-let packageRootPromise;
+var packageRootPromise;
 
-async function templateDirectory(name) {
-  return path__namespace.join(await getPackageRoot(), 'templates', name);
+function templateDirectory(_x) {
+  return _templateDirectory.apply(this, arguments);
 }
 
-async function getPackageRoot() {
-  if (!packageRootPromise) {
-    packageRootPromise = (async () => {
-      const {
-        packageDirectory
-      } = await Promise.resolve().then(function () { return require('./index2.cjs'); });
-      return packageDirectory({
-        cwd: path__namespace.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('package-manager.cjs', document.baseURI).href))))
-      });
-    })();
-  }
+function _templateDirectory() {
+  _templateDirectory = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee4(name) {
+    return index.regenerator.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.t0 = path__namespace;
+            _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);
+}
+
+function getPackageRoot() {
+  return _getPackageRoot.apply(this, arguments);
+}
 
-  return packageRootPromise;
+function _getPackageRoot() {
+  _getPackageRoot = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee6() {
+    return index.regenerator.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            if (!packageRootPromise) {
+              packageRootPromise = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee5() {
+                var _yield$import, packageDirectory;
+
+                return index.regenerator.wrap(function _callee5$(_context5) {
+                  while (1) {
+                    switch (_context5.prev = _context5.next) {
+                      case 0:
+                        _context5.next = 2;
+                        return Promise.resolve().then(function () { return require('./index2.cjs'); });
+
+                      case 2:
+                        _yield$import = _context5.sent;
+                        packageDirectory = _yield$import.packageDirectory;
+                        return _context5.abrupt("return", packageDirectory({
+                          cwd: path__namespace.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('package-manager.cjs', document.baseURI).href))))
+                        }));
+
+                      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);
 }
 
 function toValidPackageName(projectName) {
   return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@/]+/g, '-');
 }
 
-function copy(source, destination) {
-  const stat = fs__namespace.statSync(source);
+function _copy(source, destination) {
+  var stat = fs__namespace.statSync(source);
 
   if (stat.isDirectory()) {
     copyDirectory(source, destination);
@@ -108,192 +324,578 @@ function copy(source, destination) {
   }
 }
 
-async function copyDirectory(source, destination) {
-  fs__namespace.mkdirSync(destination, {
-    recursive: true
-  });
+function copyDirectory(_x2, _x3) {
+  return _copyDirectory.apply(this, arguments);
+}
 
-  for (const file of fs__namespace.readdirSync(source)) {
-    const srcFile = path__namespace.resolve(source, file);
-    const destFile = path__namespace.resolve(destination, file);
-    copy(srcFile, destFile);
-  }
+function _copyDirectory() {
+  _copyDirectory = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee7(source, destination) {
+    var _iterator2, _step2, _file2, srcFile, destFile;
+
+    return index.regenerator.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            fs__namespace.mkdirSync(destination, {
+              recursive: true
+            });
+            _iterator2 = _createForOfIteratorHelper$2(fs__namespace.readdirSync(source));
+
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                _file2 = _step2.value;
+                srcFile = path__namespace.resolve(source, _file2);
+                destFile = path__namespace.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);
 }
 
-async function writeFile(file, content) {
-  await fs__namespace.promises.writeFile(file, content);
+function writeFile(_x4, _x5) {
+  return _writeFile.apply(this, arguments);
 }
-async function isEmpty(path) {
-  return fs__namespace.readdirSync(path).length === 0;
+
+function _writeFile() {
+  _writeFile = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee8(file, content) {
+    return index.regenerator.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            _context8.next = 2;
+            return fs__namespace.promises.writeFile(file, content);
+
+          case 2:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  }));
+  return _writeFile.apply(this, arguments);
 }
-async function emptyDirectory(dir) {
-  if (!fs__namespace.existsSync(dir)) {
-    return;
-  }
 
-  for (const file of fs__namespace.readdirSync(dir)) {
-    fs__namespace.rmSync(path__namespace.resolve(dir, file), {
-      force: true,
-      recursive: true
-    });
-  }
+function isEmpty(_x6) {
+  return _isEmpty.apply(this, arguments);
+}
+
+function _isEmpty() {
+  _isEmpty = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee9(path) {
+    return index.regenerator.wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            return _context9.abrupt("return", fs__namespace.readdirSync(path).length === 0);
+
+          case 1:
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee9);
+  }));
+  return _isEmpty.apply(this, arguments);
+}
+
+function emptyDirectory(_x7) {
+  return _emptyDirectory.apply(this, arguments);
+}
+
+function _emptyDirectory() {
+  _emptyDirectory = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee10(dir) {
+    var _iterator3, _step3, _file3;
+
+    return index.regenerator.wrap(function _callee10$(_context10) {
+      while (1) {
+        switch (_context10.prev = _context10.next) {
+          case 0:
+            if (fs__namespace.existsSync(dir)) {
+              _context10.next = 2;
+              break;
+            }
+
+            return _context10.abrupt("return");
+
+          case 2:
+            _iterator3 = _createForOfIteratorHelper$2(fs__namespace.readdirSync(dir));
+
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                _file3 = _step3.value;
+                fs__namespace.rmSync(path__namespace.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);
 }
+
 function relativeDirectoryForDisplay(relativeDirectory) {
-  return relativeDirectory.startsWith('.') ? relativeDirectory : `.${path__namespace.sep}${relativeDirectory}`;
-}
-async function format(content, {
-  as: parser
-}) {
-  const [{
-    format
-  }, {
-    default: babel
-  }, {
-    default: yaml
-  }] = await Promise.all([Promise.resolve().then(function () { return require('./standalone.cjs'); }).then(function (n) { return n.standalone; }), Promise.resolve().then(function () { return require('./parser-babel.cjs'); }).then(function (n) { return n.parserBabel; }), Promise.resolve().then(function () { return require('./parser-yaml.cjs'); }).then(function (n) { return n.parserYaml; })]);
-  return format(content, {
-    arrowParens: 'always',
-    bracketSpacing: false,
-    singleQuote: true,
-    trailingComma: 'all',
-    parser,
-    plugins: [babel, yaml]
-  });
-}
-
-const ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
-async function addToTsConfig(directory, output) {
-  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
-  tsconfig.references ?? (tsconfig.references = []);
-  const relativePath = path.relative(output.root, directory);
-  const relativeForDisplay = relativeDirectoryForDisplay(relativePath);
-
-  if (tsconfig.references.length === 0) {
-    tsconfig.references.push({
-      path: relativeForDisplay
-    });
-  } else {
-    let hasExistingReference = false;
-    let referenceFormat = 'pretty-relative';
+  return relativeDirectory.startsWith('.') ? relativeDirectory : ".".concat(path__namespace.sep).concat(relativeDirectory);
+}
+function format(_x8, _x9) {
+  return _format.apply(this, arguments);
+}
+
+function _format() {
+  _format = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee11(content, _ref) {
+    var parser, _yield$Promise$all, _yield$Promise$all2, format, babel, yaml;
+
+    return index.regenerator.wrap(function _callee11$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            parser = _ref.as;
+            _context11.next = 3;
+            return Promise.all([Promise.resolve().then(function () { return require('./standalone.cjs'); }).then(function (n) { return n.standalone; }), Promise.resolve().then(function () { return require('./parser-babel.cjs'); }).then(function (n) { return n.parserBabel; }), Promise.resolve().then(function () { return require('./parser-yaml.cjs'); }).then(function (n) { return n.parserYaml; })]);
+
+          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; } } }; }
+
+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); }
+
+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);
+}
+
+function _addToTsConfig() {
+  _addToTsConfig = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee(directory, output) {
+    var _tsconfig$references;
+
+    var tsconfig, relativePath, relativeForDisplay, hasExistingReference, referenceFormat, _iterator, _step, _path, path$1;
+
+    return index.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 = path.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;
 
-    for (const {
-      path
-    } of tsconfig.references) {
-      if (path.startsWith('./')) {
-        if (ENDS_WITH_TSCONFIG.test(path)) {
-          referenceFormat = 'pretty-tsconfig';
+          case 12:
+            hasExistingReference = false;
+            referenceFormat = 'pretty-relative';
+            _iterator = _createForOfIteratorHelper$1(tsconfig.references);
+            _context.prev = 15;
+
+            _iterator.s();
+
+          case 17:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 44;
+              break;
+            }
+
+            _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;
+            }
 
-          if (path === `${relativeForDisplay}/tsconfig.json`) {
             hasExistingReference = true;
+            return _context.abrupt("break", 44);
+
+          case 29:
+            _context.next = 42;
             break;
-          }
-        }
 
-        referenceFormat = 'pretty-relative';
+          case 31:
+            if (!ENDS_WITH_TSCONFIG.test(_path)) {
+              _context.next = 38;
+              break;
+            }
 
-        if (path === relativeForDisplay) {
-          hasExistingReference = true;
-          break;
-        }
-      } else if (ENDS_WITH_TSCONFIG.test(path)) {
-        referenceFormat = 'tsconfig';
+            referenceFormat = 'tsconfig';
 
-        if (path === `${relativePath}/tsconfig.json`) {
-          hasExistingReference = true;
-          break;
-        }
-      } else {
-        referenceFormat = 'relative';
+            if (!(_path === "".concat(relativePath, "/tsconfig.json"))) {
+              _context.next = 36;
+              break;
+            }
+
+            hasExistingReference = true;
+            return _context.abrupt("break", 44);
+
+          case 36:
+            _context.next = 42;
+            break;
+
+          case 38:
+            referenceFormat = 'relative';
 
-        if (path === relativePath) {
-          hasExistingReference = true;
-          break;
+            if (!(_path === relativePath)) {
+              _context.next = 42;
+              break;
+            }
+
+            hasExistingReference = true;
+            return _context.abrupt("break", 44);
+
+          case 42:
+            _context.next = 17;
+            break;
+
+          case 44:
+            _context.next = 49;
+            break;
+
+          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$1 = "".concat(relativeForDisplay, "/tsconfig.json");
+              } else if (referenceFormat === 'pretty-relative') {
+                path$1 = relativeForDisplay;
+              } else if (referenceFormat === 'tsconfig') {
+                path$1 = "".concat(relativePath, "/tsconfig.json");
+              } else {
+                path$1 = relativePath;
+              }
+
+              tsconfig.references.push({
+                path: path$1
+              });
+            }
+
+          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();
         }
       }
-    }
+    }, _callee, null, [[15, 46, 49, 52]]);
+  }));
+  return _addToTsConfig.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 _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray$3(arr);
+}
 
-      tsconfig.references.push({
-        path
-      });
-    }
-  }
+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; } } }; }
 
-  tsconfig.references = tsconfig.references.sort(({
-    path: pathOne
-  }, {
-    path: pathTwo
-  }) => pathOne.localeCompare(pathTwo));
-  await output.write('tsconfig.json', await format(JSON.stringify(tsconfig), {
-    as: 'json'
+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);
+}
+
+function _addToPackageManagerWorkspaces() {
+  _addToPackageManagerWorkspaces = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee(directory, output, packageManager) {
+    var _workspaceYaml$packag, _yield$import, parse, stringify, workspaceYaml, _packageJson$workspac, packageJson;
+
+    return index.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 Promise.resolve().then(function () { return require('./index3.cjs'); });
+
+          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(path.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;
+
+          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(path.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);
   }));
+  return _addToPackageManagerWorkspaces.apply(this, arguments);
 }
 
-async function addToPackageManagerWorkspaces(directory, output, packageManager) {
-  if (packageManager === 'pnpm') {
-    const {
-      parse,
-      stringify
-    } = await Promise.resolve().then(function () { return require('./index3.cjs'); }).then(function (n) { return n.index; });
-    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
-    workspaceYaml.packages = await addToWorkspaces(path.relative(output.root, directory), workspaceYaml.packages ?? []);
-    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
-      as: 'yaml'
-    }));
-  } else {
-    const packageJson = JSON.parse(await output.read('package.json'));
-    packageJson.workspaces = await addToWorkspaces(path.relative(output.root, directory), packageJson.workspaces ?? []);
-    await output.write('package.json', await format(JSON.stringify(packageJson), {
-      as: 'json-stringify'
-    }));
-  }
+function addToWorkspaces(_x4, _x5) {
+  return _addToWorkspaces.apply(this, arguments);
 }
 
-async function addToWorkspaces(relative, workspaces) {
-  if (workspaces.length === 0) {
-    return [relative];
-  } // Default documentation seems to generally exclude leading `./` on paths
+function _addToWorkspaces() {
+  _addToWorkspaces = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee2(relative, workspaces) {
+    var pretty, hasMatch, _yield$import2, minimatch, _iterator, _step, pattern, normalizedPattern;
+
+    return index.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 Promise.resolve().then(function () { return require('./minimatch.cjs'); }).then(function (n) { return n.minimatch; });
+
+          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;
 
-  let pretty = false;
-  let hasMatch = false;
-  const {
-    default: minimatch
-  } = await Promise.resolve().then(function () { return require('./minimatch.cjs'); }).then(function (n) { return n.minimatch; });
+          case 22:
+            _context2.prev = 22;
+            _context2.t0 = _context2["catch"](9);
 
-  for (const pattern of workspaces) {
-    let normalizedPattern = pattern;
+            _iterator.e(_context2.t0);
 
-    if (pattern.startsWith('./')) {
-      pretty = true;
-      normalizedPattern = pattern.slice(2);
-    }
+          case 25:
+            _context2.prev = 25;
 
-    if (minimatch(relative, normalizedPattern)) {
-      hasMatch = true;
-      break;
-    }
-  }
+            _iterator.f();
 
-  if (hasMatch) {
-    return workspaces;
-  }
+            return _context2.finish(25);
+
+          case 28:
+            if (!hasMatch) {
+              _context2.next = 30;
+              break;
+            }
 
-  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
+            return _context2.abrupt("return", workspaces);
+
+          case 30:
+            return _context2.abrupt("return", [].concat(_toConsumableArray(workspaces), [pretty ? relativeDirectoryForDisplay(relative) : relative]).sort(function (patternOne, patternTwo) {
+              return patternOne.localeCompare(patternTwo);
+            }));
+
+          case 31:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[9, 22, 25, 28]]);
+  }));
+  return _addToWorkspaces.apply(this, arguments);
 }
 
+exports._slicedToArray = _slicedToArray;
 exports.addToPackageManagerWorkspaces = addToPackageManagerWorkspaces;
 exports.addToTsConfig = addToTsConfig;
 exports.createOutputTarget = createOutputTarget;