@quilted/create 0.1.18 → 0.1.21

package/build/esm/index.mjs

@@ -5,6 +5,444 @@ import 'url';
 import require$$0$1 from 'readline';
 import require$$2 from 'events';
 
+function _taggedTemplateLiteral$1(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
+
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator$5(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+var regeneratorRuntime$1 = {exports: {}};
+
+var _typeof$1 = {exports: {}};
+
+(function (module) {
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
+}
+
+module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(_typeof$1));
+
+(function (module) {
+var _typeof = _typeof$1.exports["default"];
+
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+    return exports;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function define(obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) {
+            if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+          }
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) {
+      keys.push(key);
+    }
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function reset(skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
+        "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+      }
+    },
+    stop: function stop() {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function dispatchException(exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function abrupt(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function complete(record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function finish(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    "catch": function _catch(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(regeneratorRuntime$1));
+
+// TODO(Babel 8): Remove this file.
+
+var runtime = regeneratorRuntime$1.exports();
+var regenerator = runtime;
+
+// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  if (typeof globalThis === "object") {
+    globalThis.regeneratorRuntime = runtime;
+  } else {
+    Function("r", "regeneratorRuntime = r")(runtime);
+  }
+}
+
 const flagSymbol = Symbol('arg flag');
 
 class ArgError extends Error {
@@ -417,13 +855,13 @@ colorette.whiteBright = whiteBright;
 colorette.yellow = yellow;
 colorette.yellowBright = yellowBright;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-var _templateObject = _taggedTemplateLiteral(['', ''], ['', '']);
+var _templateObject$2 = _taggedTemplateLiteral(['', ''], ['', '']);
 
 function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 /**
  * @class TemplateTag
@@ -443,7 +881,7 @@ var TemplateTag = function () {
       transformers[_key] = arguments[_key];
     }
 
-    _classCallCheck(this, TemplateTag);
+    _classCallCheck$1(this, TemplateTag);
 
     this.tag = function (strings) {
       for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
@@ -491,7 +929,7 @@ var TemplateTag = function () {
    */
 
 
-  _createClass(TemplateTag, [{
+  _createClass$1(TemplateTag, [{
     key: 'interimTag',
 
 
@@ -508,7 +946,7 @@ var TemplateTag = function () {
         substitutions[_key3 - 2] = arguments[_key3];
       }
 
-      return this.tag(_templateObject, previousTag.apply(undefined, [template].concat(substitutions)));
+      return this.tag(_templateObject$2, previousTag.apply(undefined, [template].concat(substitutions)));
     }
 
     /**
@@ -778,90 +1216,232 @@ var stripIndent = new TemplateTag(stripIndentTransformer, trimResultTransformer)
 
 new TemplateTag(stripIndentTransformer('all'), trimResultTransformer);
 
-class AbortError extends Error {
-  static test(error) {
-    return error != null && error.code === 'ABORT_ERR';
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
 
-  code = 'ABORT_ERR';
-  name = 'AbortError';
+  return obj;
+}
 
-  constructor(message = 'The operation was aborted') {
-    super(message);
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
   }
+}
 
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
 }
 
-function printHelp({
-  kind,
-  options: customOptions,
-  packageManager
-}) {
-  const command = createCommand(packageManager);
-  const usage = stripIndent`
-    ${bold_1('Usage:')}   ${command} ${kind ? magenta_1(kind) : magenta_1('[kind]')} ${green_1('[name]')} ${cyan_1('[options]')}
-  `;
-  console.log(usage);
-  const example = stripIndent`
-    ${bold_1('Example:')} ${command} ${magenta_1(kind ?? 'app')} ${green_1(`my-${kind ?? 'app'}`)} ${cyan_1('--install')}
-  `;
-  console.log(dim_1(example));
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
 
-  if (!kind) {
-    const kindSection = stripIndent`
-    ${bold_1(magenta_1('kind'))} can be one of the following project types:
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
 
-     - ${magenta_1('app')}, a web application
-     - ${magenta_1('package')}, a shared library of code
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
 
-    You’ll be asked a few additional questions based on the kind you choose.
-  `;
-    console.log();
-    console.log(kindSection);
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
   }
 
-  const optionsSection = stripIndent`
-    ${cyan_1('--name')}
-    The name of the project. When creating a package, you should use the public name you
-    want for the package, including any scope you want to use (example: ${bold_1('@my-org/my-package')}).
-    If you don’t provide a name with this flag, this command will ask you for one later.
+  return _assertThisInitialized(self);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _isNativeReflectConstruct$1() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct$1()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
 
-    ${cyan_1('--directory')}
-    The directory to create the project in. If you don’t provide this flag, Quilt will pick
-    a default directory based on the kind of the project and the name you provided.
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
 
-    ${cyan_1(`--monorepo`)}, ${cyan_1(`--no-monorepo`)}
-    If you aren’t already in a monorepo, this flag will create your new project with some
-    additional structure that allows it to be a monorepo — that is, you will be able to add
-    multiple projects to a single repository.
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var AbortError = /*#__PURE__*/function (_Error) {
+  _inherits(AbortError, _Error);
+
+  var _super2 = _createSuper(AbortError);
+
+  function AbortError() {
+    var _this2;
+
+    var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'The operation was aborted';
+
+    _classCallCheck(this, AbortError);
 
-    ${cyan_1(`--install`)}, ${cyan_1(`--no-install`)}
-    Whether to install dependencies in the newly created project. If you do not provide this
-    flag, Quilt will ask you about it later.
+    _this2 = _super2.call(this, message);
 
-    ${cyan_1('--package-manager')}
-    The package manager to use for your new project. This choice will be used to populate
-    some commands, and will be used to install dependencies if the ${cyan_1('--install')} flag is set.
+    _defineProperty$1(_assertThisInitialized(_this2), "code", 'ABORT_ERR');
 
-    Must be one of the following: ${bold_1('pnpm')}, ${bold_1('npm')}, or ${bold_1('yarn')}.
+    _defineProperty$1(_assertThisInitialized(_this2), "name", 'AbortError');
 
-    ${cyan_1(`--extras`)}, ${cyan_1(`--no-extras`)}
-    Extra developer tools to configure when creating your new project. This option only
-    applies when creating a brand new project, not when adding a project to an existing
-    workspace. You can include this flag multiple times to add multiple tools. You can
-    enable any of the following tools:
+    return _this2;
+  }
+
+  _createClass(AbortError, null, [{
+    key: "test",
+    value: function test(error) {
+      return error != null && error.code === 'ABORT_ERR';
+    }
+  }]);
+
+  return AbortError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
 
-     - ${bold_1('github')}, which adds a continuous integration (CI) GitHub Action to your project.
-     - ${bold_1('vscode')}, which adds some basic VSCode settings to your project.
+var _templateObject$1, _templateObject2, _templateObject3, _templateObject4;
+function printHelp() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      kind = _ref.kind,
+      customOptions = _ref.options,
+      packageManager = _ref.packageManager;
 
-    ${cyan_1('--yes')}, ${cyan_1('-y')}
-    Answers “yes” to any question this command would have asked.
+  var command = createCommand(packageManager);
+  var usage = stripIndent(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral$1(["\n    ", "   ", " ", " ", " ", "\n  "])), bold_1('Usage:'), command, kind ? magenta_1(kind) : magenta_1('[kind]'), green_1('[name]'), cyan_1('[options]'));
+  console.log(usage);
+  var example = stripIndent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral$1(["\n    ", " ", " ", " ", " ", "\n  "])), bold_1('Example:'), command, magenta_1(kind !== null && kind !== void 0 ? kind : 'app'), green_1("my-".concat(kind !== null && kind !== void 0 ? kind : 'app')), cyan_1('--install'));
+  console.log(dim_1(example));
 
-    ${cyan_1('--help')}, ${cyan_1('-h')}
-    Prints this help documentation.
-  `;
+  if (!kind) {
+    var kindSection = stripIndent(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral$1(["\n    ", " can be one of the following project types:\n\n     - ", ", a web application\n     - ", ", a shared library of code\n\n    You\u2019ll be asked a few additional questions based on the kind you choose.\n  "])), bold_1(magenta_1('kind')), magenta_1('app'), magenta_1('package'));
+    console.log();
+    console.log(kindSection);
+  }
+
+  var optionsSection = stripIndent(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral$1(["\n    ", "\n    The name of the project. When creating a package, you should use the public name you\n    want for the package, including any scope you want to use (example: ", ").\n    If you don\u2019t provide a name with this flag, this command will ask you for one later.\n\n    ", "\n    The directory to create the project in. If you don\u2019t provide this flag, Quilt will pick\n    a default directory based on the kind of the project and the name you provided.\n\n    ", ", ", "\n    If you aren\u2019t already in a monorepo, this flag will create your new project with some\n    additional structure that allows it to be a monorepo \u2014 that is, you will be able to add\n    multiple projects to a single repository.\n\n    ", ", ", "\n    Whether to install dependencies in the newly created project. If you do not provide this\n    flag, Quilt will ask you about it later.\n\n    ", "\n    The package manager to use for your new project. This choice will be used to populate\n    some commands, and will be used to install dependencies if the ", " flag is set.\n\n    Must be one of the following: ", ", ", ", or ", ".\n\n    ", ", ", "\n    Extra developer tools to configure when creating your new project. This option only\n    applies when creating a brand new project, not when adding a project to an existing\n    workspace. You can include this flag multiple times to add multiple tools. You can\n    enable any of the following tools:\n\n     - ", ", which adds a continuous integration (CI) GitHub Action to your project.\n     - ", ", which adds some basic VSCode settings to your project.\n\n    ", ", ", "\n    Answers \u201Cyes\u201D to any question this command would have asked.\n\n    ", ", ", "\n    Prints this help documentation.\n  "])), cyan_1('--name'), bold_1('@my-org/my-package'), cyan_1('--directory'), cyan_1("--monorepo"), cyan_1("--no-monorepo"), cyan_1("--install"), cyan_1("--no-install"), cyan_1('--package-manager'), cyan_1('--install'), bold_1('pnpm'), bold_1('npm'), bold_1('yarn'), cyan_1("--extras"), cyan_1("--no-extras"), bold_1('github'), bold_1('vscode'), cyan_1('--yes'), cyan_1('-y'), cyan_1('--help'), cyan_1('-h'));
   console.log();
-  console.log(`${bold_1(cyan_1('options'))} can include any of these flags:`);
+  console.log("".concat(bold_1(cyan_1('options')), " can include any of these flags:"));
 
   if (customOptions) {
     console.log();
@@ -873,12 +1453,16 @@ function printHelp({
 }
 
 function printOptionsSection(section) {
-  return section.split('\n').map(line => line.length > 0 ? ` ${line}` : line).join('\n');
+  return section.split('\n').map(function (line) {
+    return line.length > 0 ? " ".concat(line) : line;
+  }).join('\n');
 }
 
 function createCommand(explicitPackageManager) {
-  let packageManager;
-  const npmUserAgent = process.env['npm_config_user_agent'] ?? 'npm';
+  var _process$env$npm_conf;
+
+  var packageManager;
+  var npmUserAgent = (_process$env$npm_conf = process.env['npm_config_user_agent']) !== null && _process$env$npm_conf !== void 0 ? _process$env$npm_conf : 'npm';
 
   if (npmUserAgent.includes('pnpm') || explicitPackageManager === 'pnpm') {
     packageManager = 'pnpm';
@@ -888,7 +1472,7 @@ function createCommand(explicitPackageManager) {
     packageManager = 'npm';
   }
 
-  return `${packageManager} create @quilted`;
+  return "".concat(packageManager, " create @quilted");
 }
 
 var prompts$4 = {};
@@ -3792,9 +4376,9 @@ $.autocomplete = args => {
 };
 }(prompts$4));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(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; }
 
@@ -3823,11 +4407,11 @@ const noop$1 = () => {};
 
 
 function prompt$3() {
-  return _prompt.apply(this, arguments);
+  return _prompt$1.apply(this, arguments);
 }
 
-function _prompt() {
-  _prompt = _asyncToGenerator(function* (questions = [], {
+function _prompt$1() {
+  _prompt$1 = _asyncToGenerator(function* (questions = [], {
     onSubmit = noop$1,
     onCancel = noop$1
   } = {}) {
@@ -3862,7 +4446,7 @@ function _prompt() {
 
         // evaluate type first and skip if type is a falsy value
         if (typeof type === 'function') {
-          type = yield type(answer, _objectSpread({}, answers), question);
+          type = yield type(answer, _objectSpread$1({}, answers), question);
           question['type'] = type;
         }
 
@@ -3871,7 +4455,7 @@ function _prompt() {
         for (let key in question) {
           if (passOn$1.includes(key)) continue;
           let value = question[key];
-          question[key] = typeof value === 'function' ? yield value(answer, _objectSpread({}, answers), lastPrompt) : value;
+          question[key] = typeof value === 'function' ? yield value(answer, _objectSpread$1({}, answers), lastPrompt) : value;
         }
 
         lastPrompt = question;
@@ -3917,7 +4501,7 @@ function _prompt() {
 
     return answers;
   });
-  return _prompt.apply(this, arguments);
+  return _prompt$1.apply(this, arguments);
 }
 
 function getInjectedAnswer$1(injected, deafultValue) {
@@ -6574,170 +7158,369 @@ var prompts =
     ? dist
     : lib;
 
-async function prompt(prompt) {
-  const result = await prompts({
-    name: 'value',
-    ...prompt
-  }, {
-    onCancel() {
-      throw new AbortError();
-    }
+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; }
 
-  });
-  return result.value;
+function _objectSpread(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$1(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 prompt(_x) {
+  return _prompt.apply(this, arguments);
 }
-async function getCreateAsMonorepo(argv) {
-  let createAsMonorepo;
 
-  if (argv['--monorepo' ]) {
-    createAsMonorepo = true;
-  } else if (argv['--no-monorepo']) {
-    createAsMonorepo = false;
-  } else {
-    createAsMonorepo = await prompt({
-      type: 'confirm',
-      message: 'Do you want to create this app as a monorepo, with room for more projects?',
-      initial: true
-    });
-  }
+function _prompt() {
+  _prompt = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee(prompt) {
+    var result;
+    return regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return prompts(_objectSpread({
+              name: 'value'
+            }, prompt), {
+              onCancel: function onCancel() {
+                throw new AbortError();
+              }
+            });
+
+          case 2:
+            result = _context.sent;
+            return _context.abrupt("return", result.value);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _prompt.apply(this, arguments);
+}
 
-  return createAsMonorepo;
+function getCreateAsMonorepo(_x2) {
+  return _getCreateAsMonorepo.apply(this, arguments);
 }
-async function getShouldInstall(argv) {
-  let shouldInstall;
 
-  if (argv['--install'] || argv['--yes']) {
-    shouldInstall = true;
-  } else if (argv['--no-install']) {
-    shouldInstall = false;
-  } else {
-    shouldInstall = await prompt({
-      type: 'confirm',
-      message: 'Do you want to install dependencies for this app after creating it?',
-      initial: true
-    });
-  }
+function _getCreateAsMonorepo() {
+  _getCreateAsMonorepo = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee2(argv) {
+    var createAsMonorepo;
+    return regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!argv['--monorepo' ]) {
+              _context2.next = 4;
+              break;
+            }
+
+            createAsMonorepo = true;
+            _context2.next = 11;
+            break;
+
+          case 4:
+            if (!argv['--no-monorepo']) {
+              _context2.next = 8;
+              break;
+            }
+
+            createAsMonorepo = false;
+            _context2.next = 11;
+            break;
+
+          case 8:
+            _context2.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Do you want to create this app as a monorepo, with room for more projects?',
+              initial: true
+            });
+
+          case 10:
+            createAsMonorepo = _context2.sent;
 
-  return shouldInstall;
+          case 11:
+            return _context2.abrupt("return", createAsMonorepo);
+
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getCreateAsMonorepo.apply(this, arguments);
 }
-const VALID_PACKAGE_MANAGERS = new Set(['pnpm', 'npm', 'yarn']);
-async function getPackageManager(argv) {
-  let packageManager;
 
-  if (argv['--package-manager']) {
-    const explicitPackageManager = argv['--package-manager'].toLocaleLowerCase();
-    packageManager = VALID_PACKAGE_MANAGERS.has(explicitPackageManager) ? explicitPackageManager : 'npm';
-  } else {
-    const npmUserAgent = process.env['npm_config_user_agent'] ?? 'npm';
+function getShouldInstall(_x3) {
+  return _getShouldInstall.apply(this, arguments);
+}
 
-    if (npmUserAgent.includes('pnpm') || fs.existsSync('pnpm-lock.yaml')) {
-      packageManager = 'pnpm';
-    } else if (npmUserAgent.includes('yarn') || fs.existsSync('yarn.lock')) {
-      packageManager = 'yarn';
-    } else {
-      packageManager = 'npm';
-    }
-  }
+function _getShouldInstall() {
+  _getShouldInstall = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee3(argv) {
+    var shouldInstall;
+    return regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(argv['--install'] || argv['--yes'])) {
+              _context3.next = 4;
+              break;
+            }
+
+            shouldInstall = true;
+            _context3.next = 11;
+            break;
 
-  return packageManager;
+          case 4:
+            if (!argv['--no-install']) {
+              _context3.next = 8;
+              break;
+            }
+
+            shouldInstall = false;
+            _context3.next = 11;
+            break;
+
+          case 8:
+            _context3.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Do you want to install dependencies for this app after creating it?',
+              initial: true
+            });
+
+          case 10:
+            shouldInstall = _context3.sent;
+
+          case 11:
+            return _context3.abrupt("return", shouldInstall);
+
+          case 12:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _getShouldInstall.apply(this, arguments);
 }
-const VALID_EXTRAS = new Set(['github', 'vscode']);
-async function getExtrasToSetup(argv, {
-  inWorkspace
-}) {
-  if (inWorkspace || argv['--no-extras']) return new Set();
-
-  if (argv['--extras']) {
-    return new Set(argv['--extras'].filter(extra => VALID_EXTRAS.has(extra)));
-  }
-
-  const setupExtras = await prompt({
-    type: 'multiselect',
-    message: 'Which additional tools would you like to configure?',
-    instructions: dim_1(`\n  Use ${bold_1('space')} to select, ${bold_1('a')} to select all, ${bold_1('return')} to submit`),
-    choices: [{
-      title: 'VSCode',
-      value: 'vscode'
-    }, {
-      title: 'GitHub',
-      value: 'github'
-    }]
-  });
-  const extrasToSetup = new Set(setupExtras);
-  return extrasToSetup;
+
+var VALID_PACKAGE_MANAGERS = new Set(['pnpm', 'npm', 'yarn']);
+function getPackageManager(_x4) {
+  return _getPackageManager.apply(this, arguments);
+}
+
+function _getPackageManager() {
+  _getPackageManager = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee4(argv) {
+    var packageManager, explicitPackageManager, _process$env$npm_conf, npmUserAgent;
+
+    return regenerator.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (argv['--package-manager']) {
+              explicitPackageManager = argv['--package-manager'].toLocaleLowerCase();
+              packageManager = VALID_PACKAGE_MANAGERS.has(explicitPackageManager) ? explicitPackageManager : 'npm';
+            } else {
+              npmUserAgent = (_process$env$npm_conf = process.env['npm_config_user_agent']) !== null && _process$env$npm_conf !== void 0 ? _process$env$npm_conf : 'npm';
+
+              if (npmUserAgent.includes('pnpm') || fs.existsSync('pnpm-lock.yaml')) {
+                packageManager = 'pnpm';
+              } else if (npmUserAgent.includes('yarn') || fs.existsSync('yarn.lock')) {
+                packageManager = 'yarn';
+              } else {
+                packageManager = 'npm';
+              }
+            }
+
+            return _context4.abrupt("return", packageManager);
+
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getPackageManager.apply(this, arguments);
+}
+
+var VALID_EXTRAS = new Set(['github', 'vscode']);
+function getExtrasToSetup(_x5, _x6) {
+  return _getExtrasToSetup.apply(this, arguments);
+}
+
+function _getExtrasToSetup() {
+  _getExtrasToSetup = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee5(argv, _ref) {
+    var inWorkspace, setupExtras, extrasToSetup;
+    return regenerator.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            inWorkspace = _ref.inWorkspace;
+
+            if (!(inWorkspace || argv['--no-extras'])) {
+              _context5.next = 3;
+              break;
+            }
+
+            return _context5.abrupt("return", new Set());
+
+          case 3:
+            if (!argv['--extras']) {
+              _context5.next = 5;
+              break;
+            }
+
+            return _context5.abrupt("return", new Set(argv['--extras'].filter(function (extra) {
+              return VALID_EXTRAS.has(extra);
+            })));
+
+          case 5:
+            _context5.next = 7;
+            return prompt({
+              type: 'multiselect',
+              message: 'Which additional tools would you like to configure?',
+              instructions: dim_1("\n  Use ".concat(bold_1('space'), " to select, ").concat(bold_1('a'), " to select all, ").concat(bold_1('return'), " to submit")),
+              choices: [{
+                title: 'VSCode',
+                value: 'vscode'
+              }, {
+                title: 'GitHub',
+                value: 'github'
+              }]
+            });
+
+          case 7:
+            setupExtras = _context5.sent;
+            extrasToSetup = new Set(setupExtras);
+            return _context5.abrupt("return", extrasToSetup);
+
+          case 10:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getExtrasToSetup.apply(this, arguments);
 }
 
-/* eslint no-console: off */
-const VALID_PROJECT_KINDS = new Set(['app', 'package']);
-run().catch(error => {
+var _templateObject;
+var VALID_PROJECT_KINDS = new Set(['app', 'package']);
+run()["catch"](function (error) {
   if (AbortError.test(error)) return;
   console.error(error);
   process.exitCode = 1;
 });
 
-async function run() {
-  const permissiveArgs = arg_1({
-    '--help': Boolean,
-    '-h': '--help',
-    '--package-manager': String
-  }, {
-    permissive: true
-  });
-  const firstArgument = permissiveArgs._[0]?.toLowerCase();
+function run() {
+  return _run.apply(this, arguments);
+}
 
-  if (firstArgument != null && !firstArgument.startsWith('-') && !VALID_PROJECT_KINDS.has(firstArgument)) {
-    // TODO: show help with error message
-    process.exitCode = 1;
-    return;
-  }
+function _run() {
+  _run = _asyncToGenerator$5( /*#__PURE__*/regenerator.mark(function _callee() {
+    var _permissiveArgs$_$;
+
+    var permissiveArgs, firstArgument, kind, header, _permissiveArgs$Pac, _yield$import, createApp, _yield$import2, createProject;
+
+    return regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            permissiveArgs = arg_1({
+              '--help': Boolean,
+              '-h': '--help',
+              '--package-manager': String
+            }, {
+              permissive: true
+            });
+            firstArgument = (_permissiveArgs$_$ = permissiveArgs._[0]) === null || _permissiveArgs$_$ === void 0 ? void 0 : _permissiveArgs$_$.toLowerCase();
+
+            if (!(firstArgument != null && !firstArgument.startsWith('-') && !VALID_PROJECT_KINDS.has(firstArgument))) {
+              _context.next = 5;
+              break;
+            }
 
-  let kind = firstArgument == null || !VALID_PROJECT_KINDS.has(firstArgument) ? undefined : firstArgument;
-  const header = stripIndent`
-      🧵 ${bold_1('quilt create')}
-    `;
-  console.log(header);
-  console.log();
+            // TODO: show help with error message
+            process.exitCode = 1;
+            return _context.abrupt("return");
 
-  if (permissiveArgs['--help'] && !kind) {
-    printHelp({
-      packageManager: permissiveArgs['--package-manager']?.toLowerCase()
-    });
-    return;
-  }
+          case 5:
+            kind = firstArgument == null || !VALID_PROJECT_KINDS.has(firstArgument) ? undefined : firstArgument;
+            header = stripIndent(_templateObject || (_templateObject = _taggedTemplateLiteral$1(["\n      \uD83E\uDDF5 ", "\n    "])), bold_1('quilt create'));
+            console.log(header);
+            console.log();
 
-  if (kind == null) {
-    kind = await prompt({
-      type: 'select',
-      message: 'What kind of project would you like to create?',
-      choices: [{
-        title: 'App',
-        value: 'app'
-      }, {
-        title: 'Package',
-        value: 'package'
-      }]
-    });
-  }
+            if (!(permissiveArgs['--help'] && !kind)) {
+              _context.next = 12;
+              break;
+            }
 
-  switch (kind) {
-    case 'app':
-      {
-        const {
-          createApp
-        } = await import('./app.mjs');
-        await createApp();
-        break;
-      }
+            printHelp({
+              packageManager: (_permissiveArgs$Pac = permissiveArgs['--package-manager']) === null || _permissiveArgs$Pac === void 0 ? void 0 : _permissiveArgs$Pac.toLowerCase()
+            });
+            return _context.abrupt("return");
 
-    case 'package':
-      {
-        const {
-          createPackage
-        } = await import('./package.mjs');
-        await createPackage();
-        break;
+          case 12:
+            if (!(kind == null)) {
+              _context.next = 16;
+              break;
+            }
+
+            _context.next = 15;
+            return prompt({
+              type: 'select',
+              message: 'What kind of project would you like to create?',
+              choices: [{
+                title: 'App',
+                value: 'app'
+              }, {
+                title: 'Package',
+                value: 'package'
+              }]
+            });
+
+          case 15:
+            kind = _context.sent;
+
+          case 16:
+            _context.t0 = kind;
+            _context.next = _context.t0 === 'app' ? 19 : _context.t0 === 'package' ? 26 : 33;
+            break;
+
+          case 19:
+            _context.next = 21;
+            return import('./app.mjs');
+
+          case 21:
+            _yield$import = _context.sent;
+            createApp = _yield$import.createApp;
+            _context.next = 25;
+            return createApp();
+
+          case 25:
+            return _context.abrupt("break", 33);
+
+          case 26:
+            _context.next = 28;
+            return import('./package.mjs');
+
+          case 28:
+            _yield$import2 = _context.sent;
+            createProject = _yield$import2.createProject;
+            _context.next = 32;
+            return createProject();
+
+          case 32:
+            return _context.abrupt("break", 33);
+
+          case 33:
+          case "end":
+            return _context.stop();
+        }
       }
-  }
+    }, _callee);
+  }));
+  return _run.apply(this, arguments);
 }
 
-export { getShouldInstall as a, bold_1 as b, cyan_1 as c, getPackageManager as d, getExtrasToSetup as e, dim_1 as f, getCreateAsMonorepo as g, arg_1 as h, prompt as i, magenta_1 as m, printHelp as p, stripIndent as s, underline_1 as u };
+export { _asyncToGenerator$5 as _, _taggedTemplateLiteral$1 as a, getPackageManager as b, cyan_1 as c, dim_1 as d, getShouldInstall as e, getCreateAsMonorepo as f, getExtrasToSetup as g, bold_1 as h, arg_1 as i, prompt as j, _defineProperty$1 as k, magenta_1 as m, printHelp as p, regenerator as r, stripIndent as s, underline_1 as u };