@thisisagile/easy 18.11.2 → 18.13.0

package/dist/{chunk-AVHYDITZ.mjs → chunk-BS5KUNX2.mjs}

@@ -42,949 +42,959 @@ import {
   isTrue
 } from "./chunk-AAND4MKF.mjs";
 
-// src/types/Object.ts
-function entries(subject) {
-  return ifDefined(
-    subject,
-    () => toList([...Object.entries(subject), ...Object.entries(Object.getPrototypeOf(subject) ?? {})]),
-    () => toList()
-  );
-}
-function values(subject) {
-  return toList([...Object.values(subject), ...Object.values(Object.getPrototypeOf(subject) ?? {})]);
-}
-function keys(subject) {
-  return toList([...Object.keys(subject), ...Object.keys(Object.getPrototypeOf(subject) ?? {})]);
-}
-function extractKeys(obj, keys2) {
-  return keys2.filter((k) => k in obj).reduce(
-    (acc, key) => {
-      acc.keys[key] = obj[key];
-      delete acc[key];
-      return acc;
-    },
-    { keys: {}, ...obj }
-  );
-}
-
-// src/utils/Promise.ts
-var resolve = (subject) => Promise.resolve(subject);
-var reject = (e) => Promise.reject(e);
-var tuple = {
-  2: (first, second) => Promise.all([first, second]),
-  3: (first, second, third) => Promise.all([first, second, third]),
-  4: (first, second, third, forth) => Promise.all([first, second, third, forth]),
-  5: (first, second, third, forth, fifth) => Promise.all([first, second, third, forth, fifth]),
-  all: (first, second) => Promise.all([first, Promise.all(second)]),
-  spread: (first, ...second) => Promise.all([first, Promise.all(toArray(second))]),
-  list: (list) => Promise.all([...list]).then(toList),
-  settled: (list) => Promise.allSettled([...list]).then((rs) => ({
-    fulfilled: toList(...rs.filter((r) => r.status === "fulfilled").map((r) => r.value)),
-    rejected: toList(...rs.filter((r) => r.status === "rejected").map((r) => asString(r.reason)))
-  })),
-  object: (obj) => use(keys(obj), (ks) => tuple.list(values(obj)).then((vs) => vs.reduce((acc, v, i) => on(acc, (a) => a[ks[i]] = v), {})))
-};
-var tuple2 = tuple[2];
-var tuple3 = tuple[3];
-var tuple4 = tuple[4];
-var tuple5 = tuple[5];
-var tupleO = tuple.object;
-var settled = tuple.settled;
-
-// src/types/Meta.ts
-import "reflect-metadata";
-var ClassMeta = class {
-  constructor(subject, data = (subject.prototype ?? subject).constructor) {
-    this.subject = subject;
-    this.data = data;
-  }
-  get = (key) => Reflect.getMetadata(key, this.data);
-  set = (key, value) => {
-    Reflect.defineMetadata(key, value, this.data);
-    return value;
-  };
-  entries = () => entries(this.subject);
-  parse = (f, options = {}) => {
-    const { initial = {}, skipUndefined = false } = options;
-    return this.entries().reduce((a, [k, val]) => use(f(val), (v) => isDefined(v) || !skipUndefined ? on(a, (a2) => a2[k] = v) : a), initial);
-  };
-  properties = (key) => toList([...Object.getOwnPropertyNames(this.subject), ...Object.getOwnPropertyNames(Object.getPrototypeOf(this.subject))]).map((p) => this.property(p)).filter((p) => key ? p.get(key) : p);
-  keys = (key) => this.properties().map((p) => p.get(key)).reduce((list, u) => u ? list.add(u) : list, toList());
-  values = () => values(this.subject);
-  property = (property) => new PropertyMeta(this.subject, property);
-};
-var PropertyMeta = class {
-  constructor(subject, property, data = Reflect.getMetadata(property, subject)) {
-    this.subject = subject;
-    this.property = property;
-    this.data = data;
-  }
-  get value() {
-    return this.subject[this.property];
+// src/types/Case.ts
+var CaseBuilder = class {
+  constructor(v) {
+    this.v = v;
   }
-  get = (key) => isDefined(this.data) && isDefined(this.data[key]) ? this.data[key] : void 0;
-  set = (key, value) => {
-    Reflect.defineMetadata(this.property, { ...this.data, [key]: value }, this.subject);
-    return value;
+  is = {
+    true: (pred, out) => this.case(pred, out),
+    false: (pred, out) => this.case(!ofGet(pred, this.v), out),
+    truthy: (prop, out) => this.case(!!prop(this.v), out),
+    falsy: (prop, out) => this.case(!prop(this.v), out),
+    defined: (prop, out) => this.case(isDefined(prop(this.v)), out),
+    empty: (prop, out) => this.case(isEmpty(prop(this.v)), out),
+    valid: (prop, out) => this.case(validate(prop(this.v)).isValid, out),
+    in: (prop, out) => this.case(ofGet(prop, this.v).includes(this.v), out),
+    type: (guard, out) => this.type(guard, out),
+    not: {
+      true: (pred, out) => this.case(!ofGet(pred, this.v), out),
+      false: (pred, out) => this.case(pred, out),
+      truthy: (prop, out) => this.case(!prop(this.v), out),
+      falsy: (prop, out) => this.case(!!prop(this.v), out),
+      defined: (prop, out) => this.case(!isDefined(prop(this.v)), out),
+      empty: (prop, out) => this.case(!isEmpty(prop(this.v)), out),
+      valid: (prop, out) => this.case(!validate(prop(this.v)).isValid, out),
+      in: (prop, out) => this.case(!ofGet(prop, this.v).includes(this.v), out),
+      type: (guard, out) => this.case((v) => !guard(v), out)
+    }
   };
-};
-var meta = (subject) => new ClassMeta(subject ?? {});
-
-// src/types/Enum.ts
-var isEnumConstructor = (c) => isFunction(c) && c.isEnum;
-var Enum = class {
-  constructor(name, id = name.toLowerCase(), code = id.toString()) {
-    this.name = name;
-    this.id = id;
-    this.code = code;
-  }
-  static isEnum = true;
-  get isValid() {
-    return isDefined(this.id);
-  }
-  static all() {
-    return meta(this.allTuple()).values();
-  }
-  static filter(p, params) {
-    return this.all().filter(p, params);
-  }
-  static first(p, params) {
-    return this.all().first(p, params);
-  }
-  static byIds(ids = []) {
-    return toList(ids).mapDefined((id) => this.byId(id)).distinct();
-  }
-  static byId(id, alt) {
-    return this.allTuple()[id] ?? ofGet(alt);
-  }
-  static allTuple() {
-    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
-  }
-  equals(other) {
-    return this.id === (isEnum(other) ? other.id : other);
-  }
-  isIn(...items) {
-    return items.some((i) => this.equals(i));
+  if = this.is;
+  case(pred, out) {
+    return new Case(this.v).case(pred, out);
   }
-  toJSON() {
-    return this.id;
+  type(guard, out) {
+    return new Case(this.v).type(guard, out);
   }
-  toString() {
-    return this.id.toString();
+  equals(value, out) {
+    return new Case(this.v).equals(value, out);
   }
 };
-var isEnum = (e) => isDefined(e) && e instanceof Enum && isAn(e, "name", "id", "code");
-
-// src/types/Try.ts
-var Try = class _Try {
+var Case = class {
+  constructor(value, outcome) {
+    this.value = value;
+    this.outcome = outcome;
+  }
   is = {
-    defined: (prop) => this.filter((v) => isDefined(prop ? prop(v) : v)),
-    empty: (prop) => this.filter((v) => isEmpty(prop ? prop(v) : v)),
-    valid: (prop) => this.filter((v) => validate(prop ? prop(v) : v).isValid),
-    true: (prop) => this.filter((v) => isTrue(prop ? prop(v) : v)),
-    false: (prop) => this.filter((v) => !isTrue(prop ? prop(v) : v)),
+    true: (pred, out) => this.case(pred, out),
+    false: (pred, out) => this.case(!ofGet(pred, this.value), out),
+    truthy: (prop, out) => this.case(!!prop(this.value), out),
+    falsy: (prop, out) => this.case(!prop(this.value), out),
+    defined: (prop, out) => this.case(isDefined(prop(this.value)), out),
+    empty: (prop, out) => this.case(isEmpty(prop(this.value)), out),
+    valid: (prop, out) => this.case(validate(prop(this.value)).isValid, out),
+    in: (prop, out) => this.case(ofGet(prop, this.value).includes(this.value), out),
+    type: (guard, out) => this.type(guard, out),
     not: {
-      defined: (prop) => this.filter((v) => !isDefined(prop ? prop(v) : v)),
-      empty: (prop) => this.filter((v) => !isEmpty(prop ? prop(v) : v)),
-      valid: (prop) => this.filter((v) => !validate(prop ? prop(v) : v).isValid)
+      true: (pred, out) => this.case(!ofGet(pred, this.value), out),
+      false: (pred, out) => this.case(pred, out),
+      truthy: (prop, out) => this.case(!prop(this.value), out),
+      falsy: (prop, out) => this.case(!!prop(this.value), out),
+      defined: (prop, out) => this.case(!isDefined(prop(this.value)), out),
+      empty: (prop, out) => this.case(!isEmpty(prop(this.value)), out),
+      valid: (prop, out) => this.case(!validate(prop(this.value)).isValid, out),
+      in: (prop, out) => this.case(!ofGet(prop, this.value).includes(this.value), out),
+      type: (guard, out) => this.case((v) => !guard(v), out)
     }
   };
   if = this.is;
-  static of = (c, ...args) => {
-    try {
-      const out = ofGet(c, ...args);
-      return new Success(out instanceof _Try ? out.value : out);
-    } catch (e) {
-      return new Failure(e);
-    }
-  };
-};
-var Success = class extends Try {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  get error() {
-    throw new Error("No error found");
-  }
-  get isValid() {
-    return true;
-  }
-  map(f) {
-    return tryTo(f, this.value);
-  }
-  recover(f) {
-    return this;
-  }
-  recoverFrom(type, f) {
-    return this;
-  }
-  accept(f) {
-    return tryTo(() => {
-      f(this.value);
-      return this;
-    });
-  }
-  filter(predicate) {
-    return tryTo(() => {
-      if (predicate(this.value))
-        return this;
-      throw new Error(`Applying filter(${predicate.toString()}) failed.`);
-    });
+  case(pred, out) {
+    return tryTo(pred, this.value).is.true().map(() => ofGet(out, this.value)).map((res) => new Found(this.value, res)).or(this);
   }
-  or(value) {
-    return this.value;
+  type(guard, out) {
+    return tryTo(guard, this.value).is.true().map(() => out(this.value)).map((res) => new Found(this.value, res)).or(this);
   }
-  orElse(value) {
-    return this.value;
+  equals(value, out) {
+    return this.case(this.value === value, out);
   }
-  orThrow(_error) {
-    return this.value;
+  else(alt) {
+    return ofGet(alt, this.value);
   }
 };
-var Failure = class _Failure extends Try {
-  constructor(error) {
-    super();
-    this.error = error;
-  }
-  get value() {
-    throw this.error;
-  }
-  get isValid() {
-    return false;
-  }
-  map(f) {
-    return new _Failure(this.error);
-  }
-  recover(f) {
-    return tryTo(f, this.error);
-  }
-  recoverFrom(type, f) {
-    return tryTo(() => this.error instanceof type ? this.recover(f) : this);
+var Found = class extends Case {
+  constructor(value, outcome) {
+    super(value, outcome);
+    this.value = value;
+    this.outcome = outcome;
   }
-  accept(f) {
+  case(pred, out) {
     return this;
   }
-  filter(predicate) {
+  type(guard, out) {
     return this;
   }
-  or(value) {
-    return ofGet(value);
-  }
-  orElse(value) {
-    return ofGet(value);
+  equals(value, out) {
+    return this;
   }
-  orThrow(error) {
-    throw ofConstruct(error);
+  else(alt) {
+    return this.outcome;
   }
 };
-var tryTo = (c, ...args) => Try.of(c, ...args);
+var choose = (value) => new CaseBuilder(value);
 
-// src/types/Template.ts
-var Template = class {
-  constructor(template2, subject = {}, options = {}) {
-    this.template = template2;
-    this.subject = subject;
-    this.options = options;
-  }
-  knownPrefixes = /* @__PURE__ */ new Set(["typeof", "property", "actual", "subject"]);
-  toString = () => {
-    return entries(this.options).reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
-  };
-  props = (tmpl, key, result = toList()) => {
-    const i1 = tmpl.indexOf(`{${key}`);
-    if (i1 < 0) {
-      return result;
-    }
-    const i2 = tmpl.indexOf("}", i1);
-    return this.props(tmpl.slice(i2 + 1), key, result.add(tmpl.substring(i1 + 1, i2)));
-  };
-  object = () => tryTo(() => this.template.replace(/\{this\./g, "{")).map((t) => t.replace(/\{([^{}]+)}/g, (match, p) => this.knownPrefixes.has(p.split(".")[0]) ? match : textValue(this.subject, p))).or("");
-  option = (tmpl, prop) => {
-    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, textValue(this.options, p)), tmpl);
-  };
-};
-function template(tmpl, subject, options = {}) {
-  return new Template(asString(tmpl), subject, {
-    typeof: toName(subject),
-    subject: text(JSON.stringify(subject)),
-    ...options
-  });
+// src/types/IsEqual.ts
+var isEqualArray = (one, another) => choose([one, another]).case(([o, a]) => !isArray(o) || !isArray(a), false).case(([o, a]) => o?.length !== a?.length, false).else(([o, a]) => !o.some((v, i) => !isEqual(v, a[i])));
+var isEqualObject = (one, another) => choose([Object.keys(one), Object.keys(another)]).case(([keysO, keysA]) => keysO.length !== keysA.length, false).case(([keysO, keysA]) => keysO.some((k) => !keysA.includes(k)), false).case(([keysO]) => keysO.some((k) => !isEqual(one[k], another[k])), false).else(true);
+var isEqual = (one, another) => choose([one, another]).case(([o, a]) => o === a, true).case(
+  ([o, a]) => isArray(o) || isArray(a),
+  ([o, a]) => isEqualArray(o, a)
+).case(
+  ([o, a]) => o == null || a == null || !isObject(o) && !isObject(a),
+  ([o, a]) => o !== o && a !== a
+).else(([o, a]) => isEqualObject(o, a));
+
+// src/utils/If.ts
+function ifTrue(o, f, alt) {
+  return isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifFalse(o, f, alt) {
+  return !isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifDefined(o, f, alt) {
+  return isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
+}
+function ifNotEmpty(o, f = (o2) => o2, alt) {
+  return isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifEqual(one, another, f, alt) {
+  return isEqual(one, another) ? ofConstruct(f) : ofConstruct(alt);
+}
+function ifEither(os, f = (o) => o, alt) {
+  return use(
+    toList(os).first((o) => isPresent(o)),
+    (o) => isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt, o)
+  );
 }
 
-// src/types/ToText.ts
-var ToText = class {
-  constructor(subject) {
-    this.subject = subject;
+// src/types/List.ts
+var List = class extends Array {
+  get ids() {
+    return this.mapDefined((i) => i.id);
   }
-  get cap() {
-    return this.map((s) => capitalize(s?.toLowerCase()));
+  get indexed() {
+    return this.map((v, index) => ({ ...v, index }));
   }
-  get capFirst() {
-    return this.map((s) => capitalize(s));
+  isSubSetOf(...items) {
+    return this.diff(items).length === 0;
   }
-  get title() {
-    return this.map(
-      (s) => s.split(" ").map((w) => text(w).cap).join(" ")
-    );
+  isSuperSetOf(...items) {
+    return this.length > items.length && toList(...items).isSubSetOf(...this);
   }
-  get pascal() {
-    return this.title.replace(" ", "");
+  isIntersectingWith(...items) {
+    return this.intersect(items).length > 0;
   }
-  get lower() {
-    return this.map((s) => s.toLowerCase());
+  isDisjointWith(...items) {
+    return !this.isIntersectingWith(...items);
   }
-  get upper() {
-    return this.map((s) => s.toUpperCase());
+  areEqual(...items) {
+    return this.isSubSetOf(...items) && toList(...items).isSubSetOf(...this);
   }
-  get camel() {
-    return this.title.trim.map((s) => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
+  asc(p) {
+    return toList(...this).sort((e1, e2) => ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1);
   }
-  get kebab() {
-    return this.lower.replace(" ", "-");
+  desc(p) {
+    return toList(...this).sort((e1, e2) => ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1);
   }
-  get strictKebab() {
-    return this.map((s) => s.replace(/[^a-z\d]+/gi, " ").trim()).kebab;
+  first(p, params) {
+    return p ? this.find(p, params) : this[0];
   }
-  get slug() {
-    return this.map(
-      (s) => s.replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z\d]+/g, "-").replace(/(^-)|(-$)/g, "")
+  firstValue(f, alt) {
+    return ifDefined(
+      this.first((t) => !!f(t)),
+      f,
+      (v) => ofGet(alt, v)
     );
   }
-  get snake() {
-    return this.upper.replace(" ", "_");
+  isFirst(value) {
+    return value === this.first();
   }
-  get plural() {
-    return this.ifLike("") ?? this.add("s");
+  next(p, params) {
+    return p ? this[this.findIndex(p, params) + 1] : this[0];
   }
-  get space() {
-    return this.map((s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " "));
+  prev(p, params) {
+    return p ? this[this.findIndex(p, params) - 1] : this[0];
   }
-  get sentence() {
-    return this.isEmpty ? this : this.map((s) => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
+  last(p, params) {
+    return p ? this.filter(p, params).last() : this[this.length - 1];
   }
-  get initials() {
-    return this.map(
-      (s) => s.split(" ").map((w) => w[0]).join("")
-    );
+  isLast(value) {
+    return value === this.last();
   }
-  get trim() {
-    return this.map((s) => s.replace(/[- ,_#]/g, ""));
+  overlaps(...items) {
+    return toList(...items).some((i) => this.some((t) => i === t));
   }
-  get trimSentence() {
-    return this.map(
-      (s) => s.replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\s\u00A0]+/g, " ").replace(/\s+([.,;:!?])/g, "$1").trim()
-    );
+  diff(others) {
+    return this.filter((i) => !others.includes(i));
   }
-  get isEmpty() {
-    return isEmpty(this.toString());
+  diffByKey(others, key) {
+    return this.filter((i) => !others.some((o) => o[key] === i[key]));
   }
-  parse = (subject, options = {}) => text(template(this.subject, subject, { typeof: toName(subject), ...options }));
-  is = (...others) => others.some((o) => this.toString() === text(o).toString());
-  equals = this.is;
-  like = (...others) => others.some((o) => this.trim.lower.toString().includes(text(o).trim.lower.toString()));
-  isLike = (...others) => others.some((o) => this.trim.lower.is(text(o).trim.lower));
-  ifLike = (...others) => this.isLike(...others) ? this : void 0;
-  endsWith = (end) => this.subject.endsWith(asString(end));
-  startsWith = (end) => this.subject.startsWith(asString(end));
-  first = (n) => this.map((s) => s.substring(0, n));
-  last = (n) => this.map((s) => s.substring(s.length - n));
-  map = (func) => text(ofGet(func, this.subject));
-  replace = (search, replace) => this.map((s) => replaceAll(s, search, replace));
-  add = (add, separator = "") => this.map((s) => isNotEmpty(add) ? `${s}${separator}${text(add)}` : s);
-  with = (separator, ...other) => this.map(
-    (s) => toList(s).add(...other.map((u) => text(u).toString())).filter((s2) => isNotEmpty(s2)).join(separator)
-  );
-  split = (separator = " ") => toList(this.subject.split(separator));
-  toString() {
-    return this.subject;
+  symmetricDiff(others) {
+    return this.diff(others).concat(toList(...others).diff(this));
+  }
+  symmetricDiffByKey(others, key) {
+    return this.diffByKey(others, key).concat(toList(...others).diffByKey(this, key));
+  }
+  intersect(others) {
+    return this.filter((i) => others.includes(i));
+  }
+  intersectByKey(others, key) {
+    return this.filter((i) => others.some((o) => o[key] === i[key]));
+  }
+  intersectBy(others, f) {
+    return this.filter((i) => others.some((o) => f(i, o)));
+  }
+  accumulate(...keys2) {
+    return this.map((d, i, arr) => {
+      const acc = keys2.reduce((acc2, v) => {
+        acc2[v] = i === 0 ? d[v] : arr[i - 1][v] + d[v];
+        return acc2;
+      }, d);
+      arr[i] = acc;
+      return acc;
+    });
   }
   toJSON() {
-    return this.subject;
+    return this.reduce((a, i) => {
+      a.push(JSON.parse(JSON.stringify(i ?? {})));
+      return a;
+    }, new Array());
   }
-};
-function text(subject, alt = "") {
-  const sub = subject ? asString(subject) : alt;
-  return new ToText(sub !== "[object Object]" ? sub : "");
-}
-function textValue(subject, prop) {
-  const p = prop.split(".");
-  const root = subject?.[p[0]];
-  const initial = typeof root === "object" && root !== null ? root : text(root);
-  return p.splice(1).reduce((t, s) => (typeof t === "object" && t !== null ? t : text(t))?.[s], initial)?.toString() ?? "";
-}
-
-// src/types/Exception.ts
-var Exception = class _Exception extends Enum {
-  constructor(message, id, reason) {
-    super(message, id ?? text(message).pascal.toString());
-    this.message = message;
-    this.reason = reason;
+  map(f, params) {
+    return toList(super.map(f, params));
   }
-  static AlreadyExists = new _Exception("Subject already exists");
-  static DoesNotExist = new _Exception("Does not exist");
-  static IsMissingId = new _Exception("Subject is missing an id");
-  static IsNotImplemented = new _Exception("Is not implemented");
-  static IsNotValid = new _Exception("Is not valid");
-  static Unknown = new _Exception("Unknown error");
-  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
-  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
-  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
-  because = (reason) => new _Exception(this.message, this.id, reason);
-};
-var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
-var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
-
-// src/validation/When.ts
-var When = class _When {
-  constructor(subject, valid = true, results) {
-    this.subject = subject;
-    this.valid = valid;
-    this.results = results;
+  flatMap(f, params) {
+    return toList(super.flatMap(f, params));
+  }
+  mapDefined(f, params) {
+    return this.map(f, params).defined();
+  }
+  mapAsync(f) {
+    return Promise.all(super.map((e) => f(e))).then((a) => toList(a));
+  }
+  mapSerial(f) {
+    return super.reduce((p, item) => p.then((results) => on(results, async (r) => r.push(await f(item)))), Promise.resolve(toList()));
   }
-  get not() {
-    return this.clone(!this.valid);
+  distinct() {
+    return this.filter((i, index) => this.indexOf(i) === index);
   }
-  get and() {
-    return this.clone(this.valid);
+  distinctByKey(key) {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
   }
-  get isDefined() {
-    return this.clone(this.valid === isDefined(this.subject));
+  distinctByValue() {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(JSON.stringify(item)) && seen.add(JSON.stringify(item)));
   }
-  get isEmpty() {
-    return this.clone(this.valid === isEmpty(this.subject));
+  filter(p, params) {
+    return toList(super.filter(p, params));
   }
-  get isTrue() {
-    return this.clone(this.valid === !!this.subject);
+  sum(p) {
+    return this.reduce((sum, i) => sum + p(i), 0);
   }
-  get isValid() {
-    this.results = validate(this.subject);
-    return this.clone(this.valid === this.results.isValid);
+  max(p) {
+    return this.desc(p).first();
   }
-  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
-  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
-  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
-  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
-  is = (item) => this.clone(this.valid === (this.subject === item));
-  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
-  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
-  clone = (result = true) => new _When(this.subject, result, this.results);
-};
-var when = (subject) => new When(subject);
-
-// src/types/Context.ts
-var DotEnvContext = class {
-  domain = process.env.DOMAIN ?? "easy";
-  name = process.env.ENVIRONMENT_NAME ?? "";
-  host = process.env.HOST ?? "";
-  port = Number.parseInt(process.env.PORT ?? "8080");
-  app = process.env.APP ?? "";
-  get = (key, alt) => {
-    const k = text(key).map((k2) => k2.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString();
-    return process.env[k] ?? alt;
-  };
-};
-var BaseRequestContext = class {
-  state = {};
-  get token() {
-    return this.get("token");
+  min(p) {
+    return this.asc(p).first();
   }
-  set token(token) {
-    this.set("token", token);
+  byId(id) {
+    return this.first((i) => equals(i.id, id));
   }
-  get identity() {
-    return this.token;
+  byKey(key, value) {
+    return this.first((i) => i[key] == value);
   }
-  get jwt() {
-    return this.get("jwt");
+  add(...items) {
+    super.push(...toArray(...items));
+    return this;
   }
-  set jwt(jwt) {
-    this.set("jwt", jwt);
+  concat(...items) {
+    return toList(super.concat(...items));
   }
-  get correlationId() {
-    return this.get("correlationId");
+  reverse() {
+    return toList(super.reverse());
   }
-  set correlationId(id) {
-    this.set("correlationId", id);
+  splice(start, deleteCount, ...items) {
+    return toList(super.splice(start, deleteCount, ...items));
   }
-  get lastError() {
-    return this.get("lastError");
+  remove(item) {
+    const index = this.indexOf(item);
+    if (index > -1) {
+      this.splice(index, 1);
+    }
+    return this;
   }
-  set lastError(error) {
-    this.set("lastError", error);
+  move(sourceId, destinationId) {
+    return this.moveOn("id", sourceId, destinationId);
   }
-  get(key) {
-    return this.state[key];
+  moveOn(key, sourceId, destinationId) {
+    const source = this.findIndex((i) => equals(i[key], sourceId));
+    const dest = this.findIndex((i) => equals(i[key], destinationId));
+    return on(toList(...this), (r) => r.splice(dest, 0, ...r.splice(source, 1)));
   }
-  set(key, value) {
-    return this.state[key] = value;
+  replace(key, item) {
+    const index = this.findIndex((i) => i[key] === item?.[key]);
+    ifTrue(index != -1, () => this.splice(index, 1, item));
+    return this;
   }
-  create = (f) => f();
-  wrap = (f) => f();
-};
-var BaseContext = class extends BaseRequestContext {
-};
-var Context = class {
-  constructor(state = {}) {
-    this.state = state;
-    this.state = {
-      ...{
-        env: new DotEnvContext(),
-        request: new BaseRequestContext(),
-        other: {}
+  switch(item) {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
+  switchOn(item, on2) {
+    return use(
+      typeof on2 === "function" ? this.find(on2) : use(traverse(item, on2), (v) => this.find((i) => traverse(i, on2) === v)),
+      (i) => i ? this.remove(i) : this.add(item)
+    );
+  }
+  defined() {
+    return this.reduce((l, v) => isDefined(v) ? l.add(v) : l, toList());
+  }
+  toObject(key, options = {}) {
+    return this.reduce((o, i) => {
+      o[i[key]] = i;
+      if (options.deleteKey)
+        delete o[i[key]][key];
+      return o;
+    }, {});
+  }
+  toObjectList(key) {
+    return this.reduce(
+      (a, t) => {
+        const k = t[key];
+        a[k] = a[k] ?? toList();
+        a[k].push(t);
+        return a;
       },
-      ...this.state
-    };
+      {}
+    );
   }
-  get env() {
-    return this.state.env;
+  orElse(...alt) {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList(...alt) : void 0;
   }
-  set env(env) {
-    this.state.env = env;
+  weave(insertFrom, interval) {
+    for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {
+      this.splice(i, 0, insertFrom[n++]);
+    }
+    return this;
   }
-  get request() {
-    return this.state.request;
+  slice(start, end) {
+    return toList(super.slice(start, end));
   }
-  set request(request) {
-    this.state.request = request;
+  none(p) {
+    return !this.some(p);
   }
-  get other() {
-    return this.state.other;
+  chunk(chunkSize) {
+    return this.reduce((acc, _, index) => index % chunkSize === 0 ? on(acc, (a) => a.push(this.slice(index, index + chunkSize))) : acc, toList());
   }
-};
-var ctx = new Context();
-
-// src/types/Result.ts
-var toResult = (message, location, domain = ctx.env.domain) => ({
-  message: message.toString(),
-  location: location?.toString(),
-  domain: domain?.toString()
-});
-var isResult = (r) => isA(r, "message");
-
-// src/types/Results.ts
-var parse = (...rs) => toArray(...rs).map((r) => isResult(r) ? r : toResult(r));
-var Results = class {
-  results;
-  constructor(...rs) {
-    this.results = parse(...rs);
+  //we needed to add U because of a Typescript issue with generics
+  update(p, val) {
+    return this.map((v, i, a) => p(v, i, a) ? ofGet(val, v, i, a) : v);
   }
-  get length() {
-    return this.results.length;
+  updateFirst(p, val) {
+    const index = this.findIndex(p);
+    return this.update((t, i) => p(t, i, this) && i == index, val);
   }
-  get isValid() {
-    return this.results.length === 0;
+  updateFirstById(id, val) {
+    return this.updateFirst((i) => equals(i?.id, id), val);
   }
-  add = (...rs) => toResults(...this.results, ...parse(...rs));
+  updateById(id, val) {
+    return this.update((i) => equals(i?.id, id), val);
+  }
+  groupBy(by) {
+    return toList(
+      Array.from(this.reduce((m, v, i, a) => use(by(v, i, a), (key) => m.set(key, (m.get(key) ?? toList()).add(v))), /* @__PURE__ */ new Map()).values())
+    );
+  }
+};
+var toList = (...items) => new List().add(...items);
+var isList = (l) => isDefined(l) && isArray(l) && isA(l, "first", "last", "asc", "desc");
+var asList = (c, items = []) => toList(toArray(items).map((i) => new c(i)));
+var maxValue = (l, key) => l.desc(key).first()?.[key];
+var minValue = (l, key) => l.asc(key).first()?.[key];
+
+// src/types/Object.ts
+function entries(subject) {
+  return ifDefined(
+    subject,
+    () => toList([...Object.entries(subject), ...Object.entries(Object.getPrototypeOf(subject) ?? {})]),
+    () => toList()
+  );
+}
+function values(subject) {
+  return toList([...Object.values(subject), ...Object.values(Object.getPrototypeOf(subject) ?? {})]);
+}
+function keys(subject) {
+  return toList([...Object.keys(subject), ...Object.keys(Object.getPrototypeOf(subject) ?? {})]);
+}
+function extractKeys(obj, keys2) {
+  return keys2.filter((k) => k in obj).reduce(
+    (acc, key) => {
+      acc.keys[key] = obj[key];
+      delete acc[key];
+      return acc;
+    },
+    { keys: {}, ...obj }
+  );
+}
+
+// src/utils/Promise.ts
+var resolve = (subject) => Promise.resolve(subject);
+var reject = (e) => Promise.reject(e);
+var tuple = {
+  2: (first, second) => Promise.all([first, second]),
+  3: (first, second, third) => Promise.all([first, second, third]),
+  4: (first, second, third, forth) => Promise.all([first, second, third, forth]),
+  5: (first, second, third, forth, fifth) => Promise.all([first, second, third, forth, fifth]),
+  all: (first, second) => Promise.all([first, Promise.all(second)]),
+  spread: (first, ...second) => Promise.all([first, Promise.all(toArray(second))]),
+  list: (list) => Promise.all([...list]).then(toList),
+  settled: (list) => Promise.allSettled([...list]).then((rs) => ({
+    fulfilled: toList(...rs.filter((r) => r.status === "fulfilled").map((r) => r.value)),
+    rejected: toList(...rs.filter((r) => r.status === "rejected").map((r) => asString(r.reason)))
+  })),
+  object: (obj) => use(keys(obj), (ks) => tuple.list(values(obj)).then((vs) => vs.reduce((acc, v, i) => on(acc, (a) => a[ks[i]] = v), {})))
 };
-var toResults = (...r) => new Results(...r);
-var isResults = (r) => isDefined(r) && r instanceof Results;
+var tuple2 = tuple[2];
+var tuple3 = tuple[3];
+var tuple4 = tuple[4];
+var tuple5 = tuple[5];
+var tupleO = tuple.object;
+var settled = tuple.settled;
 
-// src/validation/Validate.ts
-var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
-var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
-var runValidator = (v, subject) => {
-  try {
-    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property];
-    const constraint = v.constraint(actual);
-    return isResults(constraint) ? constraint : !constraint ? asResults(subject, v.text, {
-      ...v,
-      actual
-    }) : toResults();
-  } catch (e) {
-    return asResults(subject, asString(e));
+// src/types/Meta.ts
+import "reflect-metadata";
+var ClassMeta = class {
+  constructor(subject, data = (subject.prototype ?? subject).constructor) {
+    this.subject = subject;
+    this.data = data;
   }
+  get = (key) => Reflect.getMetadata(key, this.data);
+  set = (key, value) => {
+    Reflect.defineMetadata(key, value, this.data);
+    return value;
+  };
+  entries = () => entries(this.subject);
+  parse = (f, options = {}) => {
+    const { initial = {}, skipUndefined = false } = options;
+    return this.entries().reduce((a, [k, val]) => use(f(val), (v) => isDefined(v) || !skipUndefined ? on(a, (a2) => a2[k] = v) : a), initial);
+  };
+  properties = (key) => toList([...Object.getOwnPropertyNames(this.subject), ...Object.getOwnPropertyNames(Object.getPrototypeOf(this.subject))]).map((p) => this.property(p)).filter((p) => key ? p.get(key) : p);
+  keys = (key) => this.properties().map((p) => p.get(key)).reduce((list, u) => u ? list.add(u) : list, toList());
+  values = () => values(this.subject);
+  property = (property) => new PropertyMeta(this.subject, property);
 };
-var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
-var validate = (subject) => choose(subject).is.not.defined(
-  (s) => s,
-  () => toResults("Subject is not defined.")
-).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {typeof}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {typeof}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
-var validateReject = (subject) => when(subject).not.isValid.reject();
-var isValid = (t) => validate(t).isValid;
-
-// src/types/Case.ts
-var CaseBuilder = class {
-  constructor(v) {
-    this.v = v;
+var PropertyMeta = class {
+  constructor(subject, property, data = Reflect.getMetadata(property, subject)) {
+    this.subject = subject;
+    this.property = property;
+    this.data = data;
   }
-  is = {
-    true: (pred, out) => this.case(pred, out),
-    false: (pred, out) => this.case(!ofGet(pred, this.v), out),
-    truthy: (prop, out) => this.case(!!prop(this.v), out),
-    falsy: (prop, out) => this.case(!prop(this.v), out),
-    defined: (prop, out) => this.case(isDefined(prop(this.v)), out),
-    empty: (prop, out) => this.case(isEmpty(prop(this.v)), out),
-    valid: (prop, out) => this.case(validate(prop(this.v)).isValid, out),
-    in: (prop, out) => this.case(ofGet(prop, this.v).includes(this.v), out),
-    type: (guard, out) => this.type(guard, out),
-    not: {
-      true: (pred, out) => this.case(!ofGet(pred, this.v), out),
-      false: (pred, out) => this.case(pred, out),
-      truthy: (prop, out) => this.case(!prop(this.v), out),
-      falsy: (prop, out) => this.case(!!prop(this.v), out),
-      defined: (prop, out) => this.case(!isDefined(prop(this.v)), out),
-      empty: (prop, out) => this.case(!isEmpty(prop(this.v)), out),
-      valid: (prop, out) => this.case(!validate(prop(this.v)).isValid, out),
-      in: (prop, out) => this.case(!ofGet(prop, this.v).includes(this.v), out),
-      type: (guard, out) => this.case((v) => !guard(v), out)
-    }
-  };
-  if = this.is;
-  case(pred, out) {
-    return new Case(this.v).case(pred, out);
+  get value() {
+    return this.subject[this.property];
   }
-  type(guard, out) {
-    return new Case(this.v).type(guard, out);
+  get = (key) => isDefined(this.data) && isDefined(this.data[key]) ? this.data[key] : void 0;
+  set = (key, value) => {
+    Reflect.defineMetadata(this.property, { ...this.data, [key]: value }, this.subject);
+    return value;
+  };
+};
+var meta = (subject) => new ClassMeta(subject ?? {});
+
+// src/types/Enum.ts
+var isEnumConstructor = (c) => isFunction(c) && c.isEnum;
+var Enum = class {
+  constructor(name, id = name.toLowerCase(), code = id.toString()) {
+    this.name = name;
+    this.id = id;
+    this.code = code;
   }
-  equals(value, out) {
-    return new Case(this.v).equals(value, out);
+  static isEnum = true;
+  get isValid() {
+    return isDefined(this.id);
   }
-};
-var Case = class {
-  constructor(value, outcome) {
-    this.value = value;
-    this.outcome = outcome;
+  static all() {
+    return meta(this.allTuple()).values();
   }
-  is = {
-    true: (pred, out) => this.case(pred, out),
-    false: (pred, out) => this.case(!ofGet(pred, this.value), out),
-    truthy: (prop, out) => this.case(!!prop(this.value), out),
-    falsy: (prop, out) => this.case(!prop(this.value), out),
-    defined: (prop, out) => this.case(isDefined(prop(this.value)), out),
-    empty: (prop, out) => this.case(isEmpty(prop(this.value)), out),
-    valid: (prop, out) => this.case(validate(prop(this.value)).isValid, out),
-    in: (prop, out) => this.case(ofGet(prop, this.value).includes(this.value), out),
-    type: (guard, out) => this.type(guard, out),
-    not: {
-      true: (pred, out) => this.case(!ofGet(pred, this.value), out),
-      false: (pred, out) => this.case(pred, out),
-      truthy: (prop, out) => this.case(!prop(this.value), out),
-      falsy: (prop, out) => this.case(!!prop(this.value), out),
-      defined: (prop, out) => this.case(!isDefined(prop(this.value)), out),
-      empty: (prop, out) => this.case(!isEmpty(prop(this.value)), out),
-      valid: (prop, out) => this.case(!validate(prop(this.value)).isValid, out),
-      in: (prop, out) => this.case(!ofGet(prop, this.value).includes(this.value), out),
-      type: (guard, out) => this.case((v) => !guard(v), out)
-    }
-  };
-  if = this.is;
-  case(pred, out) {
-    return tryTo(pred, this.value).is.true().map(() => ofGet(out, this.value)).map((res) => new Found(this.value, res)).or(this);
+  static filter(p, params) {
+    return this.all().filter(p, params);
   }
-  type(guard, out) {
-    return tryTo(guard, this.value).is.true().map(() => out(this.value)).map((res) => new Found(this.value, res)).or(this);
+  static first(p, params) {
+    return this.all().first(p, params);
   }
-  equals(value, out) {
-    return this.case(this.value === value, out);
+  static byIds(ids = []) {
+    return toList(ids).mapDefined((id) => this.byId(id)).distinct();
   }
-  else(alt) {
-    return ofGet(alt, this.value);
+  static byId(id, alt) {
+    return this.allTuple()[id] ?? ofGet(alt);
   }
-};
-var Found = class extends Case {
-  constructor(value, outcome) {
-    super(value, outcome);
-    this.value = value;
-    this.outcome = outcome;
+  static allTuple() {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
   }
-  case(pred, out) {
-    return this;
+  equals(other) {
+    return this.id === (isEnum(other) ? other.id : other);
   }
-  type(guard, out) {
-    return this;
+  isIn(...items) {
+    return items.some((i) => this.equals(i));
   }
-  equals(value, out) {
-    return this;
+  toJSON() {
+    return this.id;
   }
-  else(alt) {
-    return this.outcome;
+  toString() {
+    return this.id.toString();
   }
 };
-var choose = (value) => new CaseBuilder(value);
-
-// src/types/IsEqual.ts
-var isEqualArray = (one, another) => choose([one, another]).case(([o, a]) => !isArray(o) || !isArray(a), false).case(([o, a]) => o?.length !== a?.length, false).else(([o, a]) => !o.some((v, i) => !isEqual(v, a[i])));
-var isEqualObject = (one, another) => choose([Object.keys(one), Object.keys(another)]).case(([keysO, keysA]) => keysO.length !== keysA.length, false).case(([keysO, keysA]) => keysO.some((k) => !keysA.includes(k)), false).case(([keysO]) => keysO.some((k) => !isEqual(one[k], another[k])), false).else(true);
-var isEqual = (one, another) => choose([one, another]).case(([o, a]) => o === a, true).case(
-  ([o, a]) => isArray(o) || isArray(a),
-  ([o, a]) => isEqualArray(o, a)
-).case(
-  ([o, a]) => o == null || a == null || !isObject(o) && !isObject(a),
-  ([o, a]) => o !== o && a !== a
-).else(([o, a]) => isEqualObject(o, a));
+var isEnum = (e) => isDefined(e) && e instanceof Enum && isAn(e, "name", "id", "code");
 
-// src/utils/If.ts
-function ifTrue(o, f, alt) {
-  return isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
-}
-function ifFalse(o, f, alt) {
-  return !isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
-}
-function ifDefined(o, f, alt) {
-  return isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
-}
-function ifNotEmpty(o, f = (o2) => o2, alt) {
-  return isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
-}
-function ifEqual(one, another, f, alt) {
-  return isEqual(one, another) ? ofConstruct(f) : ofConstruct(alt);
-}
-function ifEither(os, f = (o) => o, alt) {
-  return use(
-    toList(os).first((o) => isPresent(o)),
-    (o) => isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt, o)
-  );
+// src/types/Template.ts
+var Template = class {
+  constructor(template2, subject = {}, options = {}) {
+    this.template = template2;
+    this.subject = subject;
+    this.options = options;
+  }
+  knownPrefixes = /* @__PURE__ */ new Set(["typeof", "property", "actual", "subject"]);
+  toString = () => {
+    return entries(this.options).reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
+  };
+  props = (tmpl, key, result = toList()) => {
+    const i1 = tmpl.indexOf(`{${key}`);
+    if (i1 < 0) {
+      return result;
+    }
+    const i2 = tmpl.indexOf("}", i1);
+    return this.props(tmpl.slice(i2 + 1), key, result.add(tmpl.substring(i1 + 1, i2)));
+  };
+  object = () => tryTo(() => this.template.replace(/\{this\./g, "{")).map((t) => t.replace(/\{([^{}]+)}/g, (match, p) => this.knownPrefixes.has(p.split(".")[0]) ? match : textValue(this.subject, p))).or("");
+  option = (tmpl, prop) => {
+    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, textValue(this.options, p)), tmpl);
+  };
+};
+function template(tmpl, subject, options = {}) {
+  return new Template(asString(tmpl), subject, {
+    typeof: toName(subject),
+    subject: text(JSON.stringify(subject)),
+    ...options
+  });
 }
 
-// src/types/List.ts
-var List8 = class extends Array {
-  get ids() {
-    return this.mapDefined((i) => i.id);
+// src/types/ToText.ts
+var ToText = class {
+  constructor(subject) {
+    this.subject = subject;
+  }
+  get cap() {
+    return this.map((s) => capitalize(s?.toLowerCase()));
+  }
+  get capFirst() {
+    return this.map((s) => capitalize(s));
   }
-  get indexed() {
-    return this.map((v, index) => ({ ...v, index }));
+  get title() {
+    return this.map(
+      (s) => s.split(" ").map((w) => text(w).cap).join(" ")
+    );
   }
-  isSubSetOf(...items) {
-    return this.diff(items).length === 0;
+  get pascal() {
+    return this.title.replace(" ", "");
   }
-  isSuperSetOf(...items) {
-    return this.length > items.length && toList(...items).isSubSetOf(...this);
+  get lower() {
+    return this.map((s) => s.toLowerCase());
   }
-  isIntersectingWith(...items) {
-    return this.intersect(items).length > 0;
+  get upper() {
+    return this.map((s) => s.toUpperCase());
   }
-  isDisjointWith(...items) {
-    return !this.isIntersectingWith(...items);
+  get camel() {
+    return this.title.trim.map((s) => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
   }
-  areEqual(...items) {
-    return this.isSubSetOf(...items) && toList(...items).isSubSetOf(...this);
+  get kebab() {
+    return this.lower.replace(" ", "-");
   }
-  asc(p) {
-    return toList(...this).sort((e1, e2) => ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1);
+  get strictKebab() {
+    return this.map((s) => s.replace(/[^a-z\d]+/gi, " ").trim()).kebab;
   }
-  desc(p) {
-    return toList(...this).sort((e1, e2) => ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1);
+  get slug() {
+    return this.map(
+      (s) => s.replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z\d]+/g, "-").replace(/(^-)|(-$)/g, "")
+    );
   }
-  first(p, params) {
-    return p ? this.find(p, params) : this[0];
+  get snake() {
+    return this.upper.replace(" ", "_");
   }
-  firstValue(f, alt) {
-    return ifDefined(
-      this.first((t) => !!f(t)),
-      f,
-      (v) => ofGet(alt, v)
+  get plural() {
+    return this.ifLike("") ?? this.add("s");
+  }
+  get space() {
+    return this.map((s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " "));
+  }
+  get sentence() {
+    return this.isEmpty ? this : this.map((s) => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
+  }
+  get initials() {
+    return this.map(
+      (s) => s.split(" ").map((w) => w[0]).join("")
     );
   }
-  isFirst(value) {
-    return value === this.first();
+  get trim() {
+    return this.map((s) => s.replace(/[- ,_#]/g, ""));
   }
-  next(p, params) {
-    return p ? this[this.findIndex(p, params) + 1] : this[0];
+  get trimSentence() {
+    return this.map(
+      (s) => s.replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\s\u00A0]+/g, " ").replace(/\s+([.,;:!?])/g, "$1").trim()
+    );
   }
-  prev(p, params) {
-    return p ? this[this.findIndex(p, params) - 1] : this[0];
+  get isEmpty() {
+    return isEmpty(this.toString());
   }
-  last(p, params) {
-    return p ? this.filter(p, params).last() : this[this.length - 1];
+  parse = (subject, options = {}) => text(template(this.subject, subject, { typeof: toName(subject), ...options }));
+  is = (...others) => others.some((o) => this.toString() === text(o).toString());
+  equals = this.is;
+  like = (...others) => others.some((o) => this.trim.lower.toString().includes(text(o).trim.lower.toString()));
+  isLike = (...others) => others.some((o) => this.trim.lower.is(text(o).trim.lower));
+  ifLike = (...others) => this.isLike(...others) ? this : void 0;
+  endsWith = (end) => this.subject.endsWith(asString(end));
+  startsWith = (end) => this.subject.startsWith(asString(end));
+  first = (n) => this.map((s) => s.substring(0, n));
+  last = (n) => this.map((s) => s.substring(s.length - n));
+  map = (func) => text(ofGet(func, this.subject));
+  replace = (search, replace) => this.map((s) => replaceAll(s, search, replace));
+  add = (add, separator = "") => this.map((s) => isNotEmpty(add) ? `${s}${separator}${text(add)}` : s);
+  with = (separator, ...other) => this.map(
+    (s) => toList(s).add(...other.map((u) => text(u).toString())).filter((s2) => isNotEmpty(s2)).join(separator)
+  );
+  split = (separator = " ") => toList(this.subject.split(separator));
+  toString() {
+    return this.subject;
   }
-  isLast(value) {
-    return value === this.last();
+  toJSON() {
+    return this.subject;
   }
-  overlaps(...items) {
-    return toList(...items).some((i) => this.some((t) => i === t));
+};
+function text(subject, alt = "") {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText(sub !== "[object Object]" ? sub : "");
+}
+function textValue(subject, prop) {
+  const p = prop.split(".");
+  const root = subject?.[p[0]];
+  const initial = typeof root === "object" && root !== null ? root : text(root);
+  return p.splice(1).reduce((t, s) => (typeof t === "object" && t !== null ? t : text(t))?.[s], initial)?.toString() ?? "";
+}
+
+// src/types/Exception.ts
+var Exception = class _Exception extends Enum {
+  constructor(message, id, reason) {
+    super(message, id ?? text(message).pascal.toString());
+    this.message = message;
+    this.reason = reason;
   }
-  diff(others) {
-    return this.filter((i) => !others.includes(i));
+  static AlreadyExists = new _Exception("Subject already exists");
+  static DoesNotExist = new _Exception("Does not exist");
+  static IsMissingId = new _Exception("Subject is missing an id");
+  static IsNotImplemented = new _Exception("Is not implemented");
+  static IsNotValid = new _Exception("Is not valid");
+  static Unknown = new _Exception("Unknown error");
+  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
+  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
+  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
+  because = (reason) => new _Exception(this.message, this.id, reason);
+};
+var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
+var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
+
+// src/validation/When.ts
+var When = class _When {
+  constructor(subject, valid = true, results) {
+    this.subject = subject;
+    this.valid = valid;
+    this.results = results;
   }
-  diffByKey(others, key) {
-    return this.filter((i) => !others.some((o) => o[key] === i[key]));
+  get not() {
+    return this.clone(!this.valid);
   }
-  symmetricDiff(others) {
-    return this.diff(others).concat(toList(...others).diff(this));
+  get and() {
+    return this.clone(this.valid);
   }
-  symmetricDiffByKey(others, key) {
-    return this.diffByKey(others, key).concat(toList(...others).diffByKey(this, key));
+  get isDefined() {
+    return this.clone(this.valid === isDefined(this.subject));
   }
-  intersect(others) {
-    return this.filter((i) => others.includes(i));
+  get isEmpty() {
+    return this.clone(this.valid === isEmpty(this.subject));
   }
-  intersectByKey(others, key) {
-    return this.filter((i) => others.some((o) => o[key] === i[key]));
+  get isTrue() {
+    return this.clone(this.valid === !!this.subject);
   }
-  intersectBy(others, f) {
-    return this.filter((i) => others.some((o) => f(i, o)));
+  get isValid() {
+    this.results = validate(this.subject);
+    return this.clone(this.valid === this.results.isValid);
   }
-  accumulate(...keys2) {
-    return this.map((d, i, arr) => {
-      const acc = keys2.reduce((acc2, v) => {
-        acc2[v] = i === 0 ? d[v] : arr[i - 1][v] + d[v];
-        return acc2;
-      }, d);
-      arr[i] = acc;
-      return acc;
-    });
+  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
+  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
+  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
+  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
+  is = (item) => this.clone(this.valid === (this.subject === item));
+  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
+  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
+  clone = (result = true) => new _When(this.subject, result, this.results);
+};
+var when = (subject) => new When(subject);
+
+// src/types/Context.ts
+var DotEnvContext = class {
+  domain = process.env.DOMAIN ?? "easy";
+  name = process.env.ENVIRONMENT_NAME ?? "";
+  host = process.env.HOST ?? "";
+  port = Number.parseInt(process.env.PORT ?? "8080");
+  app = process.env.APP ?? "";
+  get = (key, alt) => {
+    const k = text(key).map((k2) => k2.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString();
+    return process.env[k] ?? alt;
+  };
+};
+var BaseRequestContext = class {
+  state = {};
+  get token() {
+    return this.get("token");
   }
-  toJSON() {
-    return this.reduce((a, i) => {
-      a.push(JSON.parse(JSON.stringify(i ?? {})));
-      return a;
-    }, new Array());
+  set token(token) {
+    this.set("token", token);
   }
-  map(f, params) {
-    return toList(super.map(f, params));
+  get identity() {
+    return this.token;
   }
-  flatMap(f, params) {
-    return toList(super.flatMap(f, params));
+  get jwt() {
+    return this.get("jwt");
   }
-  mapDefined(f, params) {
-    return this.map(f, params).defined();
+  set jwt(jwt) {
+    this.set("jwt", jwt);
   }
-  mapAsync(f) {
-    return Promise.all(super.map((e) => f(e))).then((a) => toList(a));
+  get correlationId() {
+    return this.get("correlationId");
   }
-  mapSerial(f) {
-    return super.reduce((p, item) => p.then((results) => on(results, async (r) => r.push(await f(item)))), Promise.resolve(toList()));
+  set correlationId(id) {
+    this.set("correlationId", id);
   }
-  distinct() {
-    return this.filter((i, index) => this.indexOf(i) === index);
+  get lastError() {
+    return this.get("lastError");
   }
-  distinctByKey(key) {
-    const seen = /* @__PURE__ */ new Set();
-    return this.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
+  set lastError(error) {
+    this.set("lastError", error);
+  }
+  get(key) {
+    return this.state[key];
+  }
+  set(key, value) {
+    return this.state[key] = value;
+  }
+  create = (f) => f();
+  wrap = (f) => f();
+};
+var BaseContext = class extends BaseRequestContext {
+};
+var Context = class {
+  constructor(state = {}) {
+    this.state = state;
+    this.state = {
+      ...{
+        env: new DotEnvContext(),
+        request: new BaseRequestContext(),
+        other: {}
+      },
+      ...this.state
+    };
   }
-  distinctByValue() {
-    const seen = /* @__PURE__ */ new Set();
-    return this.filter((item) => !seen.has(JSON.stringify(item)) && seen.add(JSON.stringify(item)));
+  get env() {
+    return this.state.env;
   }
-  filter(p, params) {
-    return toList(super.filter(p, params));
+  set env(env) {
+    this.state.env = env;
   }
-  sum(p) {
-    return this.reduce((sum, i) => sum + p(i), 0);
+  get request() {
+    return this.state.request;
   }
-  max(p) {
-    return this.desc(p).first();
+  set request(request) {
+    this.state.request = request;
   }
-  min(p) {
-    return this.asc(p).first();
+  get other() {
+    return this.state.other;
   }
-  byId(id) {
-    return this.first((i) => equals(i.id, id));
+};
+var ctx = new Context();
+
+// src/types/Result.ts
+var toResult = (message, location, domain = ctx.env.domain) => ({
+  message: message.toString(),
+  location: location?.toString(),
+  domain: domain?.toString()
+});
+var isResult = (r) => isA(r, "message");
+
+// src/types/Results.ts
+var parse = (...rs) => toArray(...rs).map((r) => isResult(r) ? r : toResult(r));
+var Results = class {
+  results;
+  constructor(...rs) {
+    this.results = parse(...rs);
   }
-  byKey(key, value) {
-    return this.first((i) => i[key] == value);
+  get length() {
+    return this.results.length;
   }
-  add(...items) {
-    super.push(...toArray(...items));
-    return this;
+  get isValid() {
+    return this.results.length === 0;
   }
-  concat(...items) {
-    return toList(super.concat(...items));
+  add = (...rs) => toResults(...this.results, ...parse(...rs));
+};
+var toResults = (...r) => new Results(...r);
+var isResults = (r) => isDefined(r) && r instanceof Results;
+
+// src/validation/Validate.ts
+var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
+var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
+var runValidator = (v, subject) => {
+  try {
+    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property];
+    const constraint = v.constraint(actual);
+    return isResults(constraint) ? constraint : !constraint ? asResults(subject, v.text, {
+      ...v,
+      actual
+    }) : toResults();
+  } catch (e) {
+    return asResults(subject, asString(e));
   }
-  reverse() {
-    return toList(super.reverse());
+};
+var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
+var validate = (subject) => choose(subject).is.not.defined(
+  (s) => s,
+  () => toResults("Subject is not defined.")
+).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {typeof}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {typeof}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
+var validateReject = (subject) => when(subject).not.isValid.reject();
+var isValid = (t) => validate(t).isValid;
+
+// src/types/Try.ts
+var Try = class _Try {
+  is = {
+    defined: (prop) => this.filter((v) => isDefined(prop ? prop(v) : v)),
+    empty: (prop) => this.filter((v) => isEmpty(prop ? prop(v) : v)),
+    valid: (prop) => this.filter((v) => validate(prop ? prop(v) : v).isValid),
+    true: (prop) => this.filter((v) => isTrue(prop ? prop(v) : v)),
+    false: (prop) => this.filter((v) => !isTrue(prop ? prop(v) : v)),
+    not: {
+      defined: (prop) => this.filter((v) => !isDefined(prop ? prop(v) : v)),
+      empty: (prop) => this.filter((v) => !isEmpty(prop ? prop(v) : v)),
+      valid: (prop) => this.filter((v) => !validate(prop ? prop(v) : v).isValid)
+    }
+  };
+  if = this.is;
+  static of = (c, ...args) => {
+    try {
+      const out = ofGet(c, ...args);
+      return new Success(out instanceof _Try ? out.value : out);
+    } catch (e) {
+      return new Failure(e);
+    }
+  };
+};
+var Success = class extends Try {
+  constructor(value) {
+    super();
+    this.value = value;
   }
-  splice(start, deleteCount, ...items) {
-    return toList(super.splice(start, deleteCount, ...items));
+  get error() {
+    throw new Error("No error found");
   }
-  remove(item) {
-    const index = this.indexOf(item);
-    if (index > -1) {
-      this.splice(index, 1);
-    }
-    return this;
+  get isValid() {
+    return true;
   }
-  move(sourceId, destinationId) {
-    return this.moveOn("id", sourceId, destinationId);
+  map(f) {
+    return tryTo(f, this.value);
   }
-  moveOn(key, sourceId, destinationId) {
-    const source = this.findIndex((i) => equals(i[key], sourceId));
-    const dest = this.findIndex((i) => equals(i[key], destinationId));
-    return on(toList(...this), (r) => r.splice(dest, 0, ...r.splice(source, 1)));
+  recover(f) {
+    return this;
   }
-  replace(key, item) {
-    const index = this.findIndex((i) => i[key] === item?.[key]);
-    ifTrue(index != -1, () => this.splice(index, 1, item));
+  recoverFrom(type, f) {
     return this;
   }
-  switch(item) {
-    return this.includes(item) ? this.remove(item) : this.add(item);
+  accept(f) {
+    return tryTo(() => {
+      f(this.value);
+      return this;
+    });
   }
-  switchOn(item, on2) {
-    return use(
-      typeof on2 === "function" ? this.find(on2) : use(traverse(item, on2), (v) => this.find((i) => traverse(i, on2) === v)),
-      (i) => i ? this.remove(i) : this.add(item)
-    );
+  filter(predicate) {
+    return tryTo(() => {
+      if (predicate(this.value))
+        return this;
+      throw new Error(`Applying filter(${predicate.toString()}) failed.`);
+    });
   }
-  defined() {
-    return this.reduce((l, v) => isDefined(v) ? l.add(v) : l, toList());
+  or(value) {
+    return this.value;
   }
-  toObject(key, options = {}) {
-    return this.reduce((o, i) => {
-      o[i[key]] = i;
-      if (options.deleteKey)
-        delete o[i[key]][key];
-      return o;
-    }, {});
+  orElse(value) {
+    return this.value;
   }
-  toObjectList(key) {
-    return this.reduce(
-      (a, t) => {
-        const k = t[key];
-        a[k] = a[k] ?? toList();
-        a[k].push(t);
-        return a;
-      },
-      {}
-    );
+  orThrow(_error) {
+    return this.value;
   }
-  orElse(...alt) {
-    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList(...alt) : void 0;
+};
+var Failure = class _Failure extends Try {
+  constructor(error) {
+    super();
+    this.error = error;
   }
-  weave(insertFrom, interval) {
-    for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {
-      this.splice(i, 0, insertFrom[n++]);
-    }
-    return this;
+  get value() {
+    throw this.error;
   }
-  slice(start, end) {
-    return toList(super.slice(start, end));
+  get isValid() {
+    return false;
   }
-  none(p) {
-    return !this.some(p);
+  map(f) {
+    return new _Failure(this.error);
   }
-  chunk(chunkSize) {
-    return this.reduce((acc, _, index) => index % chunkSize === 0 ? on(acc, (a) => a.push(this.slice(index, index + chunkSize))) : acc, toList());
+  recover(f) {
+    return tryTo(f, this.error);
   }
-  //we needed to add U because of a Typescript issue with generics
-  update(p, val) {
-    return this.map((v, i, a) => p(v, i, a) ? ofGet(val, v, i, a) : v);
+  recoverFrom(type, f) {
+    return tryTo(() => this.error instanceof type ? this.recover(f) : this);
   }
-  updateFirst(p, val) {
-    const index = this.findIndex(p);
-    return this.update((t, i) => p(t, i, this) && i == index, val);
+  accept(f) {
+    return this;
   }
-  updateFirstById(id, val) {
-    return this.updateFirst((i) => equals(i?.id, id), val);
+  filter(predicate) {
+    return this;
   }
-  updateById(id, val) {
-    return this.update((i) => equals(i?.id, id), val);
+  or(value) {
+    return ofGet(value);
   }
-  groupBy(by) {
-    return toList(
-      Array.from(this.reduce((m, v, i, a) => use(by(v, i, a), (key) => m.set(key, (m.get(key) ?? toList()).add(v))), /* @__PURE__ */ new Map()).values())
-    );
+  orElse(value) {
+    return ofGet(value);
+  }
+  orThrow(error) {
+    throw ofConstruct(error);
   }
 };
-var toList = (...items) => new List8().add(...items);
-var isList = (l) => isDefined(l) && isArray(l) && isA(l, "first", "last", "asc", "desc");
-var asList = (c, items = []) => toList(toArray(items).map((i) => new c(i)));
-var maxValue = (l, key) => l.desc(key).first()?.[key];
-var minValue = (l, key) => l.asc(key).first()?.[key];
+var tryTo = (c, ...args) => Try.of(c, ...args);
 
 export {
-  List8 as List,
+  Try,
+  tryTo,
+  choose,
+  isEqual,
+  ifTrue,
+  ifFalse,
+  ifDefined,
+  ifNotEmpty,
+  ifEqual,
+  ifEither,
+  List,
   toList,
   isList,
   asList,
@@ -1007,8 +1017,6 @@ export {
   isEnumConstructor,
   Enum,
   isEnum,
-  Try,
-  tryTo,
   Template,
   template,
   ToText,
@@ -1032,14 +1040,6 @@ export {
   asResults,
   validate,
   validateReject,
-  isValid,
-  choose,
-  isEqual,
-  ifTrue,
-  ifFalse,
-  ifDefined,
-  ifNotEmpty,
-  ifEqual,
-  ifEither
+  isValid
 };
-//# sourceMappingURL=chunk-AVHYDITZ.mjs.map
+//# sourceMappingURL=chunk-BS5KUNX2.mjs.map