@phillips/seldon 1.144.0 → 1.145.0

package/dist/node_modules/yup/index.esm.js

@@ -0,0 +1,1899 @@
+import { p as S } from "../property-expr/index.js";
+import { t as Y } from "../tiny-case/index.js";
+import _e from "../toposort/index.js";
+const $e = Object.prototype.toString, Oe = Error.prototype.toString, ke = RegExp.prototype.toString, Ee = typeof Symbol < "u" ? Symbol.prototype.toString : () => "", Se = /^Symbol\((.*)\)(.*)$/;
+function Ae(n) {
+  return n != +n ? "NaN" : n === 0 && 1 / n < 0 ? "-0" : "" + n;
+}
+function te(n, e = !1) {
+  if (n == null || n === !0 || n === !1) return "" + n;
+  const t = typeof n;
+  if (t === "number") return Ae(n);
+  if (t === "string") return e ? `"${n}"` : n;
+  if (t === "function") return "[Function " + (n.name || "anonymous") + "]";
+  if (t === "symbol") return Ee.call(n).replace(Se, "Symbol($1)");
+  const r = $e.call(n).slice(8, -1);
+  return r === "Date" ? isNaN(n.getTime()) ? "" + n : n.toISOString(n) : r === "Error" || n instanceof Error ? "[" + Oe.call(n) + "]" : r === "RegExp" ? ke.call(n) : null;
+}
+function T(n, e) {
+  let t = te(n, e);
+  return t !== null ? t : JSON.stringify(n, function(r, s) {
+    let i = te(this[r], e);
+    return i !== null ? i : s;
+  }, 2);
+}
+function ue(n) {
+  return n == null ? [] : [].concat(n);
+}
+let le, oe, ce, De = /\$\{\s*(\w+)\s*\}/g;
+le = Symbol.toStringTag;
+class re {
+  constructor(e, t, r, s) {
+    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[le] = "Error", this.name = "ValidationError", this.value = t, this.path = r, this.type = s, this.errors = [], this.inner = [], ue(e).forEach((i) => {
+      if (m.isError(i)) {
+        this.errors.push(...i.errors);
+        const a = i.inner.length ? i.inner : [i];
+        this.inner.push(...a);
+      } else
+        this.errors.push(i);
+    }), this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+  }
+}
+oe = Symbol.hasInstance;
+ce = Symbol.toStringTag;
+class m extends Error {
+  static formatError(e, t) {
+    const r = t.label || t.path || "this";
+    return t = Object.assign({}, t, {
+      path: r,
+      originalPath: t.path
+    }), typeof e == "string" ? e.replace(De, (s, i) => T(t[i])) : typeof e == "function" ? e(t) : e;
+  }
+  static isError(e) {
+    return e && e.name === "ValidationError";
+  }
+  constructor(e, t, r, s, i) {
+    const a = new re(e, t, r, s);
+    if (i)
+      return a;
+    super(), this.value = void 0, this.path = void 0, this.type = void 0, this.params = void 0, this.errors = [], this.inner = [], this[ce] = "Error", this.name = a.name, this.message = a.message, this.type = a.type, this.value = a.value, this.path = a.path, this.errors = a.errors, this.inner = a.inner, Error.captureStackTrace && Error.captureStackTrace(this, m);
+  }
+  static [oe](e) {
+    return re[Symbol.hasInstance](e) || super[Symbol.hasInstance](e);
+  }
+}
+let x = {
+  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: n,
+    type: e,
+    value: t,
+    originalValue: r
+  }) => {
+    const s = r != null && r !== t ? ` (cast from the value \`${T(r, !0)}\`).` : ".";
+    return e !== "mixed" ? `${n} must be a \`${e}\` type, but the final value was: \`${T(t, !0)}\`` + s : `${n} must match the configured type. The validated value was: \`${T(t, !0)}\`` + s;
+  }
+}, b = {
+  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"
+}, $ = {
+  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"
+}, K = {
+  min: "${path} field must be later than ${min}",
+  max: "${path} field must be at earlier than ${max}"
+}, B = {
+  isValue: "${path} field must be ${value}"
+}, I = {
+  noUnknown: "${path} field has unspecified keys: ${unknown}",
+  exact: "${path} object contains unknown properties: ${properties}"
+}, z = {
+  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"
+}, he = {
+  notType: (n) => {
+    const {
+      path: e,
+      value: t,
+      spec: r
+    } = n, s = r.types.length;
+    if (Array.isArray(t)) {
+      if (t.length < s) return `${e} tuple value has too few items, expected a length of ${s} but got ${t.length} for value: \`${T(t, !0)}\``;
+      if (t.length > s) return `${e} tuple value has too many items, expected a length of ${s} but got ${t.length} for value: \`${T(t, !0)}\``;
+    }
+    return m.formatError(x.notType, n);
+  }
+};
+var je = Object.assign(/* @__PURE__ */ Object.create(null), {
+  mixed: x,
+  string: b,
+  number: $,
+  date: K,
+  object: I,
+  array: z,
+  boolean: B,
+  tuple: he
+});
+const j = (n) => n && n.__isYupSchema__;
+class R {
+  static fromOptions(e, t) {
+    if (!t.then && !t.otherwise) throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
+    let {
+      is: r,
+      then: s,
+      otherwise: i
+    } = t, a = typeof r == "function" ? r : (...u) => u.every((l) => l === r);
+    return new R(e, (u, l) => {
+      var o;
+      let h = a(...u) ? s : i;
+      return (o = h?.(l)) != null ? o : l;
+    });
+  }
+  constructor(e, t) {
+    this.fn = void 0, this.refs = e, this.refs = e, this.fn = t;
+  }
+  resolve(e, t) {
+    let r = this.refs.map((i) => (
+      // TODO: ? operator here?
+      i.getValue(t?.value, t?.parent, t?.context)
+    )), s = this.fn(r, e, t);
+    if (s === void 0 || // @ts-ignore this can be base
+    s === e)
+      return e;
+    if (!j(s)) throw new TypeError("conditions must return a schema object");
+    return s.resolve(t);
+  }
+}
+const M = {
+  context: "$",
+  value: "."
+};
+function ut(n, e) {
+  return new O(n, e);
+}
+class O {
+  constructor(e, t = {}) {
+    if (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, typeof e != "string") throw new TypeError("ref must be a string, got: " + e);
+    if (this.key = e.trim(), e === "") throw new TypeError("ref must be a non-empty string");
+    this.isContext = this.key[0] === M.context, this.isValue = this.key[0] === M.value, this.isSibling = !this.isContext && !this.isValue;
+    let r = this.isContext ? M.context : this.isValue ? M.value : "";
+    this.path = this.key.slice(r.length), this.getter = this.path && S.getter(this.path, !0), this.map = t.map;
+  }
+  getValue(e, t, r) {
+    let s = this.isContext ? r : this.isValue ? e : t;
+    return this.getter && (s = this.getter(s || {})), this.map && (s = this.map(s)), s;
+  }
+  /**
+   *
+   * @param {*} value
+   * @param {Object} options
+   * @param {Object=} options.context
+   * @param {Object=} options.parent
+   */
+  cast(e, t) {
+    return this.getValue(e, t?.parent, t?.context);
+  }
+  resolve() {
+    return this;
+  }
+  describe() {
+    return {
+      type: "ref",
+      key: this.key
+    };
+  }
+  toString() {
+    return `Ref(${this.key})`;
+  }
+  static isRef(e) {
+    return e && e.__isYupRef;
+  }
+}
+O.prototype.__isYupRef = !0;
+const w = (n) => n == null;
+function A(n) {
+  function e({
+    value: t,
+    path: r = "",
+    options: s,
+    originalValue: i,
+    schema: a
+  }, u, l) {
+    const {
+      name: o,
+      test: h,
+      params: c,
+      message: f,
+      skipAbsent: d
+    } = n;
+    let {
+      parent: F,
+      context: g,
+      abortEarly: _ = a.spec.abortEarly,
+      disableStackTrace: C = a.spec.disableStackTrace
+    } = s;
+    function k(p) {
+      return O.isRef(p) ? p.getValue(t, F, g) : p;
+    }
+    function H(p = {}) {
+      const E = Object.assign({
+        value: t,
+        originalValue: i,
+        label: a.spec.label,
+        path: p.path || r,
+        spec: a.spec,
+        disableStackTrace: p.disableStackTrace || C
+      }, c, p.params);
+      for (const ee of Object.keys(E)) E[ee] = k(E[ee]);
+      const W = new m(m.formatError(p.message || f, E), t, E.path, p.type || o, E.disableStackTrace);
+      return W.params = E, W;
+    }
+    const q = _ ? u : l;
+    let L = {
+      path: r,
+      parent: F,
+      type: o,
+      from: s.from,
+      createError: H,
+      resolve: k,
+      options: s,
+      originalValue: i,
+      schema: a
+    };
+    const Z = (p) => {
+      m.isError(p) ? q(p) : p ? l(null) : q(H());
+    }, X = (p) => {
+      m.isError(p) ? q(p) : u(p);
+    };
+    if (d && w(t))
+      return Z(!0);
+    let V;
+    try {
+      var Q;
+      if (V = h.call(L, t, L), typeof ((Q = V) == null ? void 0 : Q.then) == "function") {
+        if (s.sync)
+          throw new Error(`Validation test of type: "${L.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
+        return Promise.resolve(V).then(Z, X);
+      }
+    } catch (p) {
+      X(p);
+      return;
+    }
+    Z(V);
+  }
+  return e.OPTIONS = n, e;
+}
+function fe(n, e, t, r = t) {
+  let s, i, a;
+  return e ? (S.forEach(e, (u, l, o) => {
+    let h = l ? u.slice(1, u.length - 1) : u;
+    n = n.resolve({
+      context: r,
+      parent: s,
+      value: t
+    });
+    let c = n.type === "tuple", f = o ? parseInt(h, 10) : 0;
+    if (n.innerType || c) {
+      if (c && !o) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${a}" must contain an index to the tuple element, e.g. "${a}[0]"`);
+      if (t && f >= t.length)
+        throw new Error(`Yup.reach cannot resolve an array item at index: ${u}, in the path: ${e}. because there is no value at that index. `);
+      s = t, t = t && t[f], n = c ? n.spec.types[f] : n.innerType;
+    }
+    if (!o) {
+      if (!n.fields || !n.fields[h]) throw new Error(`The schema does not contain the path: ${e}. (failed at: ${a} which is a type: "${n.type}")`);
+      s = t, t = t && t[h], n = n.fields[h];
+    }
+    i = h, a = l ? "[" + u + "]" : "." + u;
+  }), {
+    schema: n,
+    parent: s,
+    parentPath: i
+  }) : {
+    parent: s,
+    parentPath: e,
+    schema: n
+  };
+}
+function lt(n, e, t, r) {
+  return fe(n, e, t, r).schema;
+}
+class U extends Set {
+  describe() {
+    const e = [];
+    for (const t of this.values())
+      e.push(O.isRef(t) ? t.describe() : t);
+    return e;
+  }
+  resolveAll(e) {
+    let t = [];
+    for (const r of this.values())
+      t.push(e(r));
+    return t;
+  }
+  clone() {
+    return new U(this.values());
+  }
+  merge(e, t) {
+    const r = this.clone();
+    return e.forEach((s) => r.add(s)), t.forEach((s) => r.delete(s)), r;
+  }
+}
+function D(n, e = /* @__PURE__ */ new Map()) {
+  if (j(n) || !n || typeof n != "object") return n;
+  if (e.has(n)) return e.get(n);
+  let t;
+  if (n instanceof Date)
+    t = new Date(n.getTime()), e.set(n, t);
+  else if (n instanceof RegExp)
+    t = new RegExp(n), e.set(n, t);
+  else if (Array.isArray(n)) {
+    t = new Array(n.length), e.set(n, t);
+    for (let r = 0; r < n.length; r++) t[r] = D(n[r], e);
+  } else if (n instanceof Map) {
+    t = /* @__PURE__ */ new Map(), e.set(n, t);
+    for (const [r, s] of n.entries()) t.set(r, D(s, e));
+  } else if (n instanceof Set) {
+    t = /* @__PURE__ */ new Set(), e.set(n, t);
+    for (const r of n) t.add(D(r, e));
+  } else if (n instanceof Object) {
+    t = {}, e.set(n, t);
+    for (const [r, s] of Object.entries(n)) t[r] = D(s, e);
+  } else
+    throw Error(`Unable to clone ${n}`);
+  return t;
+}
+class y {
+  constructor(e) {
+    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 U(), this._blacklist = new U(), this.exclusiveTests = /* @__PURE__ */ Object.create(null), this._typeCheck = void 0, this.spec = void 0, this.tests = [], this.transforms = [], this.withMutation(() => {
+      this.typeError(x.notType);
+    }), this.type = e.type, this._typeCheck = e.check, this.spec = Object.assign({
+      strip: !1,
+      strict: !1,
+      abortEarly: !0,
+      recursive: !0,
+      disableStackTrace: !1,
+      nullable: !1,
+      optional: !0,
+      coerce: !0
+    }, e?.spec), this.withMutation((t) => {
+      t.nonNullable();
+    });
+  }
+  // TODO: remove
+  get _type() {
+    return this.type;
+  }
+  clone(e) {
+    if (this._mutate)
+      return e && Object.assign(this.spec, e), this;
+    const t = Object.create(Object.getPrototypeOf(this));
+    return t.type = this.type, t._typeCheck = this._typeCheck, t._whitelist = this._whitelist.clone(), t._blacklist = this._blacklist.clone(), t.internalTests = Object.assign({}, this.internalTests), t.exclusiveTests = Object.assign({}, this.exclusiveTests), t.deps = [...this.deps], t.conditions = [...this.conditions], t.tests = [...this.tests], t.transforms = [...this.transforms], t.spec = D(Object.assign({}, this.spec, e)), t;
+  }
+  label(e) {
+    let t = this.clone();
+    return t.spec.label = e, t;
+  }
+  meta(...e) {
+    if (e.length === 0) return this.spec.meta;
+    let t = this.clone();
+    return t.spec.meta = Object.assign(t.spec.meta || {}, e[0]), t;
+  }
+  withMutation(e) {
+    let t = this._mutate;
+    this._mutate = !0;
+    let r = e(this);
+    return this._mutate = t, r;
+  }
+  concat(e) {
+    if (!e || e === this) return this;
+    if (e.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${e.type}`);
+    let t = this, r = e.clone();
+    const s = Object.assign({}, t.spec, r.spec);
+    return r.spec = s, r.internalTests = Object.assign({}, t.internalTests, r.internalTests), r._whitelist = t._whitelist.merge(e._whitelist, e._blacklist), r._blacklist = t._blacklist.merge(e._blacklist, e._whitelist), r.tests = t.tests, r.exclusiveTests = t.exclusiveTests, r.withMutation((i) => {
+      e.tests.forEach((a) => {
+        i.test(a.OPTIONS);
+      });
+    }), r.transforms = [...t.transforms, ...r.transforms], r;
+  }
+  isType(e) {
+    return e == null ? !!(this.spec.nullable && e === null || this.spec.optional && e === void 0) : this._typeCheck(e);
+  }
+  resolve(e) {
+    let t = this;
+    if (t.conditions.length) {
+      let r = t.conditions;
+      t = t.clone(), t.conditions = [], t = r.reduce((s, i) => i.resolve(s, e), t), t = t.resolve(e);
+    }
+    return t;
+  }
+  resolveOptions(e) {
+    var t, r, s, i;
+    return Object.assign({}, e, {
+      from: e.from || [],
+      strict: (t = e.strict) != null ? t : this.spec.strict,
+      abortEarly: (r = e.abortEarly) != null ? r : this.spec.abortEarly,
+      recursive: (s = e.recursive) != null ? s : this.spec.recursive,
+      disableStackTrace: (i = e.disableStackTrace) != null ? i : this.spec.disableStackTrace
+    });
+  }
+  /**
+   * Run the configured transform pipeline over an input value.
+   */
+  cast(e, t = {}) {
+    let r = this.resolve(Object.assign({
+      value: e
+    }, t)), s = t.assert === "ignore-optionality", i = r._cast(e, t);
+    if (t.assert !== !1 && !r.isType(i)) {
+      if (s && w(i))
+        return i;
+      let a = T(e), u = T(i);
+      throw new TypeError(`The value of ${t.path || "field"} could not be cast to a value that satisfies the schema type: "${r.type}". 
+
+attempted value: ${a} 
+` + (u !== a ? `result of cast: ${u}` : ""));
+    }
+    return i;
+  }
+  _cast(e, t) {
+    let r = e === void 0 ? e : this.transforms.reduce((s, i) => i.call(this, s, e, this), e);
+    return r === void 0 && (r = this.getDefault(t)), r;
+  }
+  _validate(e, t = {}, r, s) {
+    let {
+      path: i,
+      originalValue: a = e,
+      strict: u = this.spec.strict
+    } = t, l = e;
+    u || (l = this._cast(l, Object.assign({
+      assert: !1
+    }, t)));
+    let o = [];
+    for (let h of Object.values(this.internalTests))
+      h && o.push(h);
+    this.runTests({
+      path: i,
+      value: l,
+      originalValue: a,
+      options: t,
+      tests: o
+    }, r, (h) => {
+      if (h.length)
+        return s(h, l);
+      this.runTests({
+        path: i,
+        value: l,
+        originalValue: a,
+        options: t,
+        tests: this.tests
+      }, r, s);
+    });
+  }
+  /**
+   * Executes a set of validations, either schema, produced Tests or a nested
+   * schema validate result.
+   */
+  runTests(e, t, r) {
+    let s = !1, {
+      tests: i,
+      value: a,
+      originalValue: u,
+      path: l,
+      options: o
+    } = e, h = (g) => {
+      s || (s = !0, t(g, a));
+    }, c = (g) => {
+      s || (s = !0, r(g, a));
+    }, f = i.length, d = [];
+    if (!f) return c([]);
+    let F = {
+      value: a,
+      originalValue: u,
+      path: l,
+      options: o,
+      schema: this
+    };
+    for (let g = 0; g < i.length; g++) {
+      const _ = i[g];
+      _(F, h, function(k) {
+        k && (Array.isArray(k) ? d.push(...k) : d.push(k)), --f <= 0 && c(d);
+      });
+    }
+  }
+  asNestedTest({
+    key: e,
+    index: t,
+    parent: r,
+    parentPath: s,
+    originalParent: i,
+    options: a
+  }) {
+    const u = e ?? t;
+    if (u == null)
+      throw TypeError("Must include `key` or `index` for nested validations");
+    const l = typeof u == "number";
+    let o = r[u];
+    const h = Object.assign({}, a, {
+      // 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: !0,
+      parent: r,
+      value: o,
+      originalValue: i[u],
+      // FIXME: tests depend on `index` being passed around deeply,
+      //   we should not let the options.key/index bleed through
+      key: void 0,
+      // index: undefined,
+      [l ? "index" : "key"]: u,
+      path: l || u.includes(".") ? `${s || ""}[${l ? u : `"${u}"`}]` : (s ? `${s}.` : "") + e
+    });
+    return (c, f, d) => this.resolve(h)._validate(o, h, f, d);
+  }
+  validate(e, t) {
+    var r;
+    let s = this.resolve(Object.assign({}, t, {
+      value: e
+    })), i = (r = t?.disableStackTrace) != null ? r : s.spec.disableStackTrace;
+    return new Promise((a, u) => s._validate(e, t, (l, o) => {
+      m.isError(l) && (l.value = o), u(l);
+    }, (l, o) => {
+      l.length ? u(new m(l, o, void 0, void 0, i)) : a(o);
+    }));
+  }
+  validateSync(e, t) {
+    var r;
+    let s = this.resolve(Object.assign({}, t, {
+      value: e
+    })), i, a = (r = t?.disableStackTrace) != null ? r : s.spec.disableStackTrace;
+    return s._validate(e, Object.assign({}, t, {
+      sync: !0
+    }), (u, l) => {
+      throw m.isError(u) && (u.value = l), u;
+    }, (u, l) => {
+      if (u.length) throw new m(u, e, void 0, void 0, a);
+      i = l;
+    }), i;
+  }
+  isValid(e, t) {
+    return this.validate(e, t).then(() => !0, (r) => {
+      if (m.isError(r)) return !1;
+      throw r;
+    });
+  }
+  isValidSync(e, t) {
+    try {
+      return this.validateSync(e, t), !0;
+    } catch (r) {
+      if (m.isError(r)) return !1;
+      throw r;
+    }
+  }
+  _getDefault(e) {
+    let t = this.spec.default;
+    return t == null ? t : typeof t == "function" ? t.call(this, e) : D(t);
+  }
+  getDefault(e) {
+    return this.resolve(e || {})._getDefault(e);
+  }
+  default(e) {
+    return arguments.length === 0 ? this._getDefault() : this.clone({
+      default: e
+    });
+  }
+  strict(e = !0) {
+    return this.clone({
+      strict: e
+    });
+  }
+  nullability(e, t) {
+    const r = this.clone({
+      nullable: e
+    });
+    return r.internalTests.nullable = A({
+      message: t,
+      name: "nullable",
+      test(s) {
+        return s === null ? this.schema.spec.nullable : !0;
+      }
+    }), r;
+  }
+  optionality(e, t) {
+    const r = this.clone({
+      optional: e
+    });
+    return r.internalTests.optionality = A({
+      message: t,
+      name: "optionality",
+      test(s) {
+        return s === void 0 ? this.schema.spec.optional : !0;
+      }
+    }), r;
+  }
+  optional() {
+    return this.optionality(!0);
+  }
+  defined(e = x.defined) {
+    return this.optionality(!1, e);
+  }
+  nullable() {
+    return this.nullability(!0);
+  }
+  nonNullable(e = x.notNull) {
+    return this.nullability(!1, e);
+  }
+  required(e = x.required) {
+    return this.clone().withMutation((t) => t.nonNullable(e).defined(e));
+  }
+  notRequired() {
+    return this.clone().withMutation((e) => e.nullable().optional());
+  }
+  transform(e) {
+    let t = this.clone();
+    return t.transforms.push(e), t;
+  }
+  /**
+   * 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(...e) {
+    let t;
+    if (e.length === 1 ? typeof e[0] == "function" ? t = {
+      test: e[0]
+    } : t = e[0] : e.length === 2 ? t = {
+      name: e[0],
+      test: e[1]
+    } : t = {
+      name: e[0],
+      message: e[1],
+      test: e[2]
+    }, t.message === void 0 && (t.message = x.default), typeof t.test != "function") throw new TypeError("`test` is a required parameters");
+    let r = this.clone(), s = A(t), i = t.exclusive || t.name && r.exclusiveTests[t.name] === !0;
+    if (t.exclusive && !t.name)
+      throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
+    return t.name && (r.exclusiveTests[t.name] = !!t.exclusive), r.tests = r.tests.filter((a) => !(a.OPTIONS.name === t.name && (i || a.OPTIONS.test === s.OPTIONS.test))), r.tests.push(s), r;
+  }
+  when(e, t) {
+    !Array.isArray(e) && typeof e != "string" && (t = e, e = ".");
+    let r = this.clone(), s = ue(e).map((i) => new O(i));
+    return s.forEach((i) => {
+      i.isSibling && r.deps.push(i.key);
+    }), r.conditions.push(typeof t == "function" ? new R(s, t) : R.fromOptions(s, t)), r;
+  }
+  typeError(e) {
+    let t = this.clone();
+    return t.internalTests.typeError = A({
+      message: e,
+      name: "typeError",
+      skipAbsent: !0,
+      test(r) {
+        return this.schema._typeCheck(r) ? !0 : this.createError({
+          params: {
+            type: this.schema.type
+          }
+        });
+      }
+    }), t;
+  }
+  oneOf(e, t = x.oneOf) {
+    let r = this.clone();
+    return e.forEach((s) => {
+      r._whitelist.add(s), r._blacklist.delete(s);
+    }), r.internalTests.whiteList = A({
+      message: t,
+      name: "oneOf",
+      skipAbsent: !0,
+      test(s) {
+        let i = this.schema._whitelist, a = i.resolveAll(this.resolve);
+        return a.includes(s) ? !0 : this.createError({
+          params: {
+            values: Array.from(i).join(", "),
+            resolved: a
+          }
+        });
+      }
+    }), r;
+  }
+  notOneOf(e, t = x.notOneOf) {
+    let r = this.clone();
+    return e.forEach((s) => {
+      r._blacklist.add(s), r._whitelist.delete(s);
+    }), r.internalTests.blacklist = A({
+      message: t,
+      name: "notOneOf",
+      test(s) {
+        let i = this.schema._blacklist, a = i.resolveAll(this.resolve);
+        return a.includes(s) ? this.createError({
+          params: {
+            values: Array.from(i).join(", "),
+            resolved: a
+          }
+        }) : !0;
+      }
+    }), r;
+  }
+  strip(e = !0) {
+    let t = this.clone();
+    return t.spec.strip = e, t;
+  }
+  /**
+   * 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(e) {
+    const t = (e ? this.resolve(e) : this).clone(), {
+      label: r,
+      meta: s,
+      optional: i,
+      nullable: a
+    } = t.spec;
+    return {
+      meta: s,
+      label: r,
+      optional: i,
+      nullable: a,
+      default: t.getDefault(e),
+      type: t.type,
+      oneOf: t._whitelist.describe(),
+      notOneOf: t._blacklist.describe(),
+      tests: t.tests.map((l) => ({
+        name: l.OPTIONS.name,
+        params: l.OPTIONS.params
+      })).filter((l, o, h) => h.findIndex((c) => c.name === l.name) === o)
+    };
+  }
+}
+y.prototype.__isYupSchema__ = !0;
+for (const n of ["validate", "validateSync"]) y.prototype[`${n}At`] = function(e, t, r = {}) {
+  const {
+    parent: s,
+    parentPath: i,
+    schema: a
+  } = fe(this, e, t, r.context);
+  return a[n](s && s[i], Object.assign({}, r, {
+    parent: s,
+    path: e
+  }));
+};
+for (const n of ["equals", "is"]) y.prototype[n] = y.prototype.oneOf;
+for (const n of ["not", "nope"]) y.prototype[n] = y.prototype.notOneOf;
+const Ne = () => !0;
+function Ce(n) {
+  return new pe(n);
+}
+class pe extends y {
+  constructor(e) {
+    super(typeof e == "function" ? {
+      type: "mixed",
+      check: e
+    } : Object.assign({
+      type: "mixed",
+      check: Ne
+    }, e));
+  }
+}
+Ce.prototype = pe.prototype;
+function Ve() {
+  return new de();
+}
+class de extends y {
+  constructor() {
+    super({
+      type: "boolean",
+      check(e) {
+        return e instanceof Boolean && (e = e.valueOf()), typeof e == "boolean";
+      }
+    }), this.withMutation(() => {
+      this.transform((e, t, r) => {
+        if (r.spec.coerce && !r.isType(e)) {
+          if (/^(true|1)$/i.test(String(e))) return !0;
+          if (/^(false|0)$/i.test(String(e))) return !1;
+        }
+        return e;
+      });
+    });
+  }
+  isTrue(e = B.isValue) {
+    return this.test({
+      message: e,
+      name: "is-value",
+      exclusive: !0,
+      params: {
+        value: "true"
+      },
+      test(t) {
+        return w(t) || t === !0;
+      }
+    });
+  }
+  isFalse(e = B.isValue) {
+    return this.test({
+      message: e,
+      name: "is-value",
+      exclusive: !0,
+      params: {
+        value: "false"
+      },
+      test(t) {
+        return w(t) || t === !1;
+      }
+    });
+  }
+  default(e) {
+    return super.default(e);
+  }
+  defined(e) {
+    return super.defined(e);
+  }
+  optional() {
+    return super.optional();
+  }
+  required(e) {
+    return super.required(e);
+  }
+  notRequired() {
+    return super.notRequired();
+  }
+  nullable() {
+    return super.nullable();
+  }
+  nonNullable(e) {
+    return super.nonNullable(e);
+  }
+  strip(e) {
+    return super.strip(e);
+  }
+}
+Ve.prototype = de.prototype;
+const Me = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
+function Ie(n) {
+  const e = J(n);
+  if (!e) return Date.parse ? Date.parse(n) : Number.NaN;
+  if (e.z === void 0 && e.plusMinus === void 0)
+    return new Date(e.year, e.month, e.day, e.hour, e.minute, e.second, e.millisecond).valueOf();
+  let t = 0;
+  return e.z !== "Z" && e.plusMinus !== void 0 && (t = e.hourOffset * 60 + e.minuteOffset, e.plusMinus === "+" && (t = 0 - t)), Date.UTC(e.year, e.month, e.day, e.hour, e.minute + t, e.second, e.millisecond);
+}
+function J(n) {
+  var e, t;
+  const r = Me.exec(n);
+  return r ? {
+    year: v(r[1]),
+    month: v(r[2], 1) - 1,
+    day: v(r[3], 1),
+    hour: v(r[4]),
+    minute: v(r[5]),
+    second: v(r[6]),
+    millisecond: r[7] ? (
+      // allow arbitrary sub-second precision beyond milliseconds
+      v(r[7].substring(0, 3))
+    ) : 0,
+    precision: (e = (t = r[7]) == null ? void 0 : t.length) != null ? e : void 0,
+    z: r[8] || void 0,
+    plusMinus: r[9] || void 0,
+    hourOffset: v(r[10]),
+    minuteOffset: v(r[11])
+  } : null;
+}
+function v(n, e = 0) {
+  return Number(n) || e;
+}
+let ze = (
+  // 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])?)*$/
+), Pe = (
+  // 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
+), Re = /^(?:[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, Ue = "^\\d{4}-\\d{2}-\\d{2}", qe = "\\d{2}:\\d{2}:\\d{2}", Le = "(([+-]\\d{2}(:?\\d{2})?)|Z)", Ze = new RegExp(`${Ue}T${qe}(\\.\\d+)?${Le}$`), Ye = (n) => w(n) || n === n.trim(), Ke = {}.toString();
+function Be() {
+  return new me();
+}
+class me extends y {
+  constructor() {
+    super({
+      type: "string",
+      check(e) {
+        return e instanceof String && (e = e.valueOf()), typeof e == "string";
+      }
+    }), this.withMutation(() => {
+      this.transform((e, t, r) => {
+        if (!r.spec.coerce || r.isType(e) || Array.isArray(e)) return e;
+        const s = e != null && e.toString ? e.toString() : e;
+        return s === Ke ? e : s;
+      });
+    });
+  }
+  required(e) {
+    return super.required(e).withMutation((t) => t.test({
+      message: e || x.required,
+      name: "required",
+      skipAbsent: !0,
+      test: (r) => !!r.length
+    }));
+  }
+  notRequired() {
+    return super.notRequired().withMutation((e) => (e.tests = e.tests.filter((t) => t.OPTIONS.name !== "required"), e));
+  }
+  length(e, t = b.length) {
+    return this.test({
+      message: t,
+      name: "length",
+      exclusive: !0,
+      params: {
+        length: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r.length === this.resolve(e);
+      }
+    });
+  }
+  min(e, t = b.min) {
+    return this.test({
+      message: t,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r.length >= this.resolve(e);
+      }
+    });
+  }
+  max(e, t = b.max) {
+    return this.test({
+      name: "max",
+      exclusive: !0,
+      message: t,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r.length <= this.resolve(e);
+      }
+    });
+  }
+  matches(e, t) {
+    let r = !1, s, i;
+    return t && (typeof t == "object" ? {
+      excludeEmptyString: r = !1,
+      message: s,
+      name: i
+    } = t : s = t), this.test({
+      name: i || "matches",
+      message: s || b.matches,
+      params: {
+        regex: e
+      },
+      skipAbsent: !0,
+      test: (a) => a === "" && r || a.search(e) !== -1
+    });
+  }
+  email(e = b.email) {
+    return this.matches(ze, {
+      name: "email",
+      message: e,
+      excludeEmptyString: !0
+    });
+  }
+  url(e = b.url) {
+    return this.matches(Pe, {
+      name: "url",
+      message: e,
+      excludeEmptyString: !0
+    });
+  }
+  uuid(e = b.uuid) {
+    return this.matches(Re, {
+      name: "uuid",
+      message: e,
+      excludeEmptyString: !1
+    });
+  }
+  datetime(e) {
+    let t = "", r, s;
+    return e && (typeof e == "object" ? {
+      message: t = "",
+      allowOffset: r = !1,
+      precision: s = void 0
+    } = e : t = e), this.matches(Ze, {
+      name: "datetime",
+      message: t || b.datetime,
+      excludeEmptyString: !0
+    }).test({
+      name: "datetime_offset",
+      message: t || b.datetime_offset,
+      params: {
+        allowOffset: r
+      },
+      skipAbsent: !0,
+      test: (i) => {
+        if (!i || r) return !0;
+        const a = J(i);
+        return a ? !!a.z : !1;
+      }
+    }).test({
+      name: "datetime_precision",
+      message: t || b.datetime_precision,
+      params: {
+        precision: s
+      },
+      skipAbsent: !0,
+      test: (i) => {
+        if (!i || s == null) return !0;
+        const a = J(i);
+        return a ? a.precision === s : !1;
+      }
+    });
+  }
+  //-- transforms --
+  ensure() {
+    return this.default("").transform((e) => e === null ? "" : e);
+  }
+  trim(e = b.trim) {
+    return this.transform((t) => t != null ? t.trim() : t).test({
+      message: e,
+      name: "trim",
+      test: Ye
+    });
+  }
+  lowercase(e = b.lowercase) {
+    return this.transform((t) => w(t) ? t : t.toLowerCase()).test({
+      message: e,
+      name: "string_case",
+      exclusive: !0,
+      skipAbsent: !0,
+      test: (t) => w(t) || t === t.toLowerCase()
+    });
+  }
+  uppercase(e = b.uppercase) {
+    return this.transform((t) => w(t) ? t : t.toUpperCase()).test({
+      message: e,
+      name: "string_case",
+      exclusive: !0,
+      skipAbsent: !0,
+      test: (t) => w(t) || t === t.toUpperCase()
+    });
+  }
+}
+Be.prototype = me.prototype;
+let Je = (n) => n != +n;
+function Ge() {
+  return new ye();
+}
+class ye extends y {
+  constructor() {
+    super({
+      type: "number",
+      check(e) {
+        return e instanceof Number && (e = e.valueOf()), typeof e == "number" && !Je(e);
+      }
+    }), this.withMutation(() => {
+      this.transform((e, t, r) => {
+        if (!r.spec.coerce) return e;
+        let s = e;
+        if (typeof s == "string") {
+          if (s = s.replace(/\s/g, ""), s === "") return NaN;
+          s = +s;
+        }
+        return r.isType(s) || s === null ? s : parseFloat(s);
+      });
+    });
+  }
+  min(e, t = $.min) {
+    return this.test({
+      message: t,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r >= this.resolve(e);
+      }
+    });
+  }
+  max(e, t = $.max) {
+    return this.test({
+      message: t,
+      name: "max",
+      exclusive: !0,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r <= this.resolve(e);
+      }
+    });
+  }
+  lessThan(e, t = $.lessThan) {
+    return this.test({
+      message: t,
+      name: "max",
+      exclusive: !0,
+      params: {
+        less: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r < this.resolve(e);
+      }
+    });
+  }
+  moreThan(e, t = $.moreThan) {
+    return this.test({
+      message: t,
+      name: "min",
+      exclusive: !0,
+      params: {
+        more: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r > this.resolve(e);
+      }
+    });
+  }
+  positive(e = $.positive) {
+    return this.moreThan(0, e);
+  }
+  negative(e = $.negative) {
+    return this.lessThan(0, e);
+  }
+  integer(e = $.integer) {
+    return this.test({
+      name: "integer",
+      message: e,
+      skipAbsent: !0,
+      test: (t) => Number.isInteger(t)
+    });
+  }
+  truncate() {
+    return this.transform((e) => w(e) ? e : e | 0);
+  }
+  round(e) {
+    var t;
+    let r = ["ceil", "floor", "round", "trunc"];
+    if (e = ((t = e) == null ? void 0 : t.toLowerCase()) || "round", e === "trunc") return this.truncate();
+    if (r.indexOf(e.toLowerCase()) === -1) throw new TypeError("Only valid options for round() are: " + r.join(", "));
+    return this.transform((s) => w(s) ? s : Math[e](s));
+  }
+}
+Ge.prototype = ye.prototype;
+let be = /* @__PURE__ */ new Date(""), He = (n) => Object.prototype.toString.call(n) === "[object Date]";
+function ge() {
+  return new N();
+}
+class N extends y {
+  constructor() {
+    super({
+      type: "date",
+      check(e) {
+        return He(e) && !isNaN(e.getTime());
+      }
+    }), this.withMutation(() => {
+      this.transform((e, t, r) => !r.spec.coerce || r.isType(e) || e === null ? e : (e = Ie(e), isNaN(e) ? N.INVALID_DATE : new Date(e)));
+    });
+  }
+  prepareParam(e, t) {
+    let r;
+    if (O.isRef(e))
+      r = e;
+    else {
+      let s = this.cast(e);
+      if (!this._typeCheck(s)) throw new TypeError(`\`${t}\` must be a Date or a value that can be \`cast()\` to a Date`);
+      r = s;
+    }
+    return r;
+  }
+  min(e, t = K.min) {
+    let r = this.prepareParam(e, "min");
+    return this.test({
+      message: t,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      test(s) {
+        return s >= this.resolve(r);
+      }
+    });
+  }
+  max(e, t = K.max) {
+    let r = this.prepareParam(e, "max");
+    return this.test({
+      message: t,
+      name: "max",
+      exclusive: !0,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(s) {
+        return s <= this.resolve(r);
+      }
+    });
+  }
+}
+N.INVALID_DATE = be;
+ge.prototype = N.prototype;
+ge.INVALID_DATE = be;
+function Xe(n, e = []) {
+  let t = [], r = /* @__PURE__ */ new Set(), s = new Set(e.map(([a, u]) => `${a}-${u}`));
+  function i(a, u) {
+    let l = S.split(a)[0];
+    r.add(l), s.has(`${u}-${l}`) || t.push([u, l]);
+  }
+  for (const a of Object.keys(n)) {
+    let u = n[a];
+    r.add(a), O.isRef(u) && u.isSibling ? i(u.path, a) : j(u) && "deps" in u && u.deps.forEach((l) => i(l, a));
+  }
+  return _e.array(Array.from(r), t).reverse();
+}
+function se(n, e) {
+  let t = 1 / 0;
+  return n.some((r, s) => {
+    var i;
+    if ((i = e.path) != null && i.includes(r))
+      return t = s, !0;
+  }), t;
+}
+function we(n) {
+  return (e, t) => se(n, e) - se(n, t);
+}
+const xe = (n, e, t) => {
+  if (typeof n != "string")
+    return n;
+  let r = n;
+  try {
+    r = JSON.parse(n);
+  } catch {
+  }
+  return t.isType(r) ? r : n;
+};
+function P(n) {
+  if ("fields" in n) {
+    const e = {};
+    for (const [t, r] of Object.entries(n.fields))
+      e[t] = P(r);
+    return n.setFields(e);
+  }
+  if (n.type === "array") {
+    const e = n.optional();
+    return e.innerType && (e.innerType = P(e.innerType)), e;
+  }
+  return n.type === "tuple" ? n.optional().clone({
+    types: n.spec.types.map(P)
+  }) : "optional" in n ? n.optional() : n;
+}
+const Qe = (n, e) => {
+  const t = [...S.normalizePath(e)];
+  if (t.length === 1) return t[0] in n;
+  let r = t.pop(), s = S.getter(S.join(t), !0)(n);
+  return !!(s && r in s);
+};
+let ne = (n) => Object.prototype.toString.call(n) === "[object Object]";
+function ie(n, e) {
+  let t = Object.keys(n.fields);
+  return Object.keys(e).filter((r) => t.indexOf(r) === -1);
+}
+const We = we([]);
+function et(n) {
+  return new ve(n);
+}
+class ve extends y {
+  constructor(e) {
+    super({
+      type: "object",
+      check(t) {
+        return ne(t) || typeof t == "function";
+      }
+    }), this.fields = /* @__PURE__ */ Object.create(null), this._sortErrors = We, this._nodes = [], this._excludedEdges = [], this.withMutation(() => {
+      e && this.shape(e);
+    });
+  }
+  _cast(e, t = {}) {
+    var r;
+    let s = super._cast(e, t);
+    if (s === void 0) return this.getDefault(t);
+    if (!this._typeCheck(s)) return s;
+    let i = this.fields, a = (r = t.stripUnknown) != null ? r : this.spec.noUnknown, u = [].concat(this._nodes, Object.keys(s).filter((c) => !this._nodes.includes(c))), l = {}, o = Object.assign({}, t, {
+      parent: l,
+      __validating: t.__validating || !1
+    }), h = !1;
+    for (const c of u) {
+      let f = i[c], d = c in s;
+      if (f) {
+        let F, g = s[c];
+        o.path = (t.path ? `${t.path}.` : "") + c, f = f.resolve({
+          value: g,
+          context: t.context,
+          parent: l
+        });
+        let _ = f instanceof y ? f.spec : void 0, C = _?.strict;
+        if (_ != null && _.strip) {
+          h = h || c in s;
+          continue;
+        }
+        F = !t.__validating || !C ? (
+          // TODO: use _cast, this is double resolving
+          f.cast(s[c], o)
+        ) : s[c], F !== void 0 && (l[c] = F);
+      } else d && !a && (l[c] = s[c]);
+      (d !== c in l || l[c] !== s[c]) && (h = !0);
+    }
+    return h ? l : s;
+  }
+  _validate(e, t = {}, r, s) {
+    let {
+      from: i = [],
+      originalValue: a = e,
+      recursive: u = this.spec.recursive
+    } = t;
+    t.from = [{
+      schema: this,
+      value: a
+    }, ...i], t.__validating = !0, t.originalValue = a, super._validate(e, t, r, (l, o) => {
+      if (!u || !ne(o)) {
+        s(l, o);
+        return;
+      }
+      a = a || o;
+      let h = [];
+      for (let c of this._nodes) {
+        let f = this.fields[c];
+        !f || O.isRef(f) || h.push(f.asNestedTest({
+          options: t,
+          key: c,
+          parent: o,
+          parentPath: t.path,
+          originalParent: a
+        }));
+      }
+      this.runTests({
+        tests: h,
+        value: o,
+        originalValue: a,
+        options: t
+      }, r, (c) => {
+        s(c.sort(this._sortErrors).concat(l), o);
+      });
+    });
+  }
+  clone(e) {
+    const t = super.clone(e);
+    return t.fields = Object.assign({}, this.fields), t._nodes = this._nodes, t._excludedEdges = this._excludedEdges, t._sortErrors = this._sortErrors, t;
+  }
+  concat(e) {
+    let t = super.concat(e), r = t.fields;
+    for (let [s, i] of Object.entries(this.fields)) {
+      const a = r[s];
+      r[s] = a === void 0 ? i : a;
+    }
+    return t.withMutation((s) => (
+      // XXX: excludes here is wrong
+      s.setFields(r, [...this._excludedEdges, ...e._excludedEdges])
+    ));
+  }
+  _getDefault(e) {
+    if ("default" in this.spec)
+      return super._getDefault(e);
+    if (!this._nodes.length)
+      return;
+    let t = {};
+    return this._nodes.forEach((r) => {
+      var s;
+      const i = this.fields[r];
+      let a = e;
+      (s = a) != null && s.value && (a = Object.assign({}, a, {
+        parent: a.value,
+        value: a.value[r]
+      })), t[r] = i && "getDefault" in i ? i.getDefault(a) : void 0;
+    }), t;
+  }
+  setFields(e, t) {
+    let r = this.clone();
+    return r.fields = e, r._nodes = Xe(e, t), r._sortErrors = we(Object.keys(e)), t && (r._excludedEdges = t), r;
+  }
+  shape(e, t = []) {
+    return this.clone().withMutation((r) => {
+      let s = r._excludedEdges;
+      return t.length && (Array.isArray(t[0]) || (t = [t]), s = [...r._excludedEdges, ...t]), r.setFields(Object.assign(r.fields, e), s);
+    });
+  }
+  partial() {
+    const e = {};
+    for (const [t, r] of Object.entries(this.fields))
+      e[t] = "optional" in r && r.optional instanceof Function ? r.optional() : r;
+    return this.setFields(e);
+  }
+  deepPartial() {
+    return P(this);
+  }
+  pick(e) {
+    const t = {};
+    for (const r of e)
+      this.fields[r] && (t[r] = this.fields[r]);
+    return this.setFields(t, this._excludedEdges.filter(([r, s]) => e.includes(r) && e.includes(s)));
+  }
+  omit(e) {
+    const t = [];
+    for (const r of Object.keys(this.fields))
+      e.includes(r) || t.push(r);
+    return this.pick(t);
+  }
+  from(e, t, r) {
+    let s = S.getter(e, !0);
+    return this.transform((i) => {
+      if (!i) return i;
+      let a = i;
+      return Qe(i, e) && (a = Object.assign({}, i), r || delete a[e], a[t] = s(i)), a;
+    });
+  }
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(xe);
+  }
+  /**
+   * Similar to `noUnknown` but only validates that an object is the right shape without stripping the unknown keys
+   */
+  exact(e) {
+    return this.test({
+      name: "exact",
+      exclusive: !0,
+      message: e || I.exact,
+      test(t) {
+        if (t == null) return !0;
+        const r = ie(this.schema, t);
+        return r.length === 0 || this.createError({
+          params: {
+            properties: r.join(", ")
+          }
+        });
+      }
+    });
+  }
+  stripUnknown() {
+    return this.clone({
+      noUnknown: !0
+    });
+  }
+  noUnknown(e = !0, t = I.noUnknown) {
+    typeof e != "boolean" && (t = e, e = !0);
+    let r = this.test({
+      name: "noUnknown",
+      exclusive: !0,
+      message: t,
+      test(s) {
+        if (s == null) return !0;
+        const i = ie(this.schema, s);
+        return !e || i.length === 0 || this.createError({
+          params: {
+            unknown: i.join(", ")
+          }
+        });
+      }
+    });
+    return r.spec.noUnknown = e, r;
+  }
+  unknown(e = !0, t = I.noUnknown) {
+    return this.noUnknown(!e, t);
+  }
+  transformKeys(e) {
+    return this.transform((t) => {
+      if (!t) return t;
+      const r = {};
+      for (const s of Object.keys(t)) r[e(s)] = t[s];
+      return r;
+    });
+  }
+  camelCase() {
+    return this.transformKeys(Y.camelCase);
+  }
+  snakeCase() {
+    return this.transformKeys(Y.snakeCase);
+  }
+  constantCase() {
+    return this.transformKeys((e) => Y.snakeCase(e).toUpperCase());
+  }
+  describe(e) {
+    const t = (e ? this.resolve(e) : this).clone(), r = super.describe(e);
+    r.fields = {};
+    for (const [i, a] of Object.entries(t.fields)) {
+      var s;
+      let u = e;
+      (s = u) != null && s.value && (u = Object.assign({}, u, {
+        parent: u.value,
+        value: u.value[i]
+      })), r.fields[i] = a.describe(u);
+    }
+    return r;
+  }
+}
+et.prototype = ve.prototype;
+function tt(n) {
+  return new Te(n);
+}
+class Te extends y {
+  constructor(e) {
+    super({
+      type: "array",
+      spec: {
+        types: e
+      },
+      check(t) {
+        return Array.isArray(t);
+      }
+    }), this.innerType = void 0, this.innerType = e;
+  }
+  _cast(e, t) {
+    const r = super._cast(e, t);
+    if (!this._typeCheck(r) || !this.innerType)
+      return r;
+    let s = !1;
+    const i = r.map((a, u) => {
+      const l = this.innerType.cast(a, Object.assign({}, t, {
+        path: `${t.path || ""}[${u}]`
+      }));
+      return l !== a && (s = !0), l;
+    });
+    return s ? i : r;
+  }
+  _validate(e, t = {}, r, s) {
+    var i;
+    let a = this.innerType, u = (i = t.recursive) != null ? i : this.spec.recursive;
+    t.originalValue != null && t.originalValue, super._validate(e, t, r, (l, o) => {
+      var h;
+      if (!u || !a || !this._typeCheck(o)) {
+        s(l, o);
+        return;
+      }
+      let c = new Array(o.length);
+      for (let d = 0; d < o.length; d++) {
+        var f;
+        c[d] = a.asNestedTest({
+          options: t,
+          index: d,
+          parent: o,
+          parentPath: t.path,
+          originalParent: (f = t.originalValue) != null ? f : e
+        });
+      }
+      this.runTests({
+        value: o,
+        tests: c,
+        originalValue: (h = t.originalValue) != null ? h : e,
+        options: t
+      }, r, (d) => s(d.concat(l), o));
+    });
+  }
+  clone(e) {
+    const t = super.clone(e);
+    return t.innerType = this.innerType, t;
+  }
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(xe);
+  }
+  concat(e) {
+    let t = super.concat(e);
+    return t.innerType = this.innerType, e.innerType && (t.innerType = t.innerType ? (
+      // @ts-expect-error Lazy doesn't have concat and will break
+      t.innerType.concat(e.innerType)
+    ) : e.innerType), t;
+  }
+  of(e) {
+    let t = this.clone();
+    if (!j(e)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + T(e));
+    return t.innerType = e, t.spec = Object.assign({}, t.spec, {
+      types: e
+    }), t;
+  }
+  length(e, t = z.length) {
+    return this.test({
+      message: t,
+      name: "length",
+      exclusive: !0,
+      params: {
+        length: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r.length === this.resolve(e);
+      }
+    });
+  }
+  min(e, t) {
+    return t = t || z.min, this.test({
+      message: t,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      // FIXME(ts): Array<typeof T>
+      test(r) {
+        return r.length >= this.resolve(e);
+      }
+    });
+  }
+  max(e, t) {
+    return t = t || z.max, this.test({
+      message: t,
+      name: "max",
+      exclusive: !0,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(r) {
+        return r.length <= this.resolve(e);
+      }
+    });
+  }
+  ensure() {
+    return this.default(() => []).transform((e, t) => this._typeCheck(e) ? e : t == null ? [] : [].concat(t));
+  }
+  compact(e) {
+    let t = e ? (r, s, i) => !e(r, s, i) : (r) => !!r;
+    return this.transform((r) => r != null ? r.filter(t) : r);
+  }
+  describe(e) {
+    const t = (e ? this.resolve(e) : this).clone(), r = super.describe(e);
+    if (t.innerType) {
+      var s;
+      let i = e;
+      (s = i) != null && s.value && (i = Object.assign({}, i, {
+        parent: i.value,
+        value: i.value[0]
+      })), r.innerType = t.innerType.describe(i);
+    }
+    return r;
+  }
+}
+tt.prototype = Te.prototype;
+function rt(n) {
+  return new Fe(n);
+}
+class Fe extends y {
+  constructor(e) {
+    super({
+      type: "tuple",
+      spec: {
+        types: e
+      },
+      check(t) {
+        const r = this.spec.types;
+        return Array.isArray(t) && t.length === r.length;
+      }
+    }), this.withMutation(() => {
+      this.typeError(he.notType);
+    });
+  }
+  _cast(e, t) {
+    const {
+      types: r
+    } = this.spec, s = super._cast(e, t);
+    if (!this._typeCheck(s))
+      return s;
+    let i = !1;
+    const a = r.map((u, l) => {
+      const o = u.cast(s[l], Object.assign({}, t, {
+        path: `${t.path || ""}[${l}]`
+      }));
+      return o !== s[l] && (i = !0), o;
+    });
+    return i ? a : s;
+  }
+  _validate(e, t = {}, r, s) {
+    let i = this.spec.types;
+    super._validate(e, t, r, (a, u) => {
+      var l;
+      if (!this._typeCheck(u)) {
+        s(a, u);
+        return;
+      }
+      let o = [];
+      for (let [c, f] of i.entries()) {
+        var h;
+        o[c] = f.asNestedTest({
+          options: t,
+          index: c,
+          parent: u,
+          parentPath: t.path,
+          originalParent: (h = t.originalValue) != null ? h : e
+        });
+      }
+      this.runTests({
+        value: u,
+        tests: o,
+        originalValue: (l = t.originalValue) != null ? l : e,
+        options: t
+      }, r, (c) => s(c.concat(a), u));
+    });
+  }
+  describe(e) {
+    const t = (e ? this.resolve(e) : this).clone(), r = super.describe(e);
+    return r.innerType = t.spec.types.map((s, i) => {
+      var a;
+      let u = e;
+      return (a = u) != null && a.value && (u = Object.assign({}, u, {
+        parent: u.value,
+        value: u.value[i]
+      })), s.describe(u);
+    }), r;
+  }
+}
+rt.prototype = Fe.prototype;
+function ot(n) {
+  return new G(n);
+}
+function ae(n) {
+  try {
+    return n();
+  } catch (e) {
+    if (m.isError(e)) return Promise.reject(e);
+    throw e;
+  }
+}
+class G {
+  constructor(e) {
+    this.type = "lazy", this.__isYupSchema__ = !0, this.spec = void 0, this._resolve = (t, r = {}) => {
+      let s = this.builder(t, r);
+      if (!j(s)) throw new TypeError("lazy() functions must return a valid schema");
+      return this.spec.optional && (s = s.optional()), s.resolve(r);
+    }, this.builder = e, this.spec = {
+      meta: void 0,
+      optional: !1
+    };
+  }
+  clone(e) {
+    const t = new G(this.builder);
+    return t.spec = Object.assign({}, this.spec, e), t;
+  }
+  optionality(e) {
+    return this.clone({
+      optional: e
+    });
+  }
+  optional() {
+    return this.optionality(!0);
+  }
+  resolve(e) {
+    return this._resolve(e.value, e);
+  }
+  cast(e, t) {
+    return this._resolve(e, t).cast(e, t);
+  }
+  asNestedTest(e) {
+    let {
+      key: t,
+      index: r,
+      parent: s,
+      options: i
+    } = e, a = s[r ?? t];
+    return this._resolve(a, Object.assign({}, i, {
+      value: a,
+      parent: s
+    })).asNestedTest(e);
+  }
+  validate(e, t) {
+    return ae(() => this._resolve(e, t).validate(e, t));
+  }
+  validateSync(e, t) {
+    return this._resolve(e, t).validateSync(e, t);
+  }
+  validateAt(e, t, r) {
+    return ae(() => this._resolve(t, r).validateAt(e, t, r));
+  }
+  validateSyncAt(e, t, r) {
+    return this._resolve(t, r).validateSyncAt(e, t, r);
+  }
+  isValid(e, t) {
+    try {
+      return this._resolve(e, t).isValid(e, t);
+    } catch (r) {
+      if (m.isError(r))
+        return Promise.resolve(!1);
+      throw r;
+    }
+  }
+  isValidSync(e, t) {
+    return this._resolve(e, t).isValidSync(e, t);
+  }
+  describe(e) {
+    return e ? this.resolve(e).describe(e) : {
+      type: "lazy",
+      meta: this.spec.meta,
+      label: void 0
+    };
+  }
+  meta(...e) {
+    if (e.length === 0) return this.spec.meta;
+    let t = this.clone();
+    return t.spec.meta = Object.assign(t.spec.meta || {}, e[0]), t;
+  }
+}
+function ct(n) {
+  Object.keys(n).forEach((e) => {
+    Object.keys(n[e]).forEach((t) => {
+      je[e][t] = n[e][t];
+    });
+  });
+}
+function ht(n, e, t) {
+  if (!n || !j(n.prototype)) throw new TypeError("You must provide a yup schema constructor function");
+  if (typeof e != "string") throw new TypeError("A Method name must be provided");
+  if (typeof t != "function") throw new TypeError("Method function must be provided");
+  n.prototype[e] = t;
+}
+export {
+  Te as ArraySchema,
+  de as BooleanSchema,
+  N as DateSchema,
+  G as LazySchema,
+  pe as MixedSchema,
+  ye as NumberSchema,
+  ve as ObjectSchema,
+  y as Schema,
+  me as StringSchema,
+  Fe as TupleSchema,
+  m as ValidationError,
+  ht as addMethod,
+  tt as array,
+  Ve as bool,
+  Ve as boolean,
+  ge as date,
+  je as defaultLocale,
+  fe as getIn,
+  j as isSchema,
+  ot as lazy,
+  Ce as mixed,
+  Ge as number,
+  et as object,
+  T as printValue,
+  lt as reach,
+  ut as ref,
+  ct as setLocale,
+  Be as string,
+  rt as tuple
+};