@todesktop/cli 1.19.0-0 → 1.19.0-1

package/dist/cli.js

@@ -5,22 +5,3616 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js
+var require_es_object_atoms = __commonJS({
+  "../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Error;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js"(exports2, module2) {
+    "use strict";
+    module2.exports = EvalError;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js"(exports2, module2) {
+    "use strict";
+    module2.exports = RangeError;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js"(exports2, module2) {
+    "use strict";
+    module2.exports = ReferenceError;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js"(exports2, module2) {
+    "use strict";
+    module2.exports = SyntaxError;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js"(exports2, module2) {
+    "use strict";
+    module2.exports = TypeError;
+  }
+});
+
+// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js"(exports2, module2) {
+    "use strict";
+    module2.exports = URIError;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js
+var require_abs = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.abs;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js
+var require_floor = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.floor;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js
+var require_max = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.max;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js
+var require_min = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.min;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js
+var require_pow = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.pow;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js
+var require_round = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.round;
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js
+var require_isNaN = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Number.isNaN || function isNaN2(a) {
+      return a !== a;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js
+var require_sign = __commonJS({
+  "../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js"(exports2, module2) {
+    "use strict";
+    var $isNaN = require_isNaN();
+    module2.exports = function sign(number2) {
+      if ($isNaN(number2) || number2 === 0) {
+        return number2;
+      }
+      return number2 < 0 ? -1 : 1;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js
+var require_gOPD = __commonJS({
+  "../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js"(exports2, module2) {
+    "use strict";
+    var $gOPD = require_gOPD();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// ../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js"(exports2, module2) {
+    "use strict";
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    }
+    module2.exports = $defineProperty;
+  }
+});
+
+// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = /* @__PURE__ */ Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (var _ in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = (
+          /** @type {PropertyDescriptor} */
+          Object.getOwnPropertyDescriptor(obj, sym)
+        );
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js"(exports2, module2) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module2.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = __commonJS({
+  "../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  }
+});
+
+// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = __commonJS({
+  "../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    var $Object = require_es_object_atoms();
+    module2.exports = $Object.getPrototypeOf || null;
+  }
+});
+
+// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = function concatty2(a, b) {
+      var arr = [];
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+      }
+      return arr;
+    };
+    var slicy = function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+      }
+      return arr;
+    };
+    var joiny = function(arr, joiner) {
+      var str = "";
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+          str += joiner;
+        }
+      }
+      return str;
+    };
+    module2.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args2 = slicy(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args2, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args2, arguments)
+        );
+      };
+      var boundLength = max(0, target.length - args2.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = "$" + i;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = __commonJS({
+  "../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.call;
+  }
+});
+
+// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = __commonJS({
+  "../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.apply;
+  }
+});
+
+// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = __commonJS({
+  "../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  }
+});
+
+// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = __commonJS({
+  "../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var $reflectApply = require_reflectApply();
+    module2.exports = $reflectApply || bind.call($call, $apply);
+  }
+});
+
+// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = __commonJS({
+  "../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    var $TypeError = require_type();
+    var $call = require_functionCall();
+    var $actualApply = require_actualApply();
+    module2.exports = function callBindBasic(args2) {
+      if (args2.length < 1 || typeof args2[0] !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      return $actualApply(bind, $call, args2);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js
+var require_get = __commonJS({
+  "../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js"(exports2, module2) {
+    "use strict";
+    var callBind = require_call_bind_apply_helpers();
+    var gOPD = require_gopd();
+    var hasProtoAccessor;
+    try {
+      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+      [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+        throw e;
+      }
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(
+      Object.prototype,
+      /** @type {keyof typeof Object.prototype} */
+      "__proto__"
+    );
+    var $Object = Object;
+    var $getPrototypeOf = $Object.getPrototypeOf;
+    module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+      /** @type {import('./get')} */
+      function getDunder(value) {
+        return $getPrototypeOf(value == null ? value : $Object(value));
+      }
+    ) : false;
+  }
+});
+
+// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js
+var require_get_proto = __commonJS({
+  "../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js"(exports2, module2) {
+    "use strict";
+    var reflectGetProto = require_Reflect_getPrototypeOf();
+    var originalGetProto = require_Object_getPrototypeOf();
+    var getDunderProto = require_get();
+    module2.exports = reflectGetProto ? function getProto(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function getProto(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function") {
+        throw new TypeError("getProto: not an object");
+      }
+      return originalGetProto(O);
+    } : getDunderProto ? function getProto(O) {
+      return getDunderProto(O);
+    } : null;
+  }
+});
+
+// ../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js"(exports2, module2) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind = require_function_bind();
+    module2.exports = bind.call(call, $hasOwn);
+  }
+});
+
+// ../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js"(exports2, module2) {
+    "use strict";
+    var undefined2;
+    var $Object = require_es_object_atoms();
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var abs = require_abs();
+    var floor = require_floor();
+    var max = require_max();
+    var min = require_min();
+    var pow = require_pow();
+    var round = require_round();
+    var sign = require_sign();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = require_gopd();
+    var $defineProperty = require_es_define_property();
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? (function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    })() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = require_get_proto();
+    var $ObjectGPO = require_Object_getPrototypeOf();
+    var $ReflectGPO = require_Reflect_getPrototypeOf();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": $EvalError,
+      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": $Object,
+      "%Object.getOwnPropertyDescriptor%": $gOPD,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+      "%Function.prototype.call%": $call,
+      "%Function.prototype.apply%": $apply,
+      "%Object.defineProperty%": $defineProperty,
+      "%Object.getPrototypeOf%": $ObjectGPO,
+      "%Math.abs%": abs,
+      "%Math.floor%": floor,
+      "%Math.max%": max,
+      "%Math.min%": min,
+      "%Math.pow%": pow,
+      "%Math.round%": round,
+      "%Math.sign%": sign,
+      "%Reflect.getPrototypeOf%": $ReflectGPO
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      __proto__: null,
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind = require_function_bind();
+    var hasOwn = require_hasown();
+    var $concat = bind.call($call, Array.prototype.concat);
+    var $spliceApply = bind.call($apply, Array.prototype.splice);
+    var $replace = bind.call($call, String.prototype.replace);
+    var $strSlice = bind.call($call, String.prototype.slice);
+    var $exec = bind.call($call, RegExp.prototype.exec);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string2) {
+      var first = $strSlice(string2, 0, 1);
+      var last = $strSlice(string2, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string2, rePropName, function(match, number2, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number2 || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module2.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void undefined2;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js
+var require_call_bound = __commonJS({
+  "../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js"(exports2, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var callBindBasic = require_call_bind_apply_helpers();
+    var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+    module2.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = (
+        /** @type {(this: unknown, ...args: unknown[]) => unknown} */
+        GetIntrinsic(name, !!allowMissing)
+      );
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+        return callBindBasic(
+          /** @type {const} */
+          [intrinsic]
+        );
+      }
+      return intrinsic;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js
+var require_shams2 = __commonJS({
+  "../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js"(exports2, module2) {
+    "use strict";
+    var hasSymbols = require_shams();
+    module2.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-regex@1.2.1/node_modules/is-regex/index.js
+var require_is_regex = __commonJS({
+  "../../node_modules/.pnpm/is-regex@1.2.1/node_modules/is-regex/index.js"(exports2, module2) {
+    "use strict";
+    var callBound = require_call_bound();
+    var hasToStringTag = require_shams2()();
+    var hasOwn = require_hasown();
+    var gOPD = require_gopd();
+    var fn;
+    if (hasToStringTag) {
+      $exec = callBound("RegExp.prototype.exec");
+      isRegexMarker = {};
+      throwRegexMarker = function() {
+        throw isRegexMarker;
+      };
+      badStringifier = {
+        toString: throwRegexMarker,
+        valueOf: throwRegexMarker
+      };
+      if (typeof Symbol.toPrimitive === "symbol") {
+        badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+      }
+      fn = function isRegex2(value) {
+        if (!value || typeof value !== "object") {
+          return false;
+        }
+        var descriptor = (
+          /** @type {NonNullable<typeof gOPD>} */
+          gOPD(
+            /** @type {{ lastIndex?: unknown }} */
+            value,
+            "lastIndex"
+          )
+        );
+        var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, "value");
+        if (!hasLastIndexDataProperty) {
+          return false;
+        }
+        try {
+          $exec(
+            value,
+            /** @type {string} */
+            /** @type {unknown} */
+            badStringifier
+          );
+        } catch (e) {
+          return e === isRegexMarker;
+        }
+      };
+    } else {
+      $toString = callBound("Object.prototype.toString");
+      regexClass = "[object RegExp]";
+      fn = function isRegex2(value) {
+        if (!value || typeof value !== "object" && typeof value !== "function") {
+          return false;
+        }
+        return $toString(value) === regexClass;
+      };
+    }
+    var $exec;
+    var isRegexMarker;
+    var throwRegexMarker;
+    var badStringifier;
+    var $toString;
+    var regexClass;
+    module2.exports = fn;
+  }
+});
+
+// ../../node_modules/.pnpm/property-expr@2.0.6/node_modules/property-expr/index.js
+var require_property_expr = __commonJS({
+  "../../node_modules/.pnpm/property-expr@2.0.6/node_modules/property-expr/index.js"(exports2, module2) {
+    "use strict";
+    function Cache(maxSize) {
+      this._maxSize = maxSize;
+      this.clear();
+    }
+    Cache.prototype.clear = function() {
+      this._size = 0;
+      this._values = /* @__PURE__ */ Object.create(null);
+    };
+    Cache.prototype.get = function(key) {
+      return this._values[key];
+    };
+    Cache.prototype.set = function(key, value) {
+      this._size >= this._maxSize && this.clear();
+      if (!(key in this._values)) this._size++;
+      return this._values[key] = value;
+    };
+    var SPLIT_REGEX = /[^.^\]^[]+|(?=\[\]|\.\.)/g;
+    var DIGIT_REGEX = /^\d+$/;
+    var LEAD_DIGIT_REGEX = /^\d/;
+    var SPEC_CHAR_REGEX = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g;
+    var CLEAN_QUOTES_REGEX = /^\s*(['"]?)(.*?)(\1)\s*$/;
+    var MAX_CACHE_SIZE = 512;
+    var pathCache = new Cache(MAX_CACHE_SIZE);
+    var setCache = new Cache(MAX_CACHE_SIZE);
+    var getCache = new Cache(MAX_CACHE_SIZE);
+    module2.exports = {
+      Cache,
+      split,
+      normalizePath,
+      setter: function(path9) {
+        var parts = normalizePath(path9);
+        return setCache.get(path9) || setCache.set(path9, function setter(obj, value) {
+          var index = 0;
+          var len = parts.length;
+          var data = obj;
+          while (index < len - 1) {
+            var part = parts[index];
+            if (part === "__proto__" || part === "constructor" || part === "prototype") {
+              return obj;
+            }
+            data = data[parts[index++]];
+          }
+          data[parts[index]] = value;
+        });
+      },
+      getter: function(path9, safe) {
+        var parts = normalizePath(path9);
+        return getCache.get(path9) || getCache.set(path9, function getter(data) {
+          var index = 0, len = parts.length;
+          while (index < len) {
+            if (data != null || !safe) data = data[parts[index++]];
+            else return;
+          }
+          return data;
+        });
+      },
+      join: function(segments) {
+        return segments.reduce(function(path9, part) {
+          return path9 + (isQuoted(part) || DIGIT_REGEX.test(part) ? "[" + part + "]" : (path9 ? "." : "") + part);
+        }, "");
+      },
+      forEach: function(path9, cb, thisArg) {
+        forEach(Array.isArray(path9) ? path9 : split(path9), cb, thisArg);
+      }
+    };
+    function normalizePath(path9) {
+      return pathCache.get(path9) || pathCache.set(
+        path9,
+        split(path9).map(function(part) {
+          return part.replace(CLEAN_QUOTES_REGEX, "$2");
+        })
+      );
+    }
+    function split(path9) {
+      return path9.match(SPLIT_REGEX) || [""];
+    }
+    function forEach(parts, iter, thisArg) {
+      var len = parts.length, part, idx, isArray, isBracket;
+      for (idx = 0; idx < len; idx++) {
+        part = parts[idx];
+        if (part) {
+          if (shouldBeQuoted(part)) {
+            part = '"' + part + '"';
+          }
+          isBracket = isQuoted(part);
+          isArray = !isBracket && /^\d+$/.test(part);
+          iter.call(thisArg, part, isBracket, isArray, idx, parts);
+        }
+      }
+    }
+    function isQuoted(str) {
+      return typeof str === "string" && str && ["'", '"'].indexOf(str.charAt(0)) !== -1;
+    }
+    function hasLeadingNumber(part) {
+      return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX);
+    }
+    function hasSpecialChars(part) {
+      return SPEC_CHAR_REGEX.test(part);
+    }
+    function shouldBeQuoted(part) {
+      return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/tiny-case@1.0.3/node_modules/tiny-case/index.js
+var require_tiny_case = __commonJS({
+  "../../node_modules/.pnpm/tiny-case@1.0.3/node_modules/tiny-case/index.js"(exports2, module2) {
+    var reWords = /[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d*(?:1ST|2ND|3RD|(?![123])\dTH)(?=\b|[a-z_])|\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|[A-Z_])|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?)*/g;
+    var words = (str) => str.match(reWords) || [];
+    var upperFirst = (str) => str[0].toUpperCase() + str.slice(1);
+    var join5 = (str, d) => words(str).join(d).toLowerCase();
+    var camelCase = (str) => words(str).reduce(
+      (acc, next) => `${acc}${!acc ? next.toLowerCase() : next[0].toUpperCase() + next.slice(1).toLowerCase()}`,
+      ""
+    );
+    var pascalCase = (str) => upperFirst(camelCase(str));
+    var snakeCase = (str) => join5(str, "_");
+    var kebabCase = (str) => join5(str, "-");
+    var sentenceCase = (str) => upperFirst(join5(str, " "));
+    var titleCase = (str) => words(str).map(upperFirst).join(" ");
+    module2.exports = {
+      words,
+      upperFirst,
+      camelCase,
+      pascalCase,
+      snakeCase,
+      kebabCase,
+      sentenceCase,
+      titleCase
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/toposort@2.0.2/node_modules/toposort/index.js
+var require_toposort = __commonJS({
+  "../../node_modules/.pnpm/toposort@2.0.2/node_modules/toposort/index.js"(exports2, module2) {
+    module2.exports = function(edges) {
+      return toposort(uniqueNodes(edges), edges);
+    };
+    module2.exports.array = toposort;
+    function toposort(nodes, edges) {
+      var cursor = nodes.length, sorted = new Array(cursor), visited = {}, i = cursor, outgoingEdges = makeOutgoingEdges(edges), nodesHash = makeNodesHash(nodes);
+      edges.forEach(function(edge) {
+        if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+          throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+        }
+      });
+      while (i--) {
+        if (!visited[i]) visit(nodes[i], i, /* @__PURE__ */ new Set());
+      }
+      return sorted;
+      function visit(node, i2, predecessors) {
+        if (predecessors.has(node)) {
+          var nodeRep;
+          try {
+            nodeRep = ", node was:" + JSON.stringify(node);
+          } catch (e) {
+            nodeRep = "";
+          }
+          throw new Error("Cyclic dependency" + nodeRep);
+        }
+        if (!nodesHash.has(node)) {
+          throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(node));
+        }
+        if (visited[i2]) return;
+        visited[i2] = true;
+        var outgoing = outgoingEdges.get(node) || /* @__PURE__ */ new Set();
+        outgoing = Array.from(outgoing);
+        if (i2 = outgoing.length) {
+          predecessors.add(node);
+          do {
+            var child = outgoing[--i2];
+            visit(child, nodesHash.get(child), predecessors);
+          } while (i2);
+          predecessors.delete(node);
+        }
+        sorted[--cursor] = node;
+      }
+    }
+    function uniqueNodes(arr) {
+      var res = /* @__PURE__ */ new Set();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        var edge = arr[i];
+        res.add(edge[0]);
+        res.add(edge[1]);
+      }
+      return Array.from(res);
+    }
+    function makeOutgoingEdges(arr) {
+      var edges = /* @__PURE__ */ new Map();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        var edge = arr[i];
+        if (!edges.has(edge[0])) edges.set(edge[0], /* @__PURE__ */ new Set());
+        if (!edges.has(edge[1])) edges.set(edge[1], /* @__PURE__ */ new Set());
+        edges.get(edge[0]).add(edge[1]);
+      }
+      return edges;
+    }
+    function makeNodesHash(arr) {
+      var res = /* @__PURE__ */ new Map();
+      for (var i = 0, len = arr.length; i < len; i++) {
+        res.set(arr[i], i);
+      }
+      return res;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/yup@1.7.0/node_modules/yup/index.js
+var require_yup = __commonJS({
+  "../../node_modules/.pnpm/yup@1.7.0/node_modules/yup/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var propertyExpr = require_property_expr();
+    var tinyCase = require_tiny_case();
+    var toposort = require_toposort();
+    function _interopDefaultLegacy(e) {
+      return e && typeof e === "object" && "default" in e ? e : { "default": e };
+    }
+    var toposort__default = /* @__PURE__ */ _interopDefaultLegacy(toposort);
+    var toString = Object.prototype.toString;
+    var errorToString = Error.prototype.toString;
+    var regExpToString = RegExp.prototype.toString;
+    var symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
+    var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+    function printNumber(val) {
+      if (val != +val) return "NaN";
+      const isNegativeZero = val === 0 && 1 / val < 0;
+      return isNegativeZero ? "-0" : "" + val;
+    }
+    function printSimpleValue(val, quoteStrings = false) {
+      if (val == null || val === true || val === false) return "" + val;
+      const typeOf = typeof val;
+      if (typeOf === "number") return printNumber(val);
+      if (typeOf === "string") return quoteStrings ? `"${val}"` : val;
+      if (typeOf === "function") return "[Function " + (val.name || "anonymous") + "]";
+      if (typeOf === "symbol") return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+      const tag = toString.call(val).slice(8, -1);
+      if (tag === "Date") return isNaN(val.getTime()) ? "" + val : val.toISOString(val);
+      if (tag === "Error" || val instanceof Error) return "[" + errorToString.call(val) + "]";
+      if (tag === "RegExp") return regExpToString.call(val);
+      return null;
+    }
+    function printValue(value, quoteStrings) {
+      let result = printSimpleValue(value, quoteStrings);
+      if (result !== null) return result;
+      return JSON.stringify(value, function(key, value2) {
+        let result2 = printSimpleValue(this[key], quoteStrings);
+        if (result2 !== null) return result2;
+        return value2;
+      }, 2);
+    }
+    function toArray(value) {
+      return value == null ? [] : [].concat(value);
+    }
+    var _Symbol$toStringTag;
+    var _Symbol$hasInstance;
+    var _Symbol$toStringTag2;
+    var strReg = /\$\{\s*(\w+)\s*\}/g;
+    _Symbol$toStringTag = Symbol.toStringTag;
+    var ValidationErrorNoStack = class {
+      constructor(errorOrErrors, value, field, type) {
+        this.name = void 0;
+        this.message = void 0;
+        this.value = void 0;
+        this.path = void 0;
+        this.type = void 0;
+        this.params = void 0;
+        this.errors = void 0;
+        this.inner = void 0;
+        this[_Symbol$toStringTag] = "Error";
+        this.name = "ValidationError";
+        this.value = value;
+        this.path = field;
+        this.type = type;
+        this.errors = [];
+        this.inner = [];
+        toArray(errorOrErrors).forEach((err) => {
+          if (ValidationError2.isError(err)) {
+            this.errors.push(...err.errors);
+            const innerErrors = err.inner.length ? err.inner : [err];
+            this.inner.push(...innerErrors);
+          } else {
+            this.errors.push(err);
+          }
+        });
+        this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+      }
+    };
+    _Symbol$hasInstance = Symbol.hasInstance;
+    _Symbol$toStringTag2 = Symbol.toStringTag;
+    var ValidationError2 = class _ValidationError extends Error {
+      static formatError(message2, params) {
+        const path9 = params.label || params.path || "this";
+        params = Object.assign({}, params, {
+          path: path9,
+          originalPath: params.path
+        });
+        if (typeof message2 === "string") return message2.replace(strReg, (_, key) => printValue(params[key]));
+        if (typeof message2 === "function") return message2(params);
+        return message2;
+      }
+      static isError(err) {
+        return err && err.name === "ValidationError";
+      }
+      constructor(errorOrErrors, value, field, type, disableStack) {
+        const errorNoStack = new ValidationErrorNoStack(errorOrErrors, value, field, type);
+        if (disableStack) {
+          return errorNoStack;
+        }
+        super();
+        this.value = void 0;
+        this.path = void 0;
+        this.type = void 0;
+        this.params = void 0;
+        this.errors = [];
+        this.inner = [];
+        this[_Symbol$toStringTag2] = "Error";
+        this.name = errorNoStack.name;
+        this.message = errorNoStack.message;
+        this.type = errorNoStack.type;
+        this.value = errorNoStack.value;
+        this.path = errorNoStack.path;
+        this.errors = errorNoStack.errors;
+        this.inner = errorNoStack.inner;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _ValidationError);
+        }
+      }
+      static [_Symbol$hasInstance](inst) {
+        return ValidationErrorNoStack[Symbol.hasInstance](inst) || super[Symbol.hasInstance](inst);
+      }
+    };
+    var mixed = {
+      default: "${path} is invalid",
+      required: "${path} is a required field",
+      defined: "${path} must be defined",
+      notNull: "${path} cannot be null",
+      oneOf: "${path} must be one of the following values: ${values}",
+      notOneOf: "${path} must not be one of the following values: ${values}",
+      notType: ({
+        path: path9,
+        type,
+        value,
+        originalValue
+      }) => {
+        const castMsg = originalValue != null && originalValue !== value ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : ".";
+        return type !== "mixed" ? `${path9} must be a \`${type}\` type, but the final value was: \`${printValue(value, true)}\`` + castMsg : `${path9} must match the configured type. The validated value was: \`${printValue(value, true)}\`` + castMsg;
+      }
+    };
+    var string2 = {
+      length: "${path} must be exactly ${length} characters",
+      min: "${path} must be at least ${min} characters",
+      max: "${path} must be at most ${max} characters",
+      matches: '${path} must match the following: "${regex}"',
+      email: "${path} must be a valid email",
+      url: "${path} must be a valid URL",
+      uuid: "${path} must be a valid UUID",
+      datetime: "${path} must be a valid ISO date-time",
+      datetime_precision: "${path} must be a valid ISO date-time with a sub-second precision of exactly ${precision} digits",
+      datetime_offset: '${path} must be a valid ISO date-time with UTC "Z" timezone',
+      trim: "${path} must be a trimmed string",
+      lowercase: "${path} must be a lowercase string",
+      uppercase: "${path} must be a upper case string"
+    };
+    var number2 = {
+      min: "${path} must be greater than or equal to ${min}",
+      max: "${path} must be less than or equal to ${max}",
+      lessThan: "${path} must be less than ${less}",
+      moreThan: "${path} must be greater than ${more}",
+      positive: "${path} must be a positive number",
+      negative: "${path} must be a negative number",
+      integer: "${path} must be an integer"
+    };
+    var date2 = {
+      min: "${path} field must be later than ${min}",
+      max: "${path} field must be at earlier than ${max}"
+    };
+    var boolean2 = {
+      isValue: "${path} field must be ${value}"
+    };
+    var object2 = {
+      noUnknown: "${path} field has unspecified keys: ${unknown}",
+      exact: "${path} object contains unknown properties: ${properties}"
+    };
+    var array = {
+      min: "${path} field must have at least ${min} items",
+      max: "${path} field must have less than or equal to ${max} items",
+      length: "${path} must have ${length} items"
+    };
+    var tuple = {
+      notType: (params) => {
+        const {
+          path: path9,
+          value,
+          spec
+        } = params;
+        const typeLen = spec.types.length;
+        if (Array.isArray(value)) {
+          if (value.length < typeLen) return `${path9} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+          if (value.length > typeLen) return `${path9} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+        }
+        return ValidationError2.formatError(mixed.notType, params);
+      }
+    };
+    var locale = Object.assign(/* @__PURE__ */ Object.create(null), {
+      mixed,
+      string: string2,
+      number: number2,
+      date: date2,
+      object: object2,
+      array,
+      boolean: boolean2,
+      tuple
+    });
+    var isSchema = (obj) => obj && obj.__isYupSchema__;
+    var Condition = class _Condition {
+      static fromOptions(refs, config2) {
+        if (!config2.then && !config2.otherwise) throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
+        let {
+          is,
+          then,
+          otherwise
+        } = config2;
+        let check = typeof is === "function" ? is : (...values) => values.every((value) => value === is);
+        return new _Condition(refs, (values, schema) => {
+          var _branch;
+          let branch2 = check(...values) ? then : otherwise;
+          return (_branch = branch2 == null ? void 0 : branch2(schema)) != null ? _branch : schema;
+        });
+      }
+      constructor(refs, builder) {
+        this.fn = void 0;
+        this.refs = refs;
+        this.refs = refs;
+        this.fn = builder;
+      }
+      resolve(base, options) {
+        let values = this.refs.map((ref) => (
+          // TODO: ? operator here?
+          ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context)
+        ));
+        let schema = this.fn(values, base, options);
+        if (schema === void 0 || // @ts-ignore this can be base
+        schema === base) {
+          return base;
+        }
+        if (!isSchema(schema)) throw new TypeError("conditions must return a schema object");
+        return schema.resolve(options);
+      }
+    };
+    var prefixes = {
+      context: "$",
+      value: "."
+    };
+    function create$9(key, options) {
+      return new Reference(key, options);
+    }
+    var Reference = class {
+      constructor(key, options = {}) {
+        this.key = void 0;
+        this.isContext = void 0;
+        this.isValue = void 0;
+        this.isSibling = void 0;
+        this.path = void 0;
+        this.getter = void 0;
+        this.map = void 0;
+        if (typeof key !== "string") throw new TypeError("ref must be a string, got: " + key);
+        this.key = key.trim();
+        if (key === "") throw new TypeError("ref must be a non-empty string");
+        this.isContext = this.key[0] === prefixes.context;
+        this.isValue = this.key[0] === prefixes.value;
+        this.isSibling = !this.isContext && !this.isValue;
+        let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : "";
+        this.path = this.key.slice(prefix.length);
+        this.getter = this.path && propertyExpr.getter(this.path, true);
+        this.map = options.map;
+      }
+      getValue(value, parent, context) {
+        let result = this.isContext ? context : this.isValue ? value : parent;
+        if (this.getter) result = this.getter(result || {});
+        if (this.map) result = this.map(result);
+        return result;
+      }
+      /**
+       *
+       * @param {*} value
+       * @param {Object} options
+       * @param {Object=} options.context
+       * @param {Object=} options.parent
+       */
+      cast(value, options) {
+        return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
+      }
+      resolve() {
+        return this;
+      }
+      describe() {
+        return {
+          type: "ref",
+          key: this.key
+        };
+      }
+      toString() {
+        return `Ref(${this.key})`;
+      }
+      static isRef(value) {
+        return value && value.__isYupRef;
+      }
+    };
+    Reference.prototype.__isYupRef = true;
+    var isAbsent = (value) => value == null;
+    function createValidation(config2) {
+      function validate({
+        value,
+        path: path9 = "",
+        options,
+        originalValue,
+        schema
+      }, panic, next) {
+        const {
+          name,
+          test,
+          params,
+          message: message2,
+          skipAbsent
+        } = config2;
+        let {
+          parent,
+          context,
+          abortEarly = schema.spec.abortEarly,
+          disableStackTrace = schema.spec.disableStackTrace
+        } = options;
+        const resolveOptions = {
+          value,
+          parent,
+          context
+        };
+        function createError(overrides = {}) {
+          const nextParams = resolveParams(Object.assign({
+            value,
+            originalValue,
+            label: schema.spec.label,
+            path: overrides.path || path9,
+            spec: schema.spec,
+            disableStackTrace: overrides.disableStackTrace || disableStackTrace
+          }, params, overrides.params), resolveOptions);
+          const error = new ValidationError2(ValidationError2.formatError(overrides.message || message2, nextParams), value, nextParams.path, overrides.type || name, nextParams.disableStackTrace);
+          error.params = nextParams;
+          return error;
+        }
+        const invalid = abortEarly ? panic : next;
+        let ctx = {
+          path: path9,
+          parent,
+          type: name,
+          from: options.from,
+          createError,
+          resolve(item) {
+            return resolveMaybeRef(item, resolveOptions);
+          },
+          options,
+          originalValue,
+          schema
+        };
+        const handleResult = (validOrError) => {
+          if (ValidationError2.isError(validOrError)) invalid(validOrError);
+          else if (!validOrError) invalid(createError());
+          else next(null);
+        };
+        const handleError = (err) => {
+          if (ValidationError2.isError(err)) invalid(err);
+          else panic(err);
+        };
+        const shouldSkip = skipAbsent && isAbsent(value);
+        if (shouldSkip) {
+          return handleResult(true);
+        }
+        let result;
+        try {
+          var _result;
+          result = test.call(ctx, value, ctx);
+          if (typeof ((_result = result) == null ? void 0 : _result.then) === "function") {
+            if (options.sync) {
+              throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
+            }
+            return Promise.resolve(result).then(handleResult, handleError);
+          }
+        } catch (err) {
+          handleError(err);
+          return;
+        }
+        handleResult(result);
+      }
+      validate.OPTIONS = config2;
+      return validate;
+    }
+    function resolveParams(params, options) {
+      if (!params) return params;
+      for (const key of Object.keys(params)) {
+        params[key] = resolveMaybeRef(params[key], options);
+      }
+      return params;
+    }
+    function resolveMaybeRef(item, options) {
+      return Reference.isRef(item) ? item.getValue(options.value, options.parent, options.context) : item;
+    }
+    function getIn(schema, path9, value, context = value) {
+      let parent, lastPart, lastPartDebug;
+      if (!path9) return {
+        parent,
+        parentPath: path9,
+        schema
+      };
+      propertyExpr.forEach(path9, (_part, isBracket, isArray) => {
+        let part = isBracket ? _part.slice(1, _part.length - 1) : _part;
+        schema = schema.resolve({
+          context,
+          parent,
+          value
+        });
+        let isTuple = schema.type === "tuple";
+        let idx = isArray ? parseInt(part, 10) : 0;
+        if (schema.innerType || isTuple) {
+          if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${lastPartDebug}" must contain an index to the tuple element, e.g. "${lastPartDebug}[0]"`);
+          if (value && idx >= value.length) {
+            throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path9}. because there is no value at that index. `);
+          }
+          parent = value;
+          value = value && value[idx];
+          schema = isTuple ? schema.spec.types[idx] : schema.innerType;
+        }
+        if (!isArray) {
+          if (!schema.fields || !schema.fields[part]) throw new Error(`The schema does not contain the path: ${path9}. (failed at: ${lastPartDebug} which is a type: "${schema.type}")`);
+          parent = value;
+          value = value && value[part];
+          schema = schema.fields[part];
+        }
+        lastPart = part;
+        lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
+      });
+      return {
+        schema,
+        parent,
+        parentPath: lastPart
+      };
+    }
+    function reach(obj, path9, value, context) {
+      return getIn(obj, path9, value, context).schema;
+    }
+    var ReferenceSet = class _ReferenceSet extends Set {
+      describe() {
+        const description = [];
+        for (const item of this.values()) {
+          description.push(Reference.isRef(item) ? item.describe() : item);
+        }
+        return description;
+      }
+      resolveAll(resolve5) {
+        let result = [];
+        for (const item of this.values()) {
+          result.push(resolve5(item));
+        }
+        return result;
+      }
+      clone() {
+        return new _ReferenceSet(this.values());
+      }
+      merge(newItems, removeItems) {
+        const next = this.clone();
+        newItems.forEach((value) => next.add(value));
+        removeItems.forEach((value) => next.delete(value));
+        return next;
+      }
+    };
+    function clone(src, seen = /* @__PURE__ */ new Map()) {
+      if (isSchema(src) || !src || typeof src !== "object") return src;
+      if (seen.has(src)) return seen.get(src);
+      let copy;
+      if (src instanceof Date) {
+        copy = new Date(src.getTime());
+        seen.set(src, copy);
+      } else if (src instanceof RegExp) {
+        copy = new RegExp(src);
+        seen.set(src, copy);
+      } else if (Array.isArray(src)) {
+        copy = new Array(src.length);
+        seen.set(src, copy);
+        for (let i = 0; i < src.length; i++) copy[i] = clone(src[i], seen);
+      } else if (src instanceof Map) {
+        copy = /* @__PURE__ */ new Map();
+        seen.set(src, copy);
+        for (const [k, v] of src.entries()) copy.set(k, clone(v, seen));
+      } else if (src instanceof Set) {
+        copy = /* @__PURE__ */ new Set();
+        seen.set(src, copy);
+        for (const v of src) copy.add(clone(v, seen));
+      } else if (src instanceof Object) {
+        copy = {};
+        seen.set(src, copy);
+        for (const [k, v] of Object.entries(src)) copy[k] = clone(v, seen);
+      } else {
+        throw Error(`Unable to clone ${src}`);
+      }
+      return copy;
+    }
+    function createStandardPath(path9) {
+      if (!(path9 != null && path9.length)) {
+        return void 0;
+      }
+      const segments = [];
+      let currentSegment = "";
+      let inBrackets = false;
+      let inQuotes = false;
+      for (let i = 0; i < path9.length; i++) {
+        const char = path9[i];
+        if (char === "[" && !inQuotes) {
+          if (currentSegment) {
+            segments.push(...currentSegment.split(".").filter(Boolean));
+            currentSegment = "";
+          }
+          inBrackets = true;
+          continue;
+        }
+        if (char === "]" && !inQuotes) {
+          if (currentSegment) {
+            if (/^\d+$/.test(currentSegment)) {
+              segments.push(currentSegment);
+            } else {
+              segments.push(currentSegment.replace(/^"|"$/g, ""));
+            }
+            currentSegment = "";
+          }
+          inBrackets = false;
+          continue;
+        }
+        if (char === '"') {
+          inQuotes = !inQuotes;
+          continue;
+        }
+        if (char === "." && !inBrackets && !inQuotes) {
+          if (currentSegment) {
+            segments.push(currentSegment);
+            currentSegment = "";
+          }
+          continue;
+        }
+        currentSegment += char;
+      }
+      if (currentSegment) {
+        segments.push(...currentSegment.split(".").filter(Boolean));
+      }
+      return segments;
+    }
+    function createStandardIssues(error, parentPath) {
+      const path9 = parentPath ? `${parentPath}.${error.path}` : error.path;
+      return error.errors.map((err) => ({
+        message: err,
+        path: createStandardPath(path9)
+      }));
+    }
+    function issuesFromValidationError(error, parentPath) {
+      var _error$inner;
+      if (!((_error$inner = error.inner) != null && _error$inner.length) && error.errors.length) {
+        return createStandardIssues(error, parentPath);
+      }
+      const path9 = parentPath ? `${parentPath}.${error.path}` : error.path;
+      return error.inner.flatMap((err) => issuesFromValidationError(err, path9));
+    }
+    var Schema = class {
+      constructor(options) {
+        this.type = void 0;
+        this.deps = [];
+        this.tests = void 0;
+        this.transforms = void 0;
+        this.conditions = [];
+        this._mutate = void 0;
+        this.internalTests = {};
+        this._whitelist = new ReferenceSet();
+        this._blacklist = new ReferenceSet();
+        this.exclusiveTests = /* @__PURE__ */ Object.create(null);
+        this._typeCheck = void 0;
+        this.spec = void 0;
+        this.tests = [];
+        this.transforms = [];
+        this.withMutation(() => {
+          this.typeError(mixed.notType);
+        });
+        this.type = options.type;
+        this._typeCheck = options.check;
+        this.spec = Object.assign({
+          strip: false,
+          strict: false,
+          abortEarly: true,
+          recursive: true,
+          disableStackTrace: false,
+          nullable: false,
+          optional: true,
+          coerce: true
+        }, options == null ? void 0 : options.spec);
+        this.withMutation((s) => {
+          s.nonNullable();
+        });
+      }
+      // TODO: remove
+      get _type() {
+        return this.type;
+      }
+      clone(spec) {
+        if (this._mutate) {
+          if (spec) Object.assign(this.spec, spec);
+          return this;
+        }
+        const next = Object.create(Object.getPrototypeOf(this));
+        next.type = this.type;
+        next._typeCheck = this._typeCheck;
+        next._whitelist = this._whitelist.clone();
+        next._blacklist = this._blacklist.clone();
+        next.internalTests = Object.assign({}, this.internalTests);
+        next.exclusiveTests = Object.assign({}, this.exclusiveTests);
+        next.deps = [...this.deps];
+        next.conditions = [...this.conditions];
+        next.tests = [...this.tests];
+        next.transforms = [...this.transforms];
+        next.spec = clone(Object.assign({}, this.spec, spec));
+        return next;
+      }
+      label(label) {
+        let next = this.clone();
+        next.spec.label = label;
+        return next;
+      }
+      meta(...args2) {
+        if (args2.length === 0) return this.spec.meta;
+        let next = this.clone();
+        next.spec.meta = Object.assign(next.spec.meta || {}, args2[0]);
+        return next;
+      }
+      withMutation(fn) {
+        let before = this._mutate;
+        this._mutate = true;
+        let result = fn(this);
+        this._mutate = before;
+        return result;
+      }
+      concat(schema) {
+        if (!schema || schema === this) return this;
+        if (schema.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
+        let base = this;
+        let combined = schema.clone();
+        const mergedSpec = Object.assign({}, base.spec, combined.spec);
+        combined.spec = mergedSpec;
+        combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);
+        combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
+        combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
+        combined.tests = base.tests;
+        combined.exclusiveTests = base.exclusiveTests;
+        combined.withMutation((next) => {
+          schema.tests.forEach((fn) => {
+            next.test(fn.OPTIONS);
+          });
+        });
+        combined.transforms = [...base.transforms, ...combined.transforms];
+        return combined;
+      }
+      isType(v) {
+        if (v == null) {
+          if (this.spec.nullable && v === null) return true;
+          if (this.spec.optional && v === void 0) return true;
+          return false;
+        }
+        return this._typeCheck(v);
+      }
+      resolve(options) {
+        let schema = this;
+        if (schema.conditions.length) {
+          let conditions = schema.conditions;
+          schema = schema.clone();
+          schema.conditions = [];
+          schema = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema);
+          schema = schema.resolve(options);
+        }
+        return schema;
+      }
+      resolveOptions(options) {
+        var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
+        return Object.assign({}, options, {
+          from: options.from || [],
+          strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,
+          abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,
+          recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,
+          disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace
+        });
+      }
+      /**
+       * Run the configured transform pipeline over an input value.
+       */
+      cast(value, options = {}) {
+        let resolvedSchema = this.resolve(Object.assign({
+          value
+        }, options));
+        let allowOptionality = options.assert === "ignore-optionality";
+        let result = resolvedSchema._cast(value, options);
+        if (options.assert !== false && !resolvedSchema.isType(result)) {
+          if (allowOptionality && isAbsent(result)) {
+            return result;
+          }
+          let formattedValue = printValue(value);
+          let formattedResult = printValue(result);
+          throw new TypeError(`The value of ${options.path || "field"} could not be cast to a value that satisfies the schema type: "${resolvedSchema.type}". 
+
+attempted value: ${formattedValue} 
+` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ""));
+        }
+        return result;
+      }
+      _cast(rawValue, options) {
+        let value = rawValue === void 0 ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);
+        if (value === void 0) {
+          value = this.getDefault(options);
+        }
+        return value;
+      }
+      _validate(_value, options = {}, panic, next) {
+        let {
+          path: path9,
+          originalValue = _value,
+          strict = this.spec.strict
+        } = options;
+        let value = _value;
+        if (!strict) {
+          value = this._cast(value, Object.assign({
+            assert: false
+          }, options));
+        }
+        let initialTests = [];
+        for (let test of Object.values(this.internalTests)) {
+          if (test) initialTests.push(test);
+        }
+        this.runTests({
+          path: path9,
+          value,
+          originalValue,
+          options,
+          tests: initialTests
+        }, panic, (initialErrors) => {
+          if (initialErrors.length) {
+            return next(initialErrors, value);
+          }
+          this.runTests({
+            path: path9,
+            value,
+            originalValue,
+            options,
+            tests: this.tests
+          }, panic, next);
+        });
+      }
+      /**
+       * Executes a set of validations, either schema, produced Tests or a nested
+       * schema validate result.
+       */
+      runTests(runOptions, panic, next) {
+        let fired = false;
+        let {
+          tests,
+          value,
+          originalValue,
+          path: path9,
+          options
+        } = runOptions;
+        let panicOnce = (arg) => {
+          if (fired) return;
+          fired = true;
+          panic(arg, value);
+        };
+        let nextOnce = (arg) => {
+          if (fired) return;
+          fired = true;
+          next(arg, value);
+        };
+        let count = tests.length;
+        let nestedErrors = [];
+        if (!count) return nextOnce([]);
+        let args2 = {
+          value,
+          originalValue,
+          path: path9,
+          options,
+          schema: this
+        };
+        for (let i = 0; i < tests.length; i++) {
+          const test = tests[i];
+          test(args2, panicOnce, function finishTestRun(err) {
+            if (err) {
+              Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);
+            }
+            if (--count <= 0) {
+              nextOnce(nestedErrors);
+            }
+          });
+        }
+      }
+      asNestedTest({
+        key,
+        index,
+        parent,
+        parentPath,
+        originalParent,
+        options
+      }) {
+        const k = key != null ? key : index;
+        if (k == null) {
+          throw TypeError("Must include `key` or `index` for nested validations");
+        }
+        const isIndex = typeof k === "number";
+        let value = parent[k];
+        const testOptions = Object.assign({}, options, {
+          // Nested validations fields are always strict:
+          //    1. parent isn't strict so the casting will also have cast inner values
+          //    2. parent is strict in which case the nested values weren't cast either
+          strict: true,
+          parent,
+          value,
+          originalValue: originalParent[k],
+          // FIXME: tests depend on `index` being passed around deeply,
+          //   we should not let the options.key/index bleed through
+          key: void 0,
+          // index: undefined,
+          [isIndex ? "index" : "key"]: k,
+          path: isIndex || k.includes(".") ? `${parentPath || ""}[${isIndex ? k : `"${k}"`}]` : (parentPath ? `${parentPath}.` : "") + key
+        });
+        return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);
+      }
+      validate(value, options) {
+        var _options$disableStack2;
+        let schema = this.resolve(Object.assign({}, options, {
+          value
+        }));
+        let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;
+        return new Promise((resolve5, reject) => schema._validate(value, options, (error, parsed) => {
+          if (ValidationError2.isError(error)) error.value = parsed;
+          reject(error);
+        }, (errors, validated) => {
+          if (errors.length) reject(new ValidationError2(errors, validated, void 0, void 0, disableStackTrace));
+          else resolve5(validated);
+        }));
+      }
+      validateSync(value, options) {
+        var _options$disableStack3;
+        let schema = this.resolve(Object.assign({}, options, {
+          value
+        }));
+        let result;
+        let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;
+        schema._validate(value, Object.assign({}, options, {
+          sync: true
+        }), (error, parsed) => {
+          if (ValidationError2.isError(error)) error.value = parsed;
+          throw error;
+        }, (errors, validated) => {
+          if (errors.length) throw new ValidationError2(errors, value, void 0, void 0, disableStackTrace);
+          result = validated;
+        });
+        return result;
+      }
+      isValid(value, options) {
+        return this.validate(value, options).then(() => true, (err) => {
+          if (ValidationError2.isError(err)) return false;
+          throw err;
+        });
+      }
+      isValidSync(value, options) {
+        try {
+          this.validateSync(value, options);
+          return true;
+        } catch (err) {
+          if (ValidationError2.isError(err)) return false;
+          throw err;
+        }
+      }
+      _getDefault(options) {
+        let defaultValue = this.spec.default;
+        if (defaultValue == null) {
+          return defaultValue;
+        }
+        return typeof defaultValue === "function" ? defaultValue.call(this, options) : clone(defaultValue);
+      }
+      getDefault(options) {
+        let schema = this.resolve(options || {});
+        return schema._getDefault(options);
+      }
+      default(def) {
+        if (arguments.length === 0) {
+          return this._getDefault();
+        }
+        let next = this.clone({
+          default: def
+        });
+        return next;
+      }
+      strict(isStrict = true) {
+        return this.clone({
+          strict: isStrict
+        });
+      }
+      nullability(nullable, message2) {
+        const next = this.clone({
+          nullable
+        });
+        next.internalTests.nullable = createValidation({
+          message: message2,
+          name: "nullable",
+          test(value) {
+            return value === null ? this.schema.spec.nullable : true;
+          }
+        });
+        return next;
+      }
+      optionality(optional, message2) {
+        const next = this.clone({
+          optional
+        });
+        next.internalTests.optionality = createValidation({
+          message: message2,
+          name: "optionality",
+          test(value) {
+            return value === void 0 ? this.schema.spec.optional : true;
+          }
+        });
+        return next;
+      }
+      optional() {
+        return this.optionality(true);
+      }
+      defined(message2 = mixed.defined) {
+        return this.optionality(false, message2);
+      }
+      nullable() {
+        return this.nullability(true);
+      }
+      nonNullable(message2 = mixed.notNull) {
+        return this.nullability(false, message2);
+      }
+      required(message2 = mixed.required) {
+        return this.clone().withMutation((next) => next.nonNullable(message2).defined(message2));
+      }
+      notRequired() {
+        return this.clone().withMutation((next) => next.nullable().optional());
+      }
+      transform(fn) {
+        let next = this.clone();
+        next.transforms.push(fn);
+        return next;
+      }
+      /**
+       * Adds a test function to the schema's queue of tests.
+       * tests can be exclusive or non-exclusive.
+       *
+       * - exclusive tests, will replace any existing tests of the same name.
+       * - non-exclusive: can be stacked
+       *
+       * If a non-exclusive test is added to a schema with an exclusive test of the same name
+       * the exclusive test is removed and further tests of the same name will be stacked.
+       *
+       * If an exclusive test is added to a schema with non-exclusive tests of the same name
+       * the previous tests are removed and further tests of the same name will replace each other.
+       */
+      test(...args2) {
+        let opts;
+        if (args2.length === 1) {
+          if (typeof args2[0] === "function") {
+            opts = {
+              test: args2[0]
+            };
+          } else {
+            opts = args2[0];
+          }
+        } else if (args2.length === 2) {
+          opts = {
+            name: args2[0],
+            test: args2[1]
+          };
+        } else {
+          opts = {
+            name: args2[0],
+            message: args2[1],
+            test: args2[2]
+          };
+        }
+        if (opts.message === void 0) opts.message = mixed.default;
+        if (typeof opts.test !== "function") throw new TypeError("`test` is a required parameters");
+        let next = this.clone();
+        let validate = createValidation(opts);
+        let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
+        if (opts.exclusive) {
+          if (!opts.name) throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
+        }
+        if (opts.name) next.exclusiveTests[opts.name] = !!opts.exclusive;
+        next.tests = next.tests.filter((fn) => {
+          if (fn.OPTIONS.name === opts.name) {
+            if (isExclusive) return false;
+            if (fn.OPTIONS.test === validate.OPTIONS.test) return false;
+          }
+          return true;
+        });
+        next.tests.push(validate);
+        return next;
+      }
+      when(keys, options) {
+        if (!Array.isArray(keys) && typeof keys !== "string") {
+          options = keys;
+          keys = ".";
+        }
+        let next = this.clone();
+        let deps = toArray(keys).map((key) => new Reference(key));
+        deps.forEach((dep) => {
+          if (dep.isSibling) next.deps.push(dep.key);
+        });
+        next.conditions.push(typeof options === "function" ? new Condition(deps, options) : Condition.fromOptions(deps, options));
+        return next;
+      }
+      typeError(message2) {
+        let next = this.clone();
+        next.internalTests.typeError = createValidation({
+          message: message2,
+          name: "typeError",
+          skipAbsent: true,
+          test(value) {
+            if (!this.schema._typeCheck(value)) return this.createError({
+              params: {
+                type: this.schema.type
+              }
+            });
+            return true;
+          }
+        });
+        return next;
+      }
+      oneOf(enums, message2 = mixed.oneOf) {
+        let next = this.clone();
+        enums.forEach((val) => {
+          next._whitelist.add(val);
+          next._blacklist.delete(val);
+        });
+        next.internalTests.whiteList = createValidation({
+          message: message2,
+          name: "oneOf",
+          skipAbsent: true,
+          test(value) {
+            let valids = this.schema._whitelist;
+            let resolved = valids.resolveAll(this.resolve);
+            return resolved.includes(value) ? true : this.createError({
+              params: {
+                values: Array.from(valids).join(", "),
+                resolved
+              }
+            });
+          }
+        });
+        return next;
+      }
+      notOneOf(enums, message2 = mixed.notOneOf) {
+        let next = this.clone();
+        enums.forEach((val) => {
+          next._blacklist.add(val);
+          next._whitelist.delete(val);
+        });
+        next.internalTests.blacklist = createValidation({
+          message: message2,
+          name: "notOneOf",
+          test(value) {
+            let invalids = this.schema._blacklist;
+            let resolved = invalids.resolveAll(this.resolve);
+            if (resolved.includes(value)) return this.createError({
+              params: {
+                values: Array.from(invalids).join(", "),
+                resolved
+              }
+            });
+            return true;
+          }
+        });
+        return next;
+      }
+      strip(strip = true) {
+        let next = this.clone();
+        next.spec.strip = strip;
+        return next;
+      }
+      /**
+       * Return a serialized description of the schema including validations, flags, types etc.
+       *
+       * @param options Provide any needed context for resolving runtime schema alterations (lazy, when conditions, etc).
+       */
+      describe(options) {
+        const next = (options ? this.resolve(options) : this).clone();
+        const {
+          label,
+          meta,
+          optional,
+          nullable
+        } = next.spec;
+        const description = {
+          meta,
+          label,
+          optional,
+          nullable,
+          default: next.getDefault(options),
+          type: next.type,
+          oneOf: next._whitelist.describe(),
+          notOneOf: next._blacklist.describe(),
+          tests: next.tests.filter((n, idx, list) => list.findIndex((c) => c.OPTIONS.name === n.OPTIONS.name) === idx).map((fn) => {
+            const params = fn.OPTIONS.params && options ? resolveParams(Object.assign({}, fn.OPTIONS.params), options) : fn.OPTIONS.params;
+            return {
+              name: fn.OPTIONS.name,
+              params
+            };
+          })
+        };
+        return description;
+      }
+      get ["~standard"]() {
+        const schema = this;
+        const standard = {
+          version: 1,
+          vendor: "yup",
+          async validate(value) {
+            try {
+              const result = await schema.validate(value, {
+                abortEarly: false
+              });
+              return {
+                value: result
+              };
+            } catch (err) {
+              if (err instanceof ValidationError2) {
+                return {
+                  issues: issuesFromValidationError(err)
+                };
+              }
+              throw err;
+            }
+          }
+        };
+        return standard;
+      }
+    };
+    Schema.prototype.__isYupSchema__ = true;
+    for (const method of ["validate", "validateSync"]) Schema.prototype[`${method}At`] = function(path9, value, options = {}) {
+      const {
+        parent,
+        parentPath,
+        schema
+      } = getIn(this, path9, value, options.context);
+      return schema[method](parent && parent[parentPath], Object.assign({}, options, {
+        parent,
+        path: path9
+      }));
+    };
+    for (const alias of ["equals", "is"]) Schema.prototype[alias] = Schema.prototype.oneOf;
+    for (const alias of ["not", "nope"]) Schema.prototype[alias] = Schema.prototype.notOneOf;
+    var returnsTrue = () => true;
+    function create$8(spec) {
+      return new MixedSchema(spec);
+    }
+    var MixedSchema = class extends Schema {
+      constructor(spec) {
+        super(typeof spec === "function" ? {
+          type: "mixed",
+          check: spec
+        } : Object.assign({
+          type: "mixed",
+          check: returnsTrue
+        }, spec));
+      }
+    };
+    create$8.prototype = MixedSchema.prototype;
+    function create$7() {
+      return new BooleanSchema();
+    }
+    var BooleanSchema = class extends Schema {
+      constructor() {
+        super({
+          type: "boolean",
+          check(v) {
+            if (v instanceof Boolean) v = v.valueOf();
+            return typeof v === "boolean";
+          }
+        });
+        this.withMutation(() => {
+          this.transform((value, _raw, ctx) => {
+            if (ctx.spec.coerce && !ctx.isType(value)) {
+              if (/^(true|1)$/i.test(String(value))) return true;
+              if (/^(false|0)$/i.test(String(value))) return false;
+            }
+            return value;
+          });
+        });
+      }
+      isTrue(message2 = boolean2.isValue) {
+        return this.test({
+          message: message2,
+          name: "is-value",
+          exclusive: true,
+          params: {
+            value: "true"
+          },
+          test(value) {
+            return isAbsent(value) || value === true;
+          }
+        });
+      }
+      isFalse(message2 = boolean2.isValue) {
+        return this.test({
+          message: message2,
+          name: "is-value",
+          exclusive: true,
+          params: {
+            value: "false"
+          },
+          test(value) {
+            return isAbsent(value) || value === false;
+          }
+        });
+      }
+      default(def) {
+        return super.default(def);
+      }
+      defined(msg) {
+        return super.defined(msg);
+      }
+      optional() {
+        return super.optional();
+      }
+      required(msg) {
+        return super.required(msg);
+      }
+      notRequired() {
+        return super.notRequired();
+      }
+      nullable() {
+        return super.nullable();
+      }
+      nonNullable(msg) {
+        return super.nonNullable(msg);
+      }
+      strip(v) {
+        return super.strip(v);
+      }
+    };
+    create$7.prototype = BooleanSchema.prototype;
+    var isoReg = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
+    function parseIsoDate(date3) {
+      const struct = parseDateStruct(date3);
+      if (!struct) return Date.parse ? Date.parse(date3) : Number.NaN;
+      if (struct.z === void 0 && struct.plusMinus === void 0) {
+        return new Date(struct.year, struct.month, struct.day, struct.hour, struct.minute, struct.second, struct.millisecond).valueOf();
+      }
+      let totalMinutesOffset = 0;
+      if (struct.z !== "Z" && struct.plusMinus !== void 0) {
+        totalMinutesOffset = struct.hourOffset * 60 + struct.minuteOffset;
+        if (struct.plusMinus === "+") totalMinutesOffset = 0 - totalMinutesOffset;
+      }
+      return Date.UTC(struct.year, struct.month, struct.day, struct.hour, struct.minute + totalMinutesOffset, struct.second, struct.millisecond);
+    }
+    function parseDateStruct(date3) {
+      var _regexResult$7$length, _regexResult$;
+      const regexResult = isoReg.exec(date3);
+      if (!regexResult) return null;
+      return {
+        year: toNumber(regexResult[1]),
+        month: toNumber(regexResult[2], 1) - 1,
+        day: toNumber(regexResult[3], 1),
+        hour: toNumber(regexResult[4]),
+        minute: toNumber(regexResult[5]),
+        second: toNumber(regexResult[6]),
+        millisecond: regexResult[7] ? (
+          // allow arbitrary sub-second precision beyond milliseconds
+          toNumber(regexResult[7].substring(0, 3))
+        ) : 0,
+        precision: (_regexResult$7$length = (_regexResult$ = regexResult[7]) == null ? void 0 : _regexResult$.length) != null ? _regexResult$7$length : void 0,
+        z: regexResult[8] || void 0,
+        plusMinus: regexResult[9] || void 0,
+        hourOffset: toNumber(regexResult[10]),
+        minuteOffset: toNumber(regexResult[11])
+      };
+    }
+    function toNumber(str, defaultValue = 0) {
+      return Number(str) || defaultValue;
+    }
+    var rEmail = (
+      // eslint-disable-next-line
+      /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+    );
+    var rUrl = (
+      // eslint-disable-next-line
+      /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i
+    );
+    var rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+    var yearMonthDay = "^\\d{4}-\\d{2}-\\d{2}";
+    var hourMinuteSecond = "\\d{2}:\\d{2}:\\d{2}";
+    var zOrOffset = "(([+-]\\d{2}(:?\\d{2})?)|Z)";
+    var rIsoDateTime = new RegExp(`${yearMonthDay}T${hourMinuteSecond}(\\.\\d+)?${zOrOffset}$`);
+    var isTrimmed = (value) => isAbsent(value) || value === value.trim();
+    var objStringTag = {}.toString();
+    function create$6() {
+      return new StringSchema();
+    }
+    var StringSchema = class extends Schema {
+      constructor() {
+        super({
+          type: "string",
+          check(value) {
+            if (value instanceof String) value = value.valueOf();
+            return typeof value === "string";
+          }
+        });
+        this.withMutation(() => {
+          this.transform((value, _raw, ctx) => {
+            if (!ctx.spec.coerce || ctx.isType(value)) return value;
+            if (Array.isArray(value)) return value;
+            const strValue = value != null && value.toString ? value.toString() : value;
+            if (strValue === objStringTag) return value;
+            return strValue;
+          });
+        });
+      }
+      required(message2) {
+        return super.required(message2).withMutation((schema) => schema.test({
+          message: message2 || mixed.required,
+          name: "required",
+          skipAbsent: true,
+          test: (value) => !!value.length
+        }));
+      }
+      notRequired() {
+        return super.notRequired().withMutation((schema) => {
+          schema.tests = schema.tests.filter((t) => t.OPTIONS.name !== "required");
+          return schema;
+        });
+      }
+      length(length, message2 = string2.length) {
+        return this.test({
+          message: message2,
+          name: "length",
+          exclusive: true,
+          params: {
+            length
+          },
+          skipAbsent: true,
+          test(value) {
+            return value.length === this.resolve(length);
+          }
+        });
+      }
+      min(min, message2 = string2.min) {
+        return this.test({
+          message: message2,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          skipAbsent: true,
+          test(value) {
+            return value.length >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message2 = string2.max) {
+        return this.test({
+          name: "max",
+          exclusive: true,
+          message: message2,
+          params: {
+            max
+          },
+          skipAbsent: true,
+          test(value) {
+            return value.length <= this.resolve(max);
+          }
+        });
+      }
+      matches(regex, options) {
+        let excludeEmptyString = false;
+        let message2;
+        let name;
+        if (options) {
+          if (typeof options === "object") {
+            ({
+              excludeEmptyString = false,
+              message: message2,
+              name
+            } = options);
+          } else {
+            message2 = options;
+          }
+        }
+        return this.test({
+          name: name || "matches",
+          message: message2 || string2.matches,
+          params: {
+            regex
+          },
+          skipAbsent: true,
+          test: (value) => value === "" && excludeEmptyString || value.search(regex) !== -1
+        });
+      }
+      email(message2 = string2.email) {
+        return this.matches(rEmail, {
+          name: "email",
+          message: message2,
+          excludeEmptyString: true
+        });
+      }
+      url(message2 = string2.url) {
+        return this.matches(rUrl, {
+          name: "url",
+          message: message2,
+          excludeEmptyString: true
+        });
+      }
+      uuid(message2 = string2.uuid) {
+        return this.matches(rUUID, {
+          name: "uuid",
+          message: message2,
+          excludeEmptyString: false
+        });
+      }
+      datetime(options) {
+        let message2 = "";
+        let allowOffset;
+        let precision;
+        if (options) {
+          if (typeof options === "object") {
+            ({
+              message: message2 = "",
+              allowOffset = false,
+              precision = void 0
+            } = options);
+          } else {
+            message2 = options;
+          }
+        }
+        return this.matches(rIsoDateTime, {
+          name: "datetime",
+          message: message2 || string2.datetime,
+          excludeEmptyString: true
+        }).test({
+          name: "datetime_offset",
+          message: message2 || string2.datetime_offset,
+          params: {
+            allowOffset
+          },
+          skipAbsent: true,
+          test: (value) => {
+            if (!value || allowOffset) return true;
+            const struct = parseDateStruct(value);
+            if (!struct) return false;
+            return !!struct.z;
+          }
+        }).test({
+          name: "datetime_precision",
+          message: message2 || string2.datetime_precision,
+          params: {
+            precision
+          },
+          skipAbsent: true,
+          test: (value) => {
+            if (!value || precision == void 0) return true;
+            const struct = parseDateStruct(value);
+            if (!struct) return false;
+            return struct.precision === precision;
+          }
+        });
+      }
+      //-- transforms --
+      ensure() {
+        return this.default("").transform((val) => val === null ? "" : val);
+      }
+      trim(message2 = string2.trim) {
+        return this.transform((val) => val != null ? val.trim() : val).test({
+          message: message2,
+          name: "trim",
+          test: isTrimmed
+        });
+      }
+      lowercase(message2 = string2.lowercase) {
+        return this.transform((value) => !isAbsent(value) ? value.toLowerCase() : value).test({
+          message: message2,
+          name: "string_case",
+          exclusive: true,
+          skipAbsent: true,
+          test: (value) => isAbsent(value) || value === value.toLowerCase()
+        });
+      }
+      uppercase(message2 = string2.uppercase) {
+        return this.transform((value) => !isAbsent(value) ? value.toUpperCase() : value).test({
+          message: message2,
+          name: "string_case",
+          exclusive: true,
+          skipAbsent: true,
+          test: (value) => isAbsent(value) || value === value.toUpperCase()
+        });
+      }
+    };
+    create$6.prototype = StringSchema.prototype;
+    var isNaN$1 = (value) => value != +value;
+    function create$5() {
+      return new NumberSchema();
+    }
+    var NumberSchema = class extends Schema {
+      constructor() {
+        super({
+          type: "number",
+          check(value) {
+            if (value instanceof Number) value = value.valueOf();
+            return typeof value === "number" && !isNaN$1(value);
+          }
+        });
+        this.withMutation(() => {
+          this.transform((value, _raw, ctx) => {
+            if (!ctx.spec.coerce) return value;
+            let parsed = value;
+            if (typeof parsed === "string") {
+              parsed = parsed.replace(/\s/g, "");
+              if (parsed === "") return NaN;
+              parsed = +parsed;
+            }
+            if (ctx.isType(parsed) || parsed === null) return parsed;
+            return parseFloat(parsed);
+          });
+        });
+      }
+      min(min, message2 = number2.min) {
+        return this.test({
+          message: message2,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          skipAbsent: true,
+          test(value) {
+            return value >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message2 = number2.max) {
+        return this.test({
+          message: message2,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          skipAbsent: true,
+          test(value) {
+            return value <= this.resolve(max);
+          }
+        });
+      }
+      lessThan(less, message2 = number2.lessThan) {
+        return this.test({
+          message: message2,
+          name: "max",
+          exclusive: true,
+          params: {
+            less
+          },
+          skipAbsent: true,
+          test(value) {
+            return value < this.resolve(less);
+          }
+        });
+      }
+      moreThan(more, message2 = number2.moreThan) {
+        return this.test({
+          message: message2,
+          name: "min",
+          exclusive: true,
+          params: {
+            more
+          },
+          skipAbsent: true,
+          test(value) {
+            return value > this.resolve(more);
+          }
+        });
+      }
+      positive(msg = number2.positive) {
+        return this.moreThan(0, msg);
+      }
+      negative(msg = number2.negative) {
+        return this.lessThan(0, msg);
+      }
+      integer(message2 = number2.integer) {
+        return this.test({
+          name: "integer",
+          message: message2,
+          skipAbsent: true,
+          test: (val) => Number.isInteger(val)
+        });
+      }
+      truncate() {
+        return this.transform((value) => !isAbsent(value) ? value | 0 : value);
+      }
+      round(method) {
+        var _method;
+        let avail = ["ceil", "floor", "round", "trunc"];
+        method = ((_method = method) == null ? void 0 : _method.toLowerCase()) || "round";
+        if (method === "trunc") return this.truncate();
+        if (avail.indexOf(method.toLowerCase()) === -1) throw new TypeError("Only valid options for round() are: " + avail.join(", "));
+        return this.transform((value) => !isAbsent(value) ? Math[method](value) : value);
+      }
+    };
+    create$5.prototype = NumberSchema.prototype;
+    var invalidDate = /* @__PURE__ */ new Date("");
+    var isDate = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
+    function create$4() {
+      return new DateSchema();
+    }
+    var DateSchema = class _DateSchema extends Schema {
+      constructor() {
+        super({
+          type: "date",
+          check(v) {
+            return isDate(v) && !isNaN(v.getTime());
+          }
+        });
+        this.withMutation(() => {
+          this.transform((value, _raw, ctx) => {
+            if (!ctx.spec.coerce || ctx.isType(value) || value === null) return value;
+            value = parseIsoDate(value);
+            return !isNaN(value) ? new Date(value) : _DateSchema.INVALID_DATE;
+          });
+        });
+      }
+      prepareParam(ref, name) {
+        let param;
+        if (!Reference.isRef(ref)) {
+          let cast = this.cast(ref);
+          if (!this._typeCheck(cast)) throw new TypeError(`\`${name}\` must be a Date or a value that can be \`cast()\` to a Date`);
+          param = cast;
+        } else {
+          param = ref;
+        }
+        return param;
+      }
+      min(min, message2 = date2.min) {
+        let limit4 = this.prepareParam(min, "min");
+        return this.test({
+          message: message2,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          skipAbsent: true,
+          test(value) {
+            return value >= this.resolve(limit4);
+          }
+        });
+      }
+      max(max, message2 = date2.max) {
+        let limit4 = this.prepareParam(max, "max");
+        return this.test({
+          message: message2,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          skipAbsent: true,
+          test(value) {
+            return value <= this.resolve(limit4);
+          }
+        });
+      }
+    };
+    DateSchema.INVALID_DATE = invalidDate;
+    create$4.prototype = DateSchema.prototype;
+    create$4.INVALID_DATE = invalidDate;
+    function sortFields(fields, excludedEdges = []) {
+      let edges = [];
+      let nodes = /* @__PURE__ */ new Set();
+      let excludes = new Set(excludedEdges.map(([a, b]) => `${a}-${b}`));
+      function addNode(depPath, key) {
+        let node = propertyExpr.split(depPath)[0];
+        nodes.add(node);
+        if (!excludes.has(`${key}-${node}`)) edges.push([key, node]);
+      }
+      for (const key of Object.keys(fields)) {
+        let value = fields[key];
+        nodes.add(key);
+        if (Reference.isRef(value) && value.isSibling) addNode(value.path, key);
+        else if (isSchema(value) && "deps" in value) value.deps.forEach((path9) => addNode(path9, key));
+      }
+      return toposort__default["default"].array(Array.from(nodes), edges).reverse();
+    }
+    function findIndex(arr, err) {
+      let idx = Infinity;
+      arr.some((key, ii) => {
+        var _err$path;
+        if ((_err$path = err.path) != null && _err$path.includes(key)) {
+          idx = ii;
+          return true;
+        }
+      });
+      return idx;
+    }
+    function sortByKeyOrder(keys) {
+      return (a, b) => {
+        return findIndex(keys, a) - findIndex(keys, b);
+      };
+    }
+    var parseJson = (value, _, ctx) => {
+      if (typeof value !== "string") {
+        return value;
+      }
+      let parsed = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch (err) {
+      }
+      return ctx.isType(parsed) ? parsed : value;
+    };
+    function deepPartial(schema) {
+      if ("fields" in schema) {
+        const partial = {};
+        for (const [key, fieldSchema] of Object.entries(schema.fields)) {
+          partial[key] = deepPartial(fieldSchema);
+        }
+        return schema.setFields(partial);
+      }
+      if (schema.type === "array") {
+        const nextArray = schema.optional();
+        if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);
+        return nextArray;
+      }
+      if (schema.type === "tuple") {
+        return schema.optional().clone({
+          types: schema.spec.types.map(deepPartial)
+        });
+      }
+      if ("optional" in schema) {
+        return schema.optional();
+      }
+      return schema;
+    }
+    var deepHas = (obj, p) => {
+      const path9 = [...propertyExpr.normalizePath(p)];
+      if (path9.length === 1) return path9[0] in obj;
+      let last = path9.pop();
+      let parent = propertyExpr.getter(propertyExpr.join(path9), true)(obj);
+      return !!(parent && last in parent);
+    };
+    var isObject = (obj) => Object.prototype.toString.call(obj) === "[object Object]";
+    function unknown(ctx, value) {
+      let known = Object.keys(ctx.fields);
+      return Object.keys(value).filter((key) => known.indexOf(key) === -1);
+    }
+    var defaultSort = sortByKeyOrder([]);
+    function create$3(spec) {
+      return new ObjectSchema(spec);
+    }
+    var ObjectSchema = class extends Schema {
+      constructor(spec) {
+        super({
+          type: "object",
+          check(value) {
+            return isObject(value) || typeof value === "function";
+          }
+        });
+        this.fields = /* @__PURE__ */ Object.create(null);
+        this._sortErrors = defaultSort;
+        this._nodes = [];
+        this._excludedEdges = [];
+        this.withMutation(() => {
+          if (spec) {
+            this.shape(spec);
+          }
+        });
+      }
+      _cast(_value, options = {}) {
+        var _options$stripUnknown;
+        let value = super._cast(_value, options);
+        if (value === void 0) return this.getDefault(options);
+        if (!this._typeCheck(value)) return value;
+        let fields = this.fields;
+        let strip = (_options$stripUnknown = options.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;
+        let props = [].concat(this._nodes, Object.keys(value).filter((v) => !this._nodes.includes(v)));
+        let intermediateValue = {};
+        let innerOptions = Object.assign({}, options, {
+          parent: intermediateValue,
+          __validating: options.__validating || false
+        });
+        let isChanged = false;
+        for (const prop of props) {
+          let field = fields[prop];
+          let exists2 = prop in value;
+          if (field) {
+            let fieldValue;
+            let inputValue = value[prop];
+            innerOptions.path = (options.path ? `${options.path}.` : "") + prop;
+            field = field.resolve({
+              value: inputValue,
+              context: options.context,
+              parent: intermediateValue
+            });
+            let fieldSpec = field instanceof Schema ? field.spec : void 0;
+            let strict = fieldSpec == null ? void 0 : fieldSpec.strict;
+            if (fieldSpec != null && fieldSpec.strip) {
+              isChanged = isChanged || prop in value;
+              continue;
+            }
+            fieldValue = !options.__validating || !strict ? (
+              // TODO: use _cast, this is double resolving
+              field.cast(value[prop], innerOptions)
+            ) : value[prop];
+            if (fieldValue !== void 0) {
+              intermediateValue[prop] = fieldValue;
+            }
+          } else if (exists2 && !strip) {
+            intermediateValue[prop] = value[prop];
+          }
+          if (exists2 !== prop in intermediateValue || intermediateValue[prop] !== value[prop]) {
+            isChanged = true;
+          }
+        }
+        return isChanged ? intermediateValue : value;
+      }
+      _validate(_value, options = {}, panic, next) {
+        let {
+          from = [],
+          originalValue = _value,
+          recursive = this.spec.recursive
+        } = options;
+        options.from = [{
+          schema: this,
+          value: originalValue
+        }, ...from];
+        options.__validating = true;
+        options.originalValue = originalValue;
+        super._validate(_value, options, panic, (objectErrors, value) => {
+          if (!recursive || !isObject(value)) {
+            next(objectErrors, value);
+            return;
+          }
+          originalValue = originalValue || value;
+          let tests = [];
+          for (let key of this._nodes) {
+            let field = this.fields[key];
+            if (!field || Reference.isRef(field)) {
+              continue;
+            }
+            tests.push(field.asNestedTest({
+              options,
+              key,
+              parent: value,
+              parentPath: options.path,
+              originalParent: originalValue
+            }));
+          }
+          this.runTests({
+            tests,
+            value,
+            originalValue,
+            options
+          }, panic, (fieldErrors) => {
+            next(fieldErrors.sort(this._sortErrors).concat(objectErrors), value);
+          });
+        });
+      }
+      clone(spec) {
+        const next = super.clone(spec);
+        next.fields = Object.assign({}, this.fields);
+        next._nodes = this._nodes;
+        next._excludedEdges = this._excludedEdges;
+        next._sortErrors = this._sortErrors;
+        return next;
+      }
+      concat(schema) {
+        let next = super.concat(schema);
+        let nextFields = next.fields;
+        for (let [field, schemaOrRef] of Object.entries(this.fields)) {
+          const target = nextFields[field];
+          nextFields[field] = target === void 0 ? schemaOrRef : target;
+        }
+        return next.withMutation((s) => (
+          // XXX: excludes here is wrong
+          s.setFields(nextFields, [...this._excludedEdges, ...schema._excludedEdges])
+        ));
+      }
+      _getDefault(options) {
+        if ("default" in this.spec) {
+          return super._getDefault(options);
+        }
+        if (!this._nodes.length) {
+          return void 0;
+        }
+        let dft = {};
+        this._nodes.forEach((key) => {
+          var _innerOptions;
+          const field = this.fields[key];
+          let innerOptions = options;
+          if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+            innerOptions = Object.assign({}, innerOptions, {
+              parent: innerOptions.value,
+              value: innerOptions.value[key]
+            });
+          }
+          dft[key] = field && "getDefault" in field ? field.getDefault(innerOptions) : void 0;
+        });
+        return dft;
+      }
+      setFields(shape, excludedEdges) {
+        let next = this.clone();
+        next.fields = shape;
+        next._nodes = sortFields(shape, excludedEdges);
+        next._sortErrors = sortByKeyOrder(Object.keys(shape));
+        if (excludedEdges) next._excludedEdges = excludedEdges;
+        return next;
+      }
+      shape(additions, excludes = []) {
+        return this.clone().withMutation((next) => {
+          let edges = next._excludedEdges;
+          if (excludes.length) {
+            if (!Array.isArray(excludes[0])) excludes = [excludes];
+            edges = [...next._excludedEdges, ...excludes];
+          }
+          return next.setFields(Object.assign(next.fields, additions), edges);
+        });
+      }
+      partial() {
+        const partial = {};
+        for (const [key, schema] of Object.entries(this.fields)) {
+          partial[key] = "optional" in schema && schema.optional instanceof Function ? schema.optional() : schema;
+        }
+        return this.setFields(partial);
+      }
+      deepPartial() {
+        const next = deepPartial(this);
+        return next;
+      }
+      pick(keys) {
+        const picked = {};
+        for (const key of keys) {
+          if (this.fields[key]) picked[key] = this.fields[key];
+        }
+        return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));
+      }
+      omit(keys) {
+        const remaining = [];
+        for (const key of Object.keys(this.fields)) {
+          if (keys.includes(key)) continue;
+          remaining.push(key);
+        }
+        return this.pick(remaining);
+      }
+      from(from, to, alias) {
+        let fromGetter = propertyExpr.getter(from, true);
+        return this.transform((obj) => {
+          if (!obj) return obj;
+          let newObj = obj;
+          if (deepHas(obj, from)) {
+            newObj = Object.assign({}, obj);
+            if (!alias) delete newObj[from];
+            newObj[to] = fromGetter(obj);
+          }
+          return newObj;
+        });
+      }
+      /** Parse an input JSON string to an object */
+      json() {
+        return this.transform(parseJson);
+      }
+      /**
+       * Similar to `noUnknown` but only validates that an object is the right shape without stripping the unknown keys
+       */
+      exact(message2) {
+        return this.test({
+          name: "exact",
+          exclusive: true,
+          message: message2 || object2.exact,
+          test(value) {
+            if (value == null) return true;
+            const unknownKeys = unknown(this.schema, value);
+            return unknownKeys.length === 0 || this.createError({
+              params: {
+                properties: unknownKeys.join(", ")
+              }
+            });
+          }
+        });
+      }
+      stripUnknown() {
+        return this.clone({
+          noUnknown: true
+        });
+      }
+      noUnknown(noAllow = true, message2 = object2.noUnknown) {
+        if (typeof noAllow !== "boolean") {
+          message2 = noAllow;
+          noAllow = true;
+        }
+        let next = this.test({
+          name: "noUnknown",
+          exclusive: true,
+          message: message2,
+          test(value) {
+            if (value == null) return true;
+            const unknownKeys = unknown(this.schema, value);
+            return !noAllow || unknownKeys.length === 0 || this.createError({
+              params: {
+                unknown: unknownKeys.join(", ")
+              }
+            });
+          }
+        });
+        next.spec.noUnknown = noAllow;
+        return next;
+      }
+      unknown(allow = true, message2 = object2.noUnknown) {
+        return this.noUnknown(!allow, message2);
+      }
+      transformKeys(fn) {
+        return this.transform((obj) => {
+          if (!obj) return obj;
+          const result = {};
+          for (const key of Object.keys(obj)) result[fn(key)] = obj[key];
+          return result;
+        });
+      }
+      camelCase() {
+        return this.transformKeys(tinyCase.camelCase);
+      }
+      snakeCase() {
+        return this.transformKeys(tinyCase.snakeCase);
+      }
+      constantCase() {
+        return this.transformKeys((key) => tinyCase.snakeCase(key).toUpperCase());
+      }
+      describe(options) {
+        const next = (options ? this.resolve(options) : this).clone();
+        const base = super.describe(options);
+        base.fields = {};
+        for (const [key, value] of Object.entries(next.fields)) {
+          var _innerOptions2;
+          let innerOptions = options;
+          if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {
+            innerOptions = Object.assign({}, innerOptions, {
+              parent: innerOptions.value,
+              value: innerOptions.value[key]
+            });
+          }
+          base.fields[key] = value.describe(innerOptions);
+        }
+        return base;
+      }
+    };
+    create$3.prototype = ObjectSchema.prototype;
+    function create$2(type) {
+      return new ArraySchema(type);
+    }
+    var ArraySchema = class extends Schema {
+      constructor(type) {
+        super({
+          type: "array",
+          spec: {
+            types: type
+          },
+          check(v) {
+            return Array.isArray(v);
+          }
+        });
+        this.innerType = void 0;
+        this.innerType = type;
+      }
+      _cast(_value, _opts) {
+        const value = super._cast(_value, _opts);
+        if (!this._typeCheck(value) || !this.innerType) {
+          return value;
+        }
+        let isChanged = false;
+        const castArray = value.map((v, idx) => {
+          const castElement = this.innerType.cast(v, Object.assign({}, _opts, {
+            path: `${_opts.path || ""}[${idx}]`
+          }));
+          if (castElement !== v) {
+            isChanged = true;
+          }
+          return castElement;
+        });
+        return isChanged ? castArray : value;
+      }
+      _validate(_value, options = {}, panic, next) {
+        var _options$recursive;
+        let innerType = this.innerType;
+        let recursive = (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive;
+        options.originalValue != null ? options.originalValue : _value;
+        super._validate(_value, options, panic, (arrayErrors, value) => {
+          var _options$originalValu2;
+          if (!recursive || !innerType || !this._typeCheck(value)) {
+            next(arrayErrors, value);
+            return;
+          }
+          let tests = new Array(value.length);
+          for (let index = 0; index < value.length; index++) {
+            var _options$originalValu;
+            tests[index] = innerType.asNestedTest({
+              options,
+              index,
+              parent: value,
+              parentPath: options.path,
+              originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value
+            });
+          }
+          this.runTests({
+            value,
+            tests,
+            originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,
+            options
+          }, panic, (innerTypeErrors) => next(innerTypeErrors.concat(arrayErrors), value));
+        });
+      }
+      clone(spec) {
+        const next = super.clone(spec);
+        next.innerType = this.innerType;
+        return next;
+      }
+      /** Parse an input JSON string to an object */
+      json() {
+        return this.transform(parseJson);
+      }
+      concat(schema) {
+        let next = super.concat(schema);
+        next.innerType = this.innerType;
+        if (schema.innerType)
+          next.innerType = next.innerType ? (
+            // @ts-expect-error Lazy doesn't have concat and will break
+            next.innerType.concat(schema.innerType)
+          ) : schema.innerType;
+        return next;
+      }
+      of(schema) {
+        let next = this.clone();
+        if (!isSchema(schema)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema));
+        next.innerType = schema;
+        next.spec = Object.assign({}, next.spec, {
+          types: schema
+        });
+        return next;
+      }
+      length(length, message2 = array.length) {
+        return this.test({
+          message: message2,
+          name: "length",
+          exclusive: true,
+          params: {
+            length
+          },
+          skipAbsent: true,
+          test(value) {
+            return value.length === this.resolve(length);
+          }
+        });
+      }
+      min(min, message2) {
+        message2 = message2 || array.min;
+        return this.test({
+          message: message2,
+          name: "min",
+          exclusive: true,
+          params: {
+            min
+          },
+          skipAbsent: true,
+          // FIXME(ts): Array<typeof T>
+          test(value) {
+            return value.length >= this.resolve(min);
+          }
+        });
+      }
+      max(max, message2) {
+        message2 = message2 || array.max;
+        return this.test({
+          message: message2,
+          name: "max",
+          exclusive: true,
+          params: {
+            max
+          },
+          skipAbsent: true,
+          test(value) {
+            return value.length <= this.resolve(max);
+          }
+        });
+      }
+      ensure() {
+        return this.default(() => []).transform((val, original) => {
+          if (this._typeCheck(val)) return val;
+          return original == null ? [] : [].concat(original);
+        });
+      }
+      compact(rejector) {
+        let reject = !rejector ? (v) => !!v : (v, i, a) => !rejector(v, i, a);
+        return this.transform((values) => values != null ? values.filter(reject) : values);
+      }
+      describe(options) {
+        const next = (options ? this.resolve(options) : this).clone();
+        const base = super.describe(options);
+        if (next.innerType) {
+          var _innerOptions;
+          let innerOptions = options;
+          if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+            innerOptions = Object.assign({}, innerOptions, {
+              parent: innerOptions.value,
+              value: innerOptions.value[0]
+            });
+          }
+          base.innerType = next.innerType.describe(innerOptions);
+        }
+        return base;
+      }
+    };
+    create$2.prototype = ArraySchema.prototype;
+    function create$1(schemas) {
+      return new TupleSchema(schemas);
+    }
+    var TupleSchema = class extends Schema {
+      constructor(schemas) {
+        super({
+          type: "tuple",
+          spec: {
+            types: schemas
+          },
+          check(v) {
+            const types = this.spec.types;
+            return Array.isArray(v) && v.length === types.length;
+          }
+        });
+        this.withMutation(() => {
+          this.typeError(tuple.notType);
+        });
+      }
+      _cast(inputValue, options) {
+        const {
+          types
+        } = this.spec;
+        const value = super._cast(inputValue, options);
+        if (!this._typeCheck(value)) {
+          return value;
+        }
+        let isChanged = false;
+        const castArray = types.map((type, idx) => {
+          const castElement = type.cast(value[idx], Object.assign({}, options, {
+            path: `${options.path || ""}[${idx}]`
+          }));
+          if (castElement !== value[idx]) isChanged = true;
+          return castElement;
+        });
+        return isChanged ? castArray : value;
+      }
+      _validate(_value, options = {}, panic, next) {
+        let itemTypes = this.spec.types;
+        super._validate(_value, options, panic, (tupleErrors, value) => {
+          var _options$originalValu2;
+          if (!this._typeCheck(value)) {
+            next(tupleErrors, value);
+            return;
+          }
+          let tests = [];
+          for (let [index, itemSchema] of itemTypes.entries()) {
+            var _options$originalValu;
+            tests[index] = itemSchema.asNestedTest({
+              options,
+              index,
+              parent: value,
+              parentPath: options.path,
+              originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value
+            });
+          }
+          this.runTests({
+            value,
+            tests,
+            originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,
+            options
+          }, panic, (innerTypeErrors) => next(innerTypeErrors.concat(tupleErrors), value));
+        });
+      }
+      describe(options) {
+        const next = (options ? this.resolve(options) : this).clone();
+        const base = super.describe(options);
+        base.innerType = next.spec.types.map((schema, index) => {
+          var _innerOptions;
+          let innerOptions = options;
+          if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+            innerOptions = Object.assign({}, innerOptions, {
+              parent: innerOptions.value,
+              value: innerOptions.value[index]
+            });
+          }
+          return schema.describe(innerOptions);
+        });
+        return base;
+      }
+    };
+    create$1.prototype = TupleSchema.prototype;
+    function create(builder) {
+      return new Lazy(builder);
+    }
+    function catchValidationError(fn) {
+      try {
+        return fn();
+      } catch (err) {
+        if (ValidationError2.isError(err)) return Promise.reject(err);
+        throw err;
+      }
+    }
+    var Lazy = class _Lazy {
+      constructor(builder) {
+        this.type = "lazy";
+        this.__isYupSchema__ = true;
+        this.spec = void 0;
+        this._resolve = (value, options = {}) => {
+          let schema = this.builder(value, options);
+          if (!isSchema(schema)) throw new TypeError("lazy() functions must return a valid schema");
+          if (this.spec.optional) schema = schema.optional();
+          return schema.resolve(options);
+        };
+        this.builder = builder;
+        this.spec = {
+          meta: void 0,
+          optional: false
+        };
+      }
+      clone(spec) {
+        const next = new _Lazy(this.builder);
+        next.spec = Object.assign({}, this.spec, spec);
+        return next;
+      }
+      optionality(optional) {
+        const next = this.clone({
+          optional
+        });
+        return next;
+      }
+      optional() {
+        return this.optionality(true);
+      }
+      resolve(options) {
+        return this._resolve(options.value, options);
+      }
+      cast(value, options) {
+        return this._resolve(value, options).cast(value, options);
+      }
+      asNestedTest(config2) {
+        let {
+          key,
+          index,
+          parent,
+          options
+        } = config2;
+        let value = parent[index != null ? index : key];
+        return this._resolve(value, Object.assign({}, options, {
+          value,
+          parent
+        })).asNestedTest(config2);
+      }
+      validate(value, options) {
+        return catchValidationError(() => this._resolve(value, options).validate(value, options));
+      }
+      validateSync(value, options) {
+        return this._resolve(value, options).validateSync(value, options);
+      }
+      validateAt(path9, value, options) {
+        return catchValidationError(() => this._resolve(value, options).validateAt(path9, value, options));
+      }
+      validateSyncAt(path9, value, options) {
+        return this._resolve(value, options).validateSyncAt(path9, value, options);
+      }
+      isValid(value, options) {
+        try {
+          return this._resolve(value, options).isValid(value, options);
+        } catch (err) {
+          if (ValidationError2.isError(err)) {
+            return Promise.resolve(false);
+          }
+          throw err;
+        }
+      }
+      isValidSync(value, options) {
+        return this._resolve(value, options).isValidSync(value, options);
+      }
+      describe(options) {
+        return options ? this.resolve(options).describe(options) : {
+          type: "lazy",
+          meta: this.spec.meta,
+          label: void 0
+        };
+      }
+      meta(...args2) {
+        if (args2.length === 0) return this.spec.meta;
+        let next = this.clone();
+        next.spec.meta = Object.assign(next.spec.meta || {}, args2[0]);
+        return next;
+      }
+      get ["~standard"]() {
+        const schema = this;
+        const standard = {
+          version: 1,
+          vendor: "yup",
+          async validate(value) {
+            try {
+              const result = await schema.validate(value, {
+                abortEarly: false
+              });
+              return {
+                value: result
+              };
+            } catch (err) {
+              if (ValidationError2.isError(err)) {
+                return {
+                  issues: issuesFromValidationError(err)
+                };
+              }
+              throw err;
+            }
+          }
+        };
+        return standard;
+      }
+    };
+    function setLocale(custom) {
+      Object.keys(custom).forEach((type) => {
+        Object.keys(custom[type]).forEach((method) => {
+          locale[type][method] = custom[type][method];
+        });
+      });
+    }
+    function addMethod(schemaType, name, fn) {
+      if (!schemaType || !isSchema(schemaType.prototype)) throw new TypeError("You must provide a yup schema constructor function");
+      if (typeof name !== "string") throw new TypeError("A Method name must be provided");
+      if (typeof fn !== "function") throw new TypeError("Method function must be provided");
+      schemaType.prototype[name] = fn;
+    }
+    exports2.ArraySchema = ArraySchema;
+    exports2.BooleanSchema = BooleanSchema;
+    exports2.DateSchema = DateSchema;
+    exports2.LazySchema = Lazy;
+    exports2.MixedSchema = MixedSchema;
+    exports2.NumberSchema = NumberSchema;
+    exports2.ObjectSchema = ObjectSchema;
+    exports2.Schema = Schema;
+    exports2.StringSchema = StringSchema;
+    exports2.TupleSchema = TupleSchema;
+    exports2.ValidationError = ValidationError2;
+    exports2.addMethod = addMethod;
+    exports2.array = create$2;
+    exports2.bool = create$7;
+    exports2.boolean = create$7;
+    exports2.date = create$4;
+    exports2.defaultLocale = locale;
+    exports2.getIn = getIn;
+    exports2.isSchema = isSchema;
+    exports2.lazy = create;
+    exports2.mixed = create$8;
+    exports2.number = create$5;
+    exports2.object = create$3;
+    exports2.printValue = printValue;
+    exports2.reach = reach;
+    exports2.ref = create$9;
+    exports2.setLocale = setLocale;
+    exports2.string = create$6;
+    exports2.tuple = create$1;
+  }
+});
 
 // src/index.ts
 var import_commander = require("commander");
@@ -399,7 +3993,830 @@ function BreakpointNotice({ plan }) {
 // src/components/BreakpointPrompt.tsx
 var import_ink4 = require("ink");
 var import_react2 = require("react");
-var import_shared2 = require("@todesktop/shared");
+
+// ../shared/package.json
+var package_default = {
+  name: "@todesktop/shared",
+  version: "7.194.0",
+  description: "",
+  main: "./lib/cjs/index.js",
+  module: "./lib/esm/index.js",
+  types: "./lib/esm/index.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./lib/esm/index.d.ts",
+        default: "./lib/esm/index.js"
+      },
+      require: {
+        types: "./lib/cjs/index.d.ts",
+        default: "./lib/cjs/index.js"
+      }
+    }
+  },
+  scripts: {
+    build: "rm -rf ./lib && pnpm run build:cjs && pnpm run build:esm && pnpm run build:rename-cjs-index",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:rename-cjs-index": "mv ./lib/cjs/index.cjs.js ./lib/cjs/index.js && mv ./lib/cjs/index.cjs.d.ts ./lib/cjs/index.d.ts",
+    bump: "npm version minor && git push && npm publish",
+    dev: "tsc",
+    format: "prettier . --write && eslint --fix",
+    lint: "prettier . --check && eslint",
+    prepublishOnly: "npm run build",
+    test: "vitest run",
+    typecheck: "tsc --noEmit"
+  },
+  author: "Dave Jeffery <dave@davejeffery.com>",
+  license: "UNLICENSED",
+  dependencies: {
+    "@todesktop/client-electron-types": "^28.0.0",
+    "@types/debug": "^4.1.1",
+    "@types/node": "^16.4.12",
+    "is-regex": "^1.0.4",
+    semver: "^7.3.5",
+    yup: "^1.4.0"
+  },
+  devDependencies: {
+    "@todesktop/dev-config": "workspace:*",
+    "@types/semver": "^7.3.9",
+    "app-builder-lib": "^25.1.8",
+    eslint: "catalog:",
+    prettier: "catalog:",
+    typescript: "catalog:",
+    vitest: "^1.6.1"
+  }
+};
+
+// ../shared/lib/esm/base.js
+var WindowsEVOnboardingSteps;
+(function(WindowsEVOnboardingSteps2) {
+  WindowsEVOnboardingSteps2["hasBeenVerified"] = "hasBeenVerified";
+  WindowsEVOnboardingSteps2["hasChosenProvider"] = "hasChosenProvider";
+  WindowsEVOnboardingSteps2["hasGeneratedCert"] = "hasGeneratedCert";
+  WindowsEVOnboardingSteps2["hasOrderedCert"] = "hasOrderedCert";
+  WindowsEVOnboardingSteps2["hasUploadedCert"] = "hasUploadedCert";
+})(WindowsEVOnboardingSteps || (WindowsEVOnboardingSteps = {}));
+var WindowsEVOnboardingProvider;
+(function(WindowsEVOnboardingProvider2) {
+  WindowsEVOnboardingProvider2["globalsign"] = "globalsign";
+  WindowsEVOnboardingProvider2["other"] = "other";
+})(WindowsEVOnboardingProvider || (WindowsEVOnboardingProvider = {}));
+var WindowsHSMCertType;
+(function(WindowsHSMCertType2) {
+  WindowsHSMCertType2["azureTrustedSigning"] = "azureTrustedSigning";
+  WindowsHSMCertType2["ev"] = "ev";
+  WindowsHSMCertType2["file"] = "file";
+})(WindowsHSMCertType || (WindowsHSMCertType = {}));
+
+// ../shared/lib/esm/desktopify.js
+var PlatformName;
+(function(PlatformName3) {
+  PlatformName3["linux"] = "linux";
+  PlatformName3["mac"] = "mac";
+  PlatformName3["windows"] = "windows";
+})(PlatformName || (PlatformName = {}));
+var PackageManager;
+(function(PackageManager2) {
+  PackageManager2["npm"] = "npm";
+  PackageManager2["pnpm"] = "pnpm";
+  PackageManager2["yarn"] = "yarn";
+})(PackageManager || (PackageManager = {}));
+var BuildStatus;
+(function(BuildStatus2) {
+  BuildStatus2["building"] = "building";
+  BuildStatus2["cancelled"] = "cancelled";
+  BuildStatus2["failed"] = "failed";
+  BuildStatus2["preparation"] = "preparation";
+  BuildStatus2["queued"] = "queued";
+  BuildStatus2["succeeded"] = "succeeded";
+})(BuildStatus || (BuildStatus = {}));
+var AnalysisStatus;
+(function(AnalysisStatus2) {
+  AnalysisStatus2["analyzing"] = "analyzing";
+  AnalysisStatus2["done"] = "done";
+  AnalysisStatus2["downloading"] = "downloading";
+  AnalysisStatus2["error"] = "error";
+  AnalysisStatus2["extracting"] = "extracting";
+  AnalysisStatus2["initializing"] = "initializing";
+  AnalysisStatus2["notStarted"] = "notStarted";
+})(AnalysisStatus || (AnalysisStatus = {}));
+var ManifestCategory;
+(function(ManifestCategory2) {
+  ManifestCategory2["buildStamped"] = "build-stamped";
+  ManifestCategory2["primary"] = "primary";
+  ManifestCategory2["versioned"] = "versioned";
+})(ManifestCategory || (ManifestCategory = {}));
+
+// ../shared/lib/esm/introspection/breakpoints.js
+var MINUTE = 60 * 1e3;
+var BREAKPOINT_DEFAULT_LEASE_MS = 20 * MINUTE;
+var BREAKPOINT_RENEW_INCREMENT_MS = 10 * MINUTE;
+var BREAKPOINT_MAX_REMAINING_MS = 20 * MINUTE;
+
+// ../shared/lib/esm/introspection/status.js
+function formatIntrospectionStatus(breakpointStatus, shellStatus) {
+  if (breakpointStatus === "paused") {
+    if (shellStatus === "connected") {
+      return "paused (shell connected)";
+    }
+    if (shellStatus === "disconnected") {
+      return "paused (shell disconnected)";
+    }
+    return "paused";
+  }
+  if (breakpointStatus === "ready") {
+    if (shellStatus === "connected") {
+      return "ready (shell connected)";
+    }
+    if (shellStatus === "disconnected") {
+      return "ready (shell disconnected)";
+    }
+    return "ready";
+  }
+  if (breakpointStatus === "resuming") {
+    return "resuming";
+  }
+  if (breakpointStatus === "initializing") {
+    return "initializing";
+  }
+  if (breakpointStatus === "finished") {
+    return "finished";
+  }
+  if (breakpointStatus === "error" || shellStatus === "error") {
+    return "error";
+  }
+  return "status unknown";
+}
+
+// ../shared/lib/esm/plans.js
+var PortalConfigKey;
+(function(PortalConfigKey2) {
+  PortalConfigKey2["BuilderUpdateDev"] = "builder_update_dev";
+  PortalConfigKey2["BuilderUpdateProd"] = "builder_update_prod";
+  PortalConfigKey2["BuilderUpgradeDev"] = "builder_upgrade_dev";
+  PortalConfigKey2["BuilderUpgradeProd"] = "builder_upgrade_prod";
+  PortalConfigKey2["CLIUpdateDev"] = "cli_update_dev";
+  PortalConfigKey2["CLIUpdateProd"] = "cli_update_prod";
+  PortalConfigKey2["CLIUpgradeDev"] = "cli_upgrade_dev";
+  PortalConfigKey2["CLIUpgradeProd"] = "cli_upgrade_prod";
+})(PortalConfigKey || (PortalConfigKey = {}));
+var createPrice = (id, price) => {
+  return Object.assign({ id }, price);
+};
+var createProduct = (id, prices) => ({ id, prices });
+var createPlan = (tier, products2) => {
+  const record = {
+    basic: { label: "Basic", tiers: ["basic", "legacy_pro", "pro", "scale"] },
+    legacy_pro: { label: "Pro", tiers: ["legacy_pro", "pro", "scale"] },
+    pro: { label: "Pro", tiers: ["pro", "scale"] },
+    scale: { label: "Scale", tiers: ["scale"] }
+  };
+  const { label, tiers } = record[tier];
+  return {
+    eligiblePlanTiers: tiers,
+    label,
+    products: { dev: products2.dev, prod: products2.prod },
+    tier
+  };
+};
+var PORTAL_VERSION = 1;
+var createPortalConfig = (key, products2) => {
+  return {
+    business_profile: {
+      headline: "ToDesktop Billing Portal",
+      privacy_policy_url: "https://www.todesktop.com/privacy-policy",
+      terms_of_service_url: "https://www.todesktop.com/terms"
+    },
+    default_return_url: "https://app.todesktop.com",
+    features: {
+      payment_method_update: { enabled: true },
+      subscription_update: {
+        default_allowed_updates: ["price"],
+        enabled: true,
+        products: products2.map((product) => {
+          return {
+            prices: Object.values(product.prices).filter((price) => price.status === "active").map((price) => price.id),
+            product: product.id
+          };
+        })
+      }
+    },
+    metadata: { key, version: PORTAL_VERSION }
+  };
+};
+var products = {
+  dev: {
+    builder: {
+      essential: createProduct("prod_MoR1S4o0nLv00y", {
+        monthly_125: createPrice("price_1PuuAqIewCKA2h0Iw4judQNj", {
+          amount: 125,
+          period: "monthly",
+          status: "active"
+        }),
+        monthly_99: createPrice("price_1M4o9XIewCKA2h0IVfGrid8E", {
+          amount: 99,
+          period: "monthly",
+          status: "inactive"
+        }),
+        yearly_1200: createPrice("price_1PuvdgIewCKA2h0IisTKqjFN", {
+          amount: 1200,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      professional: createProduct("prod_MoR1SchsRDAIgY", {
+        monthly_199: createPrice("price_1M4o9vIewCKA2h0IHREokdD8", {
+          amount: 199,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_240: createPrice("price_1M4o9vIewCKA2h0IHREokdD8", {
+          amount: 240,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_300: createPrice("price_1PuuHrIewCKA2h0IQfEZ4Wog", {
+          amount: 300,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_2880: createPrice("price_1PuuJAIewCKA2h0IibpUIhf9", {
+          amount: 2880,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    },
+    cli: {
+      founder: createProduct("prod_Gq0E8nbTYHtkPl", {
+        monthly_100: createPrice("plan_Gq0FzdmoTJshQL", {
+          amount: 100,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_125: createPrice("price_1PuuMRIewCKA2h0IrggfwCwA", {
+          amount: 125,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_1200: createPrice("price_1PuuMkIewCKA2h0IRxhkDpmk", {
+          amount: 1200,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      founder30: createProduct("prod_GsL6LaRo4NFD5n", {
+        monthly_30: createPrice("plan_GsL7NZskOY0TC9", {
+          amount: 30,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      founder50: createProduct("prod_GsL5O1PdbxOrxJ", {
+        monthly_50: createPrice("plan_GsL6VYAshfh7c4", {
+          amount: 50,
+          period: "monthly",
+          status: "active"
+        }),
+        monthly_90: createPrice("plan_GsL6VYAshfh7c4", {
+          amount: 90,
+          period: "monthly",
+          status: "inactive"
+        })
+      }),
+      performance: createProduct("prod_LphQku6BNkzCga", {
+        monthly_300: createPrice("price_1L821UIewCKA2h0IUwRhicyo", {
+          amount: 300,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_375: createPrice("price_1PuuO7IewCKA2h0IOK9ivzS0", {
+          amount: 375,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_3600: createPrice("price_1PuuOKIewCKA2h0IrcVvJkgG", {
+          amount: 3600,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      scale: createProduct("prod_LphQxNgfUIxVfA", {
+        monthly_1200: createPrice("price_1L821wIewCKA2h0IMLUmjulL", {
+          amount: 1200,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_1500: createPrice("price_1PuuPFIewCKA2h0IbPmKdsJr", {
+          amount: 1500,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_14400: createPrice("price_1PuuPaIewCKA2h0IhLfSlRFj", {
+          amount: 14400,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    },
+    legacy: {
+      business: createProduct("prod_Fe8CbCE2wGJIWr", {
+        monthly_199: createPrice("plan_Fe8CUkZfXasFtB", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      enterprise: createProduct("prod_Hc9PMnHUmHvOlw", {
+        monthly_700: createPrice("price_1H2v6JIewCKA2h0IgUwsuctb", {
+          amount: 700,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      essential: createProduct("prod_FplN7CkqFRH0ye", {
+        monthly_58: createPrice("plan_FpljxNuZtNFFbm", {
+          amount: 58,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      essentialNew: createProduct("prod_GYXm5X66hM1Ywj", {
+        monthly_58: createPrice("plan_GYXmTA3EdfCv4q", {
+          amount: 58,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_580: createPrice("plan_GYXmTA3EdfCv4q", {
+          amount: 580,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      growth: createProduct("prod_FplOSDbBmxba94", {
+        monthly_199: createPrice("plan_FplOshrr1w3Mvu", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      professional: createProduct("prod_GYXo54YK5kga12", {
+        monthly_199: createPrice("plan_GYXoIkvwVKyfF2", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_1990: createPrice("price_1KHU70IewCKA2h0IR87yXOQ2", {
+          amount: 1990,
+          period: "yearly",
+          status: "inactive"
+        }),
+        yearly_2388: createPrice("price_1KHU70IewCKA2h0IR87yXOQ2", {
+          amount: 2388,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      startup: createProduct("prod_Fe8BTslXbdylxV", {
+        monthly_49: createPrice("plan_Fe8BzLp7k71eGD", {
+          amount: 49,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_200: createPrice("plan_Fe8BzLp7k71eGD", {
+          amount: 200,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    }
+  },
+  prod: {
+    builder: {
+      essential: createProduct("prod_MoR2Ldm5PJpJZJ", {
+        monthly_125: createPrice("price_1PuuU1IewCKA2h0IUSAcuUUb", {
+          amount: 125,
+          period: "monthly",
+          status: "active"
+        }),
+        monthly_99: createPrice("price_1M4oA4IewCKA2h0IWgfbSJBe", {
+          amount: 99,
+          period: "monthly",
+          status: "inactive"
+        }),
+        yearly_1200: createPrice("price_1PuuUZIewCKA2h0IDMNwNqQl", {
+          amount: 1200,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      professional: createProduct("prod_MoR2h0Nf16hhgb", {
+        monthly_199: createPrice("price_1M4oABIewCKA2h0INkbaCbIS", {
+          amount: 199,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_240: createPrice("price_1MIDxtIewCKA2h0IvWi5weJL", {
+          amount: 240,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_300: createPrice("price_1PuuVSIewCKA2h0IETsLUwF9", {
+          amount: 300,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_2880: createPrice("price_1PuuVmIewCKA2h0I37dMpqI5", {
+          amount: 2880,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    },
+    cli: {
+      founder: createProduct("prod_GpzVRVsBgluoef", {
+        monthly_100: createPrice("plan_GpzWZLfsOzjrvI", {
+          amount: 100,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_125: createPrice("price_1PuuXFIewCKA2h0IVHSyfFsd", {
+          amount: 125,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_1200: createPrice("price_1PuuXYIewCKA2h0IAsygBajd", {
+          amount: 1200,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      founder30: createProduct("prod_GrHtZKuUDvLZOF", {
+        monthly_30: createPrice("plan_GrHuyGjzYN0XN2", {
+          amount: 30,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      founder50: createProduct("prod_GsL0ntimYpTTwD", {
+        monthly_50: createPrice("plan_GsL1IRUwpj5CIF", {
+          amount: 50,
+          period: "monthly",
+          status: "active"
+        }),
+        monthly_90: createPrice("price_1JMHNnIewCKA2h0II5RGjVtk", {
+          amount: 90,
+          period: "monthly",
+          status: "inactive"
+        })
+      }),
+      performance: createProduct("prod_LphRn5Rfuq3CMh", {
+        monthly_300: createPrice("price_1L822LIewCKA2h0I5JYyOG1p", {
+          amount: 300,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_375: createPrice("price_1PuuYKIewCKA2h0IWBJ4cyRQ", {
+          amount: 375,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_3600: createPrice("price_1PuuYcIewCKA2h0IzeU1xWbQ", {
+          amount: 3600,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      scale: createProduct("prod_LphRKSuMLjQriP", {
+        monthly_1200: createPrice("price_1L822RIewCKA2h0IPt9f2nZM", {
+          amount: 1200,
+          period: "monthly",
+          status: "inactive"
+        }),
+        monthly_1500: createPrice("price_1PuuarIewCKA2h0IEONPcFU5", {
+          amount: 1500,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_14400: createPrice("price_1Puub5IewCKA2h0IMJ3CQ58r", {
+          amount: 14400,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    },
+    legacy: {
+      business: createProduct("prod_FdmEvAgT7ZtVEw", {
+        monthly_199: createPrice("plan_FdmE8akq9ukxiY", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      enterprise: createProduct("prod_GuGGWeMQ3SCuE9", {
+        monthly_700: createPrice("plan_GuGICX6nRtDthN", {
+          amount: 700,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      essential: createProduct("prod_FohIP5aSMWWGyY", {
+        monthly_58: createPrice("plan_FohJzCujA6vvt4", {
+          amount: 58,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      essentialNew: createProduct("prod_GYXn73zcoJKsF8", {
+        monthly_58: createPrice("plan_GYXn2cnPl5dy7j", {
+          amount: 58,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_580: createPrice("price_1Gqb24IewCKA2h0ILP5rxTnT", {
+          amount: 580,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      growth: createProduct("prod_FohKfjLOlJNm1W", {
+        monthly_199: createPrice("plan_FohKGuWis5ocsi", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        })
+      }),
+      professional: createProduct("prod_GYXouE5K7vuitU", {
+        monthly_199: createPrice("plan_GYXoKsa2j0yURg", {
+          amount: 199,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_1990: createPrice("price_1KHTgaIewCKA2h0I81TVg85r", {
+          amount: 1990,
+          period: "yearly",
+          status: "inactive"
+        }),
+        yearly_2388: createPrice("price_1KLT32IewCKA2h0IFeJOAgG5", {
+          amount: 2388,
+          period: "yearly",
+          status: "active"
+        })
+      }),
+      startup: createProduct("prod_FdmCGcrX2IETUH", {
+        monthly_49: createPrice("plan_FdmDAUN7JGD8pR", {
+          amount: 49,
+          period: "monthly",
+          status: "active"
+        }),
+        yearly_200: createPrice("plan_Ft8qvk401twwrW", {
+          amount: 200,
+          period: "yearly",
+          status: "active"
+        })
+      })
+    }
+  }
+};
+var { dev, prod } = products;
+var basicPlan = createPlan("basic", {
+  dev: [
+    dev.builder.essential,
+    dev.cli.founder30,
+    dev.cli.founder50,
+    dev.cli.founder,
+    dev.legacy.essential,
+    dev.legacy.essentialNew,
+    dev.legacy.startup
+  ],
+  prod: [
+    prod.builder.essential,
+    prod.cli.founder30,
+    prod.cli.founder50,
+    prod.cli.founder,
+    prod.legacy.essential,
+    prod.legacy.essentialNew,
+    prod.legacy.startup
+  ]
+});
+var legacyProPlan = createPlan("legacy_pro", {
+  dev: [
+    dev.builder.professional,
+    dev.cli.founder,
+    dev.cli.founder30,
+    dev.cli.founder50,
+    dev.cli.performance,
+    dev.cli.scale,
+    dev.legacy.professional,
+    dev.legacy.growth,
+    dev.legacy.business
+  ],
+  prod: [
+    prod.builder.professional,
+    prod.cli.founder,
+    prod.cli.founder30,
+    prod.cli.founder50,
+    prod.cli.performance,
+    prod.cli.scale,
+    prod.legacy.professional,
+    prod.legacy.growth,
+    prod.legacy.business
+  ]
+});
+var proPlan = createPlan("pro", {
+  dev: [
+    dev.builder.professional,
+    dev.cli.performance,
+    dev.legacy.professional,
+    dev.legacy.growth,
+    dev.legacy.business
+  ],
+  prod: [
+    prod.builder.professional,
+    prod.cli.performance,
+    prod.legacy.professional,
+    prod.legacy.growth,
+    prod.legacy.business
+  ]
+});
+var scalePlan = createPlan("scale", {
+  dev: [dev.cli.scale, dev.legacy.enterprise],
+  prod: [prod.cli.scale, prod.legacy.enterprise]
+});
+var configurations = {
+  dev: {
+    builder: {
+      update: createPortalConfig(PortalConfigKey.BuilderUpdateDev, [
+        dev.builder.essential,
+        dev.builder.professional
+      ]),
+      upgrade: createPortalConfig(PortalConfigKey.BuilderUpgradeDev, [
+        dev.builder.professional
+      ])
+    },
+    cli: {
+      update: createPortalConfig(PortalConfigKey.CLIUpdateDev, [
+        dev.cli.founder,
+        dev.cli.performance,
+        dev.cli.scale
+      ]),
+      upgrade: createPortalConfig(PortalConfigKey.CLIUpgradeDev, [
+        dev.cli.performance,
+        dev.cli.scale
+      ])
+    }
+  },
+  prod: {
+    builder: {
+      update: createPortalConfig(PortalConfigKey.BuilderUpdateProd, [
+        prod.builder.essential,
+        prod.builder.professional
+      ]),
+      upgrade: createPortalConfig(PortalConfigKey.BuilderUpgradeProd, [
+        prod.builder.professional
+      ])
+    },
+    cli: {
+      update: createPortalConfig(PortalConfigKey.CLIUpdateProd, [
+        prod.cli.founder,
+        prod.cli.performance,
+        prod.cli.scale
+      ]),
+      upgrade: createPortalConfig(PortalConfigKey.CLIUpgradeProd, [
+        prod.cli.performance,
+        prod.cli.scale
+      ])
+    }
+  }
+};
+var LegacyProductRecord = {
+  builder_essential: {
+    dev: dev.builder.essential,
+    prod: prod.builder.essential
+  },
+  builder_professional: {
+    dev: dev.builder.professional,
+    prod: prod.builder.professional
+  },
+  business: { dev: dev.legacy.business, prod: prod.legacy.business },
+  cli_founder: { dev: dev.cli.founder, prod: prod.cli.founder },
+  cli_founder_30: { dev: dev.cli.founder30, prod: prod.cli.founder30 },
+  cli_founder_50: { dev: dev.cli.founder50, prod: prod.cli.founder50 },
+  cli_performance: { dev: dev.cli.performance, prod: prod.cli.performance },
+  cli_scale: { dev: dev.cli.scale, prod: prod.cli.scale },
+  enterprise: { dev: dev.legacy.enterprise, prod: prod.legacy.enterprise },
+  essential: { dev: dev.legacy.essential, prod: prod.legacy.essential },
+  essential_new: {
+    dev: dev.legacy.essentialNew,
+    prod: prod.legacy.essentialNew
+  },
+  growth: { dev: dev.legacy.growth, prod: prod.legacy.growth },
+  professional: {
+    dev: dev.legacy.professional,
+    prod: prod.legacy.professional
+  },
+  professional_annual: {
+    dev: dev.legacy.professional,
+    prod: prod.legacy.professional
+  },
+  professional_annual_full_price: {
+    dev: dev.legacy.professional,
+    prod: prod.legacy.professional
+  },
+  startup: { dev: dev.legacy.startup, prod: prod.legacy.startup }
+};
+
+// ../shared/lib/esm/validations.js
+var import_is_regex = __toESM(require_is_regex());
+var import_semver = __toESM(require("semver"));
+var yup = __toESM(require_yup());
+var appTitleValidation = yup.string().label("App title").max(26).matches(/^[\w\-\s]+$/, "App title may contain letters, numbers, spaces and dashes only").matches(/^[^\s]+(\s+[^\s]+)*$/, "App title may not begin or end with space").required();
+function isNumeric(str) {
+  if (typeof str !== "string")
+    return false;
+  return !Number.isNaN(Number(str)) && !Number.isNaN(parseFloat(str));
+}
+function isNumericSemver(value) {
+  if (!import_semver.default.valid(value))
+    return false;
+  if (!value.split(".").every((num) => isNumeric(num)))
+    return false;
+  return true;
+}
+var forceVersionValidation = yup.string().label("App version").required().when("$currentVersion", ([currentVersion], schema) => schema.test("semantic-version", "App version must follow a numeric SemVer versioning scheme (e.g. 1.0.0) and be greater than prior version.", (forceVersion) => {
+  return isNumericSemver(forceVersion) && import_semver.default.gt(forceVersion, currentVersion);
+}));
+var iconValidation = yup.string().label("Icon").url().required("You must upload an icon for your app");
+var urlValidation = yup.string().matches(/^(?:([a-z0-9+.-]+):\/\/)(?:\S+(?::\S*)?@)?(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*\.?)(?::\d{2,5})?(?:[/?#]\S*)?$/, {
+  excludeEmptyString: true,
+  message: "Invalid URL. Don't forget to include the protocol (e.g.. https://)."
+}).label("Website URL").required();
+var urlValidationForm = yup.object().shape({
+  url: urlValidation
+});
+var heightValidation = yup.number().label("Height").moreThan(1).lessThan(2e3).required();
+var widthValidation = yup.number().label("Width").moreThan(1).lessThan(3e3).required();
+var internalAppRegexValidation = yup.string().required().label("Internal URLs").test("escape-forward-slash", "a forward-slash ('/') must be escaped with a back-slash ('\\')", (value) => {
+  if (value.includes("/")) {
+    const forwardSlashCount = value.split("").map((char) => char === "/").filter((isTrue) => isTrue).length;
+    const backSlashEscapeCount = ((value || "").match(/(?=\\\/)/g) || []).length;
+    return forwardSlashCount === backSlashEscapeCount;
+  }
+  return true;
+}).test(
+  "is-regex",
+  // eslint-disable-next-line no-template-curly-in-string
+  "${path} must be valid regular expression",
+  (value) => (0, import_is_regex.default)(RegExp(value))
+);
+var appProtocolValidation = yup.string().required().label("App Protocol").test("ends-with-protocol", "Protocols must end with `://`", (value) => value.endsWith("://")).test("is-lowercase", "Protocols must be lowercase", (value) => value === value.toLowerCase()).matches(/^[a-zA-Z-.]+:\/\/$/, "Protocols contain letters, dots (.) and dashes (-) only").min(5);
+var appConfigValidation = yup.object({
+  customUserAgent: yup.string().required(),
+  disableDevTools: yup.boolean().required(),
+  iconUrl: iconValidation,
+  id: yup.string().required(),
+  internalURLs: yup.string().required(),
+  isFrameBlocked: yup.boolean().required(),
+  meta: yup.object({
+    appIterations: yup.number().required(),
+    hasAppChanged: yup.boolean().required(),
+    publishedVersions: yup.object({
+      desktopify: yup.string().notRequired(),
+      electron: yup.string().notRequired(),
+      version: yup.string().notRequired()
+    }),
+    schemaVersion: yup.number().required()
+  }).required(),
+  name: appTitleValidation,
+  secret: yup.string().required(),
+  singleInstance: yup.boolean().required(),
+  url: urlValidation,
+  windowOptions: yup.object({
+    hasMaxHeight: yup.boolean().required(),
+    hasMaxWidth: yup.boolean().required(),
+    hasMinHeight: yup.boolean().required(),
+    hasMinWidth: yup.boolean().required(),
+    height: yup.number().required(),
+    isFullscreenable: yup.boolean().required(),
+    isMaximizable: yup.boolean().required(),
+    isMinimizable: yup.boolean().required(),
+    isResizable: yup.boolean().required(),
+    maxHeight: yup.number().required(),
+    maxWidth: yup.number().required(),
+    minHeight: yup.number().required(),
+    minWidth: yup.number().required(),
+    startInFullscreenMode: yup.boolean().required(),
+    width: yup.number().required(),
+    alwaysOnTop: yup.boolean().required(),
+    autoHideMenuBar: yup.boolean().required(),
+    transparentInsetTitlebar: yup.boolean().required(),
+    transparentTitlebar: yup.boolean().required()
+  }).required()
+});
+
+// ../shared/lib/esm/index.js
+var schemaVersion = package_default.version;
 
 // src/utilities/useInput.ts
 var import_is_ci = __toESM(require("is-ci"));
@@ -879,7 +5296,6 @@ if (firebaseFunctionsBase.includes("localhost")) {
 var getCallableFirebaseFunction_default = (functionName) => (0, import_functions.httpsCallable)(functions, functionName);
 
 // src/utilities/introspectionStatus.ts
-var import_shared = require("@todesktop/shared");
 function getIntrospectionStatusIndicator(breakpointStatus, shellStatus) {
   if (shellStatus === "connected") {
     return "\u25C6";
@@ -1019,14 +5435,14 @@ function BreakpointPrompt({
   const { shellStatus } = data;
   const expiresAtMs = ((_a2 = toDateSafe(breakpoint.expiresAt)) == null ? void 0 : _a2.getTime()) ?? NaN;
   const remainingMs = expiresAtMs - now;
-  const canRenew = remainingMs < import_shared2.BREAKPOINT_MAX_REMAINING_MS;
+  const canRenew = remainingMs < BREAKPOINT_MAX_REMAINING_MS;
   const formattedBreakpoint = formatBreakpoint(toBreakpointConfig(breakpoint));
   const renewalsDescription = describeRenewals(breakpoint.renewals);
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink4.Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink4.Text, { color: "yellow", children: [
       platform,
       " ",
-      (0, import_shared.formatIntrospectionStatus)(breakpointStatus, shellStatus),
+      formatIntrospectionStatus(breakpointStatus, shellStatus),
       " at",
       " ",
       formattedBreakpoint,
@@ -1775,7 +6191,8 @@ function loadTypeScriptConfig(configPath) {
       logger_default.debug(`Found TypeScript in user's project at: ${tsPath}`);
     } catch {
       try {
-        typescript = require("typescript");
+        const moduleName = "typescript";
+        typescript = require(moduleName);
         logger_default.debug("Using globally available TypeScript installation");
       } catch {
         throw new Error(
@@ -1951,7 +6368,7 @@ var import_email_regex = __toESM(require("email-regex"));
 var fs3 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 var import_parse_author = __toESM(require("parse-author"));
-var semver = __toESM(require("semver"));
+var semver2 = __toESM(require("semver"));
 
 // src/utilities/projectConfig/validatePackageJSON.ts
 var import_ajv = __toESM(require("ajv"));
@@ -2310,7 +6727,7 @@ var addCustomKeywords_default = (ajv, context) => {
     type: "string",
     validate: (schema, data) => {
       const keyword = (schema.packageName ? `${schema.packageName} ` : "") + "version";
-      if (!(semver.valid(data) || semver.validRange(data))) {
+      if (!(semver2.valid(data) || semver2.validRange(data))) {
         throw new import_ajv2.ValidationError([
           {
             keyword,
@@ -5796,13 +10213,13 @@ var import_util = __toESM(require("util"));
 var import_jsx_runtime30 = require("react/jsx-runtime");
 var supportsColor = import_chalk2.default.stderr.supportsColor;
 var SyntaxHighlight = ({
-  object,
+  object: object2,
   colors = supportsColor == null ? void 0 : supportsColor.hasBasic
 }) => {
   const { stdout } = (0, import_ink28.useStdout)();
   const highlightedCode = React3.useMemo(() => {
-    return stdout.isTTY ? import_util.default.inspect(object, { colors, depth: 6 }) : JSON.stringify(object, null, 2);
-  }, [colors, object, stdout.isTTY]);
+    return stdout.isTTY ? import_util.default.inspect(object2, { colors, depth: 6 }) : JSON.stringify(object2, null, 2);
+  }, [colors, object2, stdout.isTTY]);
   return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_ink28.Text, { wrap: "end", children: highlightedCode });
 };
 var SyntaxHighlight_default = SyntaxHighlight;
@@ -6866,7 +11283,6 @@ function useBuildTableState({
 
 // src/commands/introspect/utilities/buildQueries.ts
 var import_firestore23 = require("firebase/firestore");
-var import_shared3 = require("@todesktop/shared");
 async function getRunningBuildsWithIntrospection(configPath) {
   const { id: appId } = getProjectConfig(configPath).config;
   const { id: userId } = await findAppUserId_default(appId);
@@ -6877,7 +11293,7 @@ async function getRunningBuildsWithIntrospection(configPath) {
   );
   const q = (0, import_firestore23.query)(
     buildsCollection,
-    (0, import_firestore23.where)("status", "in", [import_shared3.BuildStatus.building, import_shared3.BuildStatus.preparation]),
+    (0, import_firestore23.where)("status", "in", [BuildStatus.building, BuildStatus.preparation]),
     (0, import_firestore23.orderBy)("createdAt", "desc"),
     (0, import_firestore23.limit)(10)
   );
@@ -7086,7 +11502,7 @@ function PlatformSelector({
       return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ErrorDisplay, { commandUsed: "todesktop introspect", error: state.error });
     case "show-platforms": {
       const items = state.platforms.map((platform) => {
-        const statusLabel = (0, import_shared.formatIntrospectionStatus)(
+        const statusLabel = formatIntrospectionStatus(
           platform.breakpointStatus,
           platform.shellStatus
         );
@@ -7591,7 +12007,7 @@ var import_ink41 = require("ink");
 var import_react29 = require("react");
 
 // src/commands/smoke-test/utilities/build.ts
-var import_semver = __toESM(require("semver"));
+var import_semver2 = __toESM(require("semver"));
 var MIN_RUNTIME_VERSION = "1.2.3-0";
 function isBuildTestable(build) {
   try {
@@ -7680,16 +12096,16 @@ function validateBuild(build) {
   }
 }
 function isRuntimeVerRangeAllowed(runtimeVerRange) {
-  const minRuntimeVersionForApp = import_semver.default.minVersion(runtimeVerRange, {
+  const minRuntimeVersionForApp = import_semver2.default.minVersion(runtimeVerRange, {
     loose: true
   });
-  return import_semver.default.gte(minRuntimeVersionForApp, MIN_RUNTIME_VERSION, {
+  return import_semver2.default.gte(minRuntimeVersionForApp, MIN_RUNTIME_VERSION, {
     loose: true
   });
 }
 
 // src/commands/release/utilities/analyzeRelease.ts
-var import_semver2 = __toESM(require("semver"));
+var import_semver3 = __toESM(require("semver"));
 var MIN_RUNTIME_VERSION_FOR_DOWNGRADE = "1.4.1-1";
 function analyzeRelease({
   build,
@@ -7697,7 +12113,7 @@ function analyzeRelease({
 }) {
   const result = {
     downgradeAllowed: Boolean(
-      (latestReleasedBuild == null ? void 0 : latestReleasedBuild.todesktopRuntimeVersionUsed) && import_semver2.default.gte(
+      (latestReleasedBuild == null ? void 0 : latestReleasedBuild.todesktopRuntimeVersionUsed) && import_semver3.default.gte(
         latestReleasedBuild.todesktopRuntimeVersionUsed,
         MIN_RUNTIME_VERSION_FOR_DOWNGRADE
       )
@@ -7706,7 +12122,7 @@ function analyzeRelease({
     isAlreadyReleased: Boolean(build.releasedAt),
     isAlreadyTheLatest: build.id === (latestReleasedBuild == null ? void 0 : latestReleasedBuild.id),
     isOlderThanLatest: Boolean(
-      latestReleasedBuild && latestReleasedBuild.appVersion && build.appVersion && import_semver2.default.gt(latestReleasedBuild.appVersion, build.appVersion)
+      latestReleasedBuild && latestReleasedBuild.appVersion && build.appVersion && import_semver3.default.gt(latestReleasedBuild.appVersion, build.appVersion)
     ),
     isReleasable: false,
     isSucceeded: build.status === "succeeded",
@@ -8499,14 +12915,14 @@ var WhoamiCommand_default = WhoAmIWrapper;
 var import_chalk3 = __toESM(require("chalk"));
 var import_is_installed_globally = __toESM(require("is-installed-globally"));
 var import_latest_version = __toESM(require("latest-version"));
-var import_semver3 = __toESM(require("semver"));
+var import_semver4 = __toESM(require("semver"));
 var exitIfCLIOutOfDate_default = () => {
   if (process.env.AVA_PATH) {
     return;
   }
   const pkg = getToDesktopPackageJson();
   (0, import_latest_version.default)(pkg.name).then((latest) => {
-    if (import_semver3.default.gt(latest, pkg.version)) {
+    if (import_semver4.default.gt(latest, pkg.version)) {
       const commandToUpdate = import_chalk3.default.greenBright(
         `npm install ${import_is_installed_globally.default ? "-g" : "--save-dev"} @todesktop/cli`
       );
@@ -8514,7 +12930,7 @@ var exitIfCLIOutOfDate_default = () => {
         `Your version of @todesktop/cli is out of date.
 Run ${commandToUpdate} to update to v${latest}.`
       );
-      if (!import_semver3.default.satisfies(latest, `^${pkg.version}`)) {
+      if (!import_semver4.default.satisfies(latest, `^${pkg.version}`)) {
         console.error(`CLI is exiting because it is out out of date.`);
         process.exit(1);
       }
@@ -8527,13 +12943,13 @@ var Sentry3 = __toESM(require("@sentry/node"));
 var import_os2 = __toESM(require("os"));
 
 // package.json
-var package_default = {
+var package_default2 = {
   private: false,
   publishConfig: {
     access: "public"
   },
   name: "@todesktop/cli",
-  version: "1.19.0",
+  version: "1.19.0-1",
   license: "MIT",
   author: "Dave Jeffery <dave@todesktop.com> (http://www.todesktop.com/)",
   homepage: "https://todesktop.com/cli",
@@ -8618,7 +13034,7 @@ var package_default = {
   },
   devDependencies: {
     "@todesktop/dev-config": "workspace:*",
-    "@todesktop/shared": "^7.193.0",
+    "@todesktop/shared": "workspace:*",
     "@types/bunyan": "^1.8.11",
     "@types/ink-testing-library": "^1.0.4",
     "@types/is-ci": "^3.0.4",
@@ -8703,8 +13119,8 @@ var initSentry_default = () => {
   }
   try {
     scope.setContext("app", {
-      app_name: package_default.name,
-      app_version: package_default.version
+      app_name: package_default2.name,
+      app_version: package_default2.version
     });
   } catch {
   }
@@ -8726,7 +13142,6 @@ var onCommand_default = ({ sentry = true, exitIfOutOfDate = true } = {}) => {
 };
 
 // src/commands/build/utilities/continueBreakpoint.ts
-var import_shared4 = require("@todesktop/shared");
 async function continueBreakpoint({
   buildId,
   platform,
@@ -8758,7 +13173,7 @@ async function continueBreakpoint({
   );
 }
 function isValidPlatform(value) {
-  return typeof value === "string" && Object.values(import_shared4.PlatformName).includes(value);
+  return typeof value === "string" && Object.values(PlatformName).includes(value);
 }
 
 // src/index.ts