functype 0.8.62 → 0.8.63

package/dist/option/index.mjs

@@ -1,7 +1,2 @@
-import { N as e, O as s, S as m } from "../index-CgMYHgdG.mjs";
-export {
-  e as None,
-  s as Option,
-  m as Some
-};
-//# sourceMappingURL=index.mjs.map
+export{e as None,f as Option,d as Some}from'../chunk-3DIRMZSK.mjs';import'../chunk-PXFJPCM7.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/option/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/set/index.d.ts

@@ -1,2 +1,3 @@
-export * from './Set';
-export * from './shim';
+export { S as Set } from '../option/index.js';
+import '../Tuple-DfdXAbL_.js';
+import '../branded/index.js';

package/dist/set/index.mjs

@@ -1,5 +1,2 @@
-import { f as o } from "../index-CgMYHgdG.mjs";
-export {
-  o as Set
-};
-//# sourceMappingURL=index.mjs.map
+export{g as Set}from'../chunk-3DIRMZSK.mjs';import'../chunk-PXFJPCM7.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/set/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/try/index.d.ts

@@ -1 +1,3 @@
-export * from './Try';
+export { h as Try } from '../option/index.js';
+import '../Tuple-DfdXAbL_.js';
+import '../branded/index.js';

package/dist/try/index.mjs

@@ -1,44 +1,2 @@
-import { k as e, R as o, L as i } from "../index-CgMYHgdG.mjs";
-const a = (t) => ({
-  _tag: "Success",
-  error: void 0,
-  isSuccess: () => !0,
-  isFailure: () => !1,
-  get: () => t,
-  getOrElse: (r) => t,
-  orElse: (r) => a(t),
-  orThrow: (r) => t,
-  toEither: () => o(t),
-  map: (r) => c(() => r(t)),
-  flatMap: (r) => r(t),
-  toString: () => `Success(${e(t)})`,
-  toValue: () => ({ _tag: "Success", value: t })
-}), s = (t) => ({
-  _tag: "Failure",
-  error: t,
-  isSuccess: () => !1,
-  isFailure: () => !0,
-  get: () => {
-    throw t;
-  },
-  getOrElse: (r) => r,
-  orElse: (r) => r,
-  orThrow: (r) => {
-    throw r;
-  },
-  toEither: () => i(t),
-  map: (r) => s(t),
-  flatMap: (r) => s(t),
-  toString: () => `Failure(${e(t)}))`,
-  toValue: () => ({ _tag: "Failure", value: t })
-}), c = (t) => {
-  try {
-    return a(t());
-  } catch (r) {
-    return s(r instanceof Error ? r : new Error(String(r)));
-  }
-};
-export {
-  c as Try
-};
-//# sourceMappingURL=index.mjs.map
+export{w as Try}from'../chunk-3DIRMZSK.mjs';import'../chunk-PXFJPCM7.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/try/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../src/try/Try.ts"],"sourcesContent":["import stringify from \"safe-stable-stringify\"\n\nimport { Either, Left, Right } from \"@/either/Either\"\nimport { Typeable } from \"@/typeable/Typeable\"\nimport { Valuable } from \"@/valuable/Valuable\"\n\ntype TypeNames = \"Success\" | \"Failure\"\n\nexport type Try<T> = {\n  readonly _tag: TypeNames\n  readonly error: Error | undefined\n  isSuccess: () => boolean\n  isFailure: () => boolean\n  get: () => T\n  getOrElse: (defaultValue: T) => T\n  orElse: (alternative: Try<T>) => Try<T>\n  orThrow: (error: Error) => T\n  toEither: () => Either<Error, T>\n  map: <U>(f: (value: T) => U) => Try<U>\n  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>\n  toString: () => string\n} & Typeable<TypeNames> &\n  Valuable<TypeNames, T | Error>\n\nconst Success = <T>(value: T): Try<T> => ({\n  _tag: \"Success\",\n  error: undefined,\n  isSuccess: () => true,\n  isFailure: () => false,\n  get: () => value,\n  getOrElse: (_defaultValue: T) => value,\n  orElse: (_alternative: Try<T>) => Success(value),\n  orThrow: (_error: Error) => value,\n  toEither: () => Right<Error, T>(value),\n  map: <U>(f: (value: T) => U) => Try(() => f(value)),\n  flatMap: <U>(f: (value: T) => Try<U>) => f(value),\n  toString: () => `Success(${stringify(value)})`,\n  toValue: () => ({ _tag: \"Success\", value }),\n})\n\nconst Failure = <T>(error: Error): Try<T> => ({\n  _tag: \"Failure\",\n  error,\n  isSuccess: () => false,\n  isFailure: () => true,\n  get: () => {\n    throw error\n  },\n  getOrElse: (defaultValue: T) => defaultValue,\n  orElse: (alternative: Try<T>) => alternative,\n  orThrow: (error: Error) => {\n    throw error\n  },\n  toEither: () => Left<Error, T>(error),\n  map: <U>(_f: (value: T) => U) => Failure<U>(error),\n  flatMap: <U>(_f: (value: T) => Try<U>) => Failure<U>(error),\n  toString: () => `Failure(${stringify(error)}))`,\n  toValue: () => ({ _tag: \"Failure\", value: error }),\n})\n\nexport const Try = <T>(f: () => T): Try<T> => {\n  try {\n    return Success(f())\n  } catch (error) {\n    return Failure(error instanceof Error ? error : new Error(String(error)))\n  }\n}\n"],"names":["Success","value","_defaultValue","_alternative","_error","Right","f","Try","stringify","Failure","error","defaultValue","alternative","Left","_f"],"mappings":";AAwBA,MAAMA,IAAU,CAAIC,OAAsB;AAAA,EACxC,MAAM;AAAA,EACN,OAAO;AAAA,EACP,WAAW,MAAM;AAAA,EACjB,WAAW,MAAM;AAAA,EACjB,KAAK,MAAMA;AAAA,EACX,WAAW,CAACC,MAAqBD;AAAA,EACjC,QAAQ,CAACE,MAAyBH,EAAQC,CAAK;AAAA,EAC/C,SAAS,CAACG,MAAkBH;AAAA,EAC5B,UAAU,MAAMI,EAAgBJ,CAAK;AAAA,EACrC,KAAK,CAAIK,MAAuBC,EAAI,MAAMD,EAAEL,CAAK,CAAC;AAAA,EAClD,SAAS,CAAIK,MAA4BA,EAAEL,CAAK;AAAA,EAChD,UAAU,MAAM,WAAWO,EAAUP,CAAK,CAAC;AAAA,EAC3C,SAAS,OAAO,EAAE,MAAM,WAAW,OAAAA,EAAM;AAC3C,IAEMQ,IAAU,CAAIC,OAA0B;AAAA,EAC5C,MAAM;AAAA,EACN,OAAAA;AAAA,EACA,WAAW,MAAM;AAAA,EACjB,WAAW,MAAM;AAAA,EACjB,KAAK,MAAM;AACH,UAAAA;AAAA,EACR;AAAA,EACA,WAAW,CAACC,MAAoBA;AAAA,EAChC,QAAQ,CAACC,MAAwBA;AAAA,EACjC,SAAS,CAACF,MAAiB;AACnBA,UAAAA;AAAAA,EACR;AAAA,EACA,UAAU,MAAMG,EAAeH,CAAK;AAAA,EACpC,KAAK,CAAII,MAAwBL,EAAWC,CAAK;AAAA,EACjD,SAAS,CAAII,MAA6BL,EAAWC,CAAK;AAAA,EAC1D,UAAU,MAAM,WAAWF,EAAUE,CAAK,CAAC;AAAA,EAC3C,SAAS,OAAO,EAAE,MAAM,WAAW,OAAOA,EAAM;AAClD,IAEaH,IAAM,CAAID,MAAuB;AACxC,MAAA;AACK,WAAAN,EAAQM,GAAG;AAAA,WACXI,GAAO;AACP,WAAAD,EAAQC,aAAiB,QAAQA,IAAQ,IAAI,MAAM,OAAOA,CAAK,CAAC,CAAC;AAAA,EAAA;AAE5E;"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/tuple/index.d.ts

@@ -1 +1 @@
-export * from './Tuple';
+export { b as Tuple } from '../Tuple-DfdXAbL_.js';

package/dist/tuple/index.mjs

@@ -1,27 +1,2 @@
-const n = (t) => ({
-  _tag: "Tuple",
-  map: (e) => {
-    const r = e(t);
-    return n(r);
-  },
-  flatMap: (e) => e(t),
-  get: (e) => t[e],
-  toArray: () => t,
-  [Symbol.iterator]() {
-    let e = 0;
-    return {
-      next: () => e < t.length ? {
-        value: t[e++],
-        done: !1
-      } : {
-        value: void 0,
-        done: !0
-      }
-    };
-  },
-  toValue: () => ({ _tag: "Tuple", value: t })
-});
-export {
-  n as Tuple
-};
-//# sourceMappingURL=index.mjs.map
+export{c as Tuple}from'../chunk-PXFJPCM7.mjs';//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/tuple/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../src/tuple/Tuple.ts"],"sourcesContent":["import type { ArrayFunctor, ArrayType } from \"@/functor\"\nimport { Typeable } from \"@/typeable/Typeable\"\nimport { Valuable } from \"@/valuable/Valuable\"\n\nexport type Tuple<T extends ArrayType> = {\n  get<K extends number>(index: K): T[K]\n\n  map<U extends ArrayType>(f: (value: T) => U): Tuple<U>\n\n  flatMap<U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U>\n\n  toArray(): T\n\n  [Symbol.iterator](): Iterator<T[number]>\n} & ArrayFunctor<T> &\n  Typeable<\"Tuple\"> &\n  Valuable<\"Tuple\", T>\n\nexport const Tuple = <T extends ArrayType>(values: T): Tuple<T> => {\n  return {\n    _tag: \"Tuple\",\n    map: <U extends ArrayType>(f: (value: T) => U): Tuple<U> => {\n      const mapValue = f(values)\n      return Tuple(mapValue)\n    },\n\n    flatMap: <U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U> => {\n      return f(values)\n    },\n\n    get: <K extends number>(index: K): T[K] => {\n      return values[index]\n    },\n\n    toArray: (): T => {\n      return values\n    },\n    [Symbol.iterator](): Iterator<T[number]> {\n      let index = 0\n      return {\n        next: (): IteratorResult<T[number]> => {\n          if (index < values.length) {\n            return {\n              value: values[index++],\n              done: false,\n            }\n          } else {\n            return {\n              value: undefined,\n              done: true,\n            }\n          }\n        },\n      }\n    },\n    toValue: () => ({ _tag: \"Tuple\", value: values }),\n  }\n}\n"],"names":["Tuple","values","f","mapValue","index"],"mappings":"AAkBa,MAAAA,IAAQ,CAAsBC,OAClC;AAAA,EACL,MAAM;AAAA,EACN,KAAK,CAAsBC,MAAiC;AACpD,UAAAC,IAAWD,EAAED,CAAM;AACzB,WAAOD,EAAMG,CAAQ;AAAA,EACvB;AAAA,EAEA,SAAS,CAAsBD,MACtBA,EAAED,CAAM;AAAA,EAGjB,KAAK,CAAmBG,MACfH,EAAOG,CAAK;AAAA,EAGrB,SAAS,MACAH;AAAA,EAET,CAAC,OAAO,QAAQ,IAAyB;AACvC,QAAIG,IAAQ;AACL,WAAA;AAAA,MACL,MAAM,MACAA,IAAQH,EAAO,SACV;AAAA,QACL,OAAOA,EAAOG,GAAO;AAAA,QACrB,MAAM;AAAA,MACR,IAEO;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,MACR;AAAA,IAGN;AAAA,EACF;AAAA,EACA,SAAS,OAAO,EAAE,MAAM,SAAS,OAAOH,EAAO;AACjD;"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.8.62",
+  "version": "0.8.63",
   "type": "module",
   "description": "A smallish functional library for TypeScript",
   "author": "jordan.burke@gmail.com",
@@ -31,11 +31,10 @@
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
     "typedoc": "^0.28.2",
     "typescript": "5.8.3",
-    "vitest": "^3.1.1",
-    "vite": "^6.2.6",
-    "vite-plugin-dts": "^4.5.3"
+    "vitest": "^3.1.1"
   },
   "types": "./dist/index.d.ts",
   "module": "./dist/index.mjs",
@@ -117,9 +116,9 @@
   "scripts": {
     "compile": "tsc --noEmit",
     "build": "pnpm compile && pnpm lint && pnpm test",
-    "build:dev": "vite build --watch --mode development",
-    "build:prod": "pnpm compile && pnpm test && vite build --mode production",
-    "build:watch": "vite build --watch",
+    "build:dev": "tsup --watch",
+    "build:prod": "pnpm compile && pnpm test && cross-env NODE_ENV=production tsup",
+    "build:watch": "tsup --watch",
     "build:publish": "pnpm build:prod && pnpm publish --access public",
     "lint:fix": "eslint ./src --quiet --fix",
     "lint:format": "prettier --loglevel warn --write \"./**/*.{ts,tsx,css,md,json}\" ",

package/dist/Map-BNxKlujn.mjs

@@ -1,46 +0,0 @@
-import { f as h, e as n, O as c } from "./index-CgMYHgdG.mjs";
-import { Tuple as w } from "./tuple/index.mjs";
-const l = Map, r = (a) => {
-  const i = "Map", s = {
-    values: new l(a)
-  }, o = () => Array.from(s.values.entries()).map(([t, e]) => w([t, e])), u = (t) => r(new l(s.values).set(t.toArray()[0], t.toArray()[1]).entries()), p = (t) => {
-    const e = new l(s.values);
-    return e.delete(t) ? r(e.entries()) : r(s.values.entries());
-  }, g = (t) => {
-    const e = t.toArray();
-    return s.values.get(e[0]) === e[1];
-  }, v = () => s.values.size, f = (t) => r(Array.from(s.values.entries()).map(([e, O]) => [e, t(O)])), d = (t) => {
-    const e = r(s.values.entries()).toList();
-    return r(e.flatMap(t).toArray());
-  }, m = (t) => n(o()).reduce(t), M = (t) => n(o()).reduceRight(t), E = (t) => (e) => n(o()).foldLeft(t)(e), y = (t) => (e) => n(o()).foldRight(t)(e), S = (t) => c(s.values.get(t)), A = (t, e) => c(s.values.get(t)).getOrElse(e), L = () => s.values.size === 0;
-  return {
-    _tag: i,
-    add: u,
-    remove: p,
-    contains: g,
-    get size() {
-      return v();
-    },
-    map: f,
-    flatMap: d,
-    reduce: m,
-    reduceRight: M,
-    foldLeft: E,
-    foldRight: y,
-    get: S,
-    getOrElse: A,
-    get isEmpty() {
-      return L();
-    },
-    orElse: (t, e) => c(s.values.get(t)).orElse(e),
-    toList: () => n(o()),
-    toSet: () => h(o()),
-    toString: () => `Map(${o().toString()})`,
-    toValue: () => ({ _tag: "Map", value: s.values })
-  };
-}, x = (a) => r(a);
-export {
-  l as E,
-  x as M
-};
-//# sourceMappingURL=Map-BNxKlujn.mjs.map

package/dist/Map-BNxKlujn.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Map-BNxKlujn.mjs","sources":["../src/map/shim.ts","../src/map/Map.ts"],"sourcesContent":["export type IESMap<K, V> = Map<K, V>\nexport const ESMap = Map\n","import type { Collection } from \"@/collections\"\nimport { type Traversable, Typeable } from \"@/index\"\nimport type { IterableType } from \"@/iterable\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option/Option\"\nimport { Set } from \"@/set/Set\"\nimport { Tuple } from \"@/tuple/Tuple\"\nimport { Valuable } from \"@/valuable/Valuable\"\n\nimport { ESMap, type IESMap } from \"./shim\"\n\ntype SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, \"map\" | \"flatMap\">\n\nexport type Map<K, V> = {\n  add(item: Tuple<[K, V]>): Map<K, V>\n  remove(value: K): Map<K, V>\n  map<U>(f: (value: V) => U): Map<K, U>\n  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map<K2, V2>\n  get(key: K): Option<V>\n  getOrElse(key: K, defaultValue: V): V\n  orElse(key: K, alternative: Option<V>): Option<V>\n} & SafeTraversable<K, V> &\n  Collection<Tuple<[K, V]>> &\n  Typeable<\"Map\"> &\n  Valuable<\"Map\", IESMap<K, V>>\n\ntype MapState<K, V> = {\n  values: IESMap<K, V>\n}\n\nconst MapObject = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> => {\n  const _tag = \"Map\"\n  const state: MapState<K, V> = {\n    values: new ESMap<K, V>(entries),\n  }\n\n  const getEntries = () => Array.from(state.values.entries()).map(([key, value]) => Tuple<[K, V]>([key, value]))\n\n  const add = (item: Tuple<[K, V]>): Map<K, V> =>\n    MapObject(new ESMap(state.values).set(item.toArray()[0], item.toArray()[1]).entries())\n\n  const remove = (value: K): Map<K, V> => {\n    const newMap = new ESMap(state.values)\n    return newMap.delete(value) ? MapObject(newMap.entries()) : MapObject(state.values.entries())\n  }\n\n  const contains = (value: Tuple<[K, V]>): boolean => {\n    const tuple = value.toArray()\n    return state.values.get(tuple[0]) === tuple[1]\n  }\n\n  const size = (): number => state.values.size\n\n  const map = <U>(f: (value: V) => U): Map<K, U> =>\n    MapObject(Array.from(state.values.entries()).map(([k, v]) => [k, f(v)]))\n\n  const flatMap = <K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map<K2, V2> => {\n    const list = MapObject(state.values.entries()).toList()\n    return MapObject(list.flatMap(f).toArray())\n  }\n\n  const reduce = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduce(f)\n\n  const reduceRight = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduceRight(f)\n\n  const foldLeft =\n    <B>(z: B) =>\n    (op: (b: B, a: Tuple<[K, V]>) => B): B =>\n      List(getEntries()).foldLeft(z)(op)\n\n  const foldRight =\n    <B>(z: B) =>\n    (op: (a: Tuple<[K, V]>, b: B) => B): B =>\n      List(getEntries()).foldRight(z)(op)\n\n  const get = (key: K): Option<V> => Option(state.values.get(key))\n\n  const getOrElse = (key: K, defaultValue: V): V => Option(state.values.get(key)).getOrElse(defaultValue)\n\n  const isEmpty = (): boolean => state.values.size === 0\n\n  const orElse = (key: K, alternative: Option<V>): Option<V> => Option(state.values.get(key)).orElse(alternative)\n\n  const toList = (): List<Tuple<[K, V]>> => List(getEntries())\n\n  const toSet = (): Set<Tuple<[K, V]>> => Set(getEntries())\n\n  const toString = (): string => `Map(${getEntries().toString()})`\n\n  return {\n    _tag,\n    add,\n    remove,\n    contains,\n    get size() {\n      return size()\n    },\n    map,\n    flatMap,\n    reduce,\n    reduceRight,\n    foldLeft,\n    foldRight,\n    get,\n    getOrElse,\n    get isEmpty() {\n      return isEmpty()\n    },\n    orElse,\n    toList,\n    toSet,\n    toString,\n    toValue: () => ({ _tag: \"Map\", value: state.values }),\n  }\n}\n\nexport const Map = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> =>\n  MapObject(entries)\n\n// Example usage\n// const myMap = createMap<string, unknown>([\n//   [\"a\", 1],\n//   [\"b\", 2],\n//   [\"c\", 3],\n// ])\n"],"names":["ESMap","MapObject","entries","_tag","state","getEntries","key","value","Tuple","add","item","remove","newMap","contains","tuple","size","map","f","k","v","flatMap","list","reduce","List","reduceRight","foldLeft","z","op","foldRight","get","Option","getOrElse","defaultValue","isEmpty","alternative","Set","Map"],"mappings":";;AACO,MAAMA,IAAQ,KC6BfC,IAAY,CAAOC,MAAwF;AAC/G,QAAMC,IAAO,OACPC,IAAwB;AAAA,IAC5B,QAAQ,IAAIJ,EAAYE,CAAO;AAAA,EACjC,GAEMG,IAAa,MAAM,MAAM,KAAKD,EAAM,OAAO,SAAS,EAAE,IAAI,CAAC,CAACE,GAAKC,CAAK,MAAMC,EAAc,CAACF,GAAKC,CAAK,CAAC,CAAC,GAEvGE,IAAM,CAACC,MACXT,EAAU,IAAID,EAAMI,EAAM,MAAM,EAAE,IAAIM,EAAK,QAAU,EAAA,CAAC,GAAGA,EAAK,QAAA,EAAU,CAAC,CAAC,EAAE,SAAS,GAEjFC,IAAS,CAACJ,MAAwB;AACtC,UAAMK,IAAS,IAAIZ,EAAMI,EAAM,MAAM;AACrC,WAAOQ,EAAO,OAAOL,CAAK,IAAIN,EAAUW,EAAO,QAAS,CAAA,IAAIX,EAAUG,EAAM,OAAO,SAAS;AAAA,EAC9F,GAEMS,IAAW,CAACN,MAAkC;AAC5C,UAAAO,IAAQP,EAAM,QAAQ;AACrB,WAAAH,EAAM,OAAO,IAAIU,EAAM,CAAC,CAAC,MAAMA,EAAM,CAAC;AAAA,EAC/C,GAEMC,IAAO,MAAcX,EAAM,OAAO,MAElCY,IAAM,CAAIC,MACdhB,EAAU,MAAM,KAAKG,EAAM,OAAO,QAAS,CAAA,EAAE,IAAI,CAAC,CAACc,GAAGC,CAAC,MAAM,CAACD,GAAGD,EAAEE,CAAC,CAAC,CAAC,CAAC,GAEnEC,IAAU,CAASH,MAAqE;AAC5F,UAAMI,IAAOpB,EAAUG,EAAM,OAAO,QAAQ,CAAC,EAAE,OAAO;AACtD,WAAOH,EAAUoB,EAAK,QAAQJ,CAAC,EAAE,SAAS;AAAA,EAC5C,GAEMK,IAAS,CAACL,MACdM,EAAKlB,GAAY,EAAE,OAAOY,CAAC,GAEvBO,IAAc,CAACP,MACnBM,EAAKlB,GAAY,EAAE,YAAYY,CAAC,GAE5BQ,IACJ,CAAIC,MACJ,CAACC,MACCJ,EAAKlB,EAAW,CAAC,EAAE,SAASqB,CAAC,EAAEC,CAAE,GAE/BC,IACJ,CAAIF,MACJ,CAACC,MACCJ,EAAKlB,EAAW,CAAC,EAAE,UAAUqB,CAAC,EAAEC,CAAE,GAEhCE,IAAM,CAACvB,MAAsBwB,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,GAEzDyB,IAAY,CAACzB,GAAQ0B,MAAuBF,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,EAAE,UAAU0B,CAAY,GAEhGC,IAAU,MAAe7B,EAAM,OAAO,SAAS;AAU9C,SAAA;AAAA,IACL,MAAAD;AAAA,IACA,KAAAM;AAAA,IACA,QAAAE;AAAA,IACA,UAAAE;AAAA,IACA,IAAI,OAAO;AACT,aAAOE,EAAK;AAAA,IACd;AAAA,IACA,KAAAC;AAAA,IACA,SAAAI;AAAA,IACA,QAAAE;AAAA,IACA,aAAAE;AAAA,IACA,UAAAC;AAAA,IACA,WAAAG;AAAA,IACA,KAAAC;AAAA,IACA,WAAAE;AAAA,IACA,IAAI,UAAU;AACZ,aAAOE,EAAQ;AAAA,IACjB;AAAA,IACA,QA3Ba,CAAC3B,GAAQ4B,MAAsCJ,EAAO1B,EAAM,OAAO,IAAIE,CAAG,CAAC,EAAE,OAAO4B,CAAW;AAAA,IA4B5G,QA1Ba,MAA2BX,EAAKlB,GAAY;AAAA,IA2BzD,OAzBY,MAA0B8B,EAAI9B,GAAY;AAAA,IA0BtD,UAxBe,MAAc,OAAOA,EAAW,EAAE,SAAU,CAAA;AAAA,IAyB3D,SAAS,OAAO,EAAE,MAAM,OAAO,OAAOD,EAAM,OAAO;AAAA,EACrD;AACF,GAEagC,IAAM,CAAOlC,MACxBD,EAAUC,CAAO;"}

package/dist/branded/Brand.d.ts

@@ -1,46 +0,0 @@
-/**
- * Brand is a utility for creating nominal typing in TypeScript
- * It allows for creating distinct types that are structurally identical
- * but considered different by TypeScript's type system
- */
-export type Brand<K extends string, T> = T & {
-    readonly __brand: K;
-};
-export type Unbrand<T> = T extends Brand<string, infer U> ? U : never;
-export type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
-/**
- * Helper to create a branded type
- * @param value - The value to brand
- * @returns The branded value
- */
-export declare function Brand<K extends string, T>(brand: K, value: T): Brand<K, T>;
-/**
- * Helper to remove a brand from a value
- * @param branded - The branded value
- * @returns The original value without the brand
- */
-export declare function unbrand<T>(branded: Brand<string, T>): T;
-/**
- * Type guard for checking if a value has a specific brand
- * @param value - The value to check
- * @param brand - The brand to check for
- * @returns True if the value has the specified brand
- *
- * Note: Since brands are phantom types that exist only at compile time,
- * this function can only provide a runtime approximation. It always returns true
- * for non-null values, as we have no way to actually check the brand at runtime.
- * This function is primarily for API consistency and documentation purposes.
- */
-export declare function hasBrand<K extends string, T>(value: unknown, brand: K): value is Brand<K, T>;
-/**
- * Create a branded type constructor for a specific brand
- * @param brand - The brand name
- * @returns A function that brands values with the specified brand
- */
-export declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
-export type BrandedString<K extends string> = Brand<K, string>;
-export type BrandedNumber<K extends string> = Brand<K, number>;
-export type BrandedBoolean<K extends string> = Brand<K, boolean>;
-export declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
-export declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
-export declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;

package/dist/collections/index.d.ts

@@ -1,8 +0,0 @@
-import { List } from '../list/List';
-import { Set } from '../set/Set';
-export type Converters<A> = {
-    toList(): List<A>;
-    toSet(): Set<A>;
-    toString(): string;
-};
-export type Collection<A> = Converters<A>;

package/dist/companion/Companion.d.ts

@@ -1,23 +0,0 @@
-/**
- * Creates a function-object hybrid similar to Scala's companion objects.
- * This utility allows creating TypeScript function objects with attached methods,
- * mimicking Scala's class + companion object pattern without using classes.
- *
- * @param object The main function that will be invoked when the object is called
- * @param companion Additional static methods to attach to the function
- * @returns A function with the attached methods
- *
- * @example
- * const greet = (name: string) => `Hello, ${name}!`;
- * const methods = {
- *   formal: (name: string) => `Good day, ${name}.`,
- *   casual: (name: string) => `Hey ${name}!`
- * };
- * const Greeter = createCompanionObject(greet, methods);
- *
- * // Usage:
- * Greeter("World"); // Hello, World!
- * Greeter.formal("Sir"); // Good day, Sir.
- * Greeter.casual("Friend"); // Hey Friend!
- */
-export declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;

package/dist/companion/index.d.ts

@@ -1 +0,0 @@
-export * from './Companion';

package/dist/core/base/Base.d.ts

@@ -1,10 +0,0 @@
-/**
- * Base Object from which most other objects inherit
- * @param type
- * @param body
- * @constructor
- */
-export declare function Base<T>(type: string, body: T): T & {
-    toString(): string;
-    _tag: string;
-};

package/dist/core/base/index.d.ts

@@ -1 +0,0 @@
-export * from './Base';

package/dist/core/index.d.ts

@@ -1,4 +0,0 @@
-export * from './base';
-export * from './info';
-export * from './task';
-export * from './throwable';

package/dist/core/info/Info.d.ts

@@ -1,26 +0,0 @@
-import { Identity } from '../../identity/Identity';
-type Params = {
-    id: string;
-    description: string;
-    location: string;
-    reason: string;
-    means: string;
-} & Identity<string>;
-/**
- * Base Object from which most other objects inherit
- * @param type
- * @param body
- * @param params
- * @constructor
- */
-export declare function Info<T>(type: string, body: T, params: Params): T & {
-    toString(): string;
-    _tag: string;
-} & {
-    id: string;
-    description: string;
-    location: string;
-    reason: string;
-    means: string;
-} & Identity<string>;
-export {};

package/dist/core/info/index.d.ts

@@ -1 +0,0 @@
-export * from './Info';

package/dist/core/task/Task.d.ts

@@ -1,57 +0,0 @@
-import { Throwable } from '../throwable/Throwable';
-import { Either } from '../../either/Either';
-import { FPromise } from '../../fpromise/FPromise';
-export type TaskParams = {
-    name?: string;
-    description?: string;
-};
-export type TaskInfo = {
-    _task: TaskParams;
-};
-export type TaskException<T> = Either<Throwable, T> & TaskInfo;
-/**
- * TaskException factory function
- * @param error
- * @param _task
- * @param data
- * @constructor
- */
-export declare const TaskException: <T>(error: unknown, data?: unknown, _task?: TaskParams) => TaskException<T>;
-export type TaskResult<T> = Either<Throwable, T> & TaskInfo;
-export declare const TaskResult: <T>(data: T, _task?: TaskParams) => TaskResult<T>;
-export type Sync<T> = Either<Throwable, T>;
-export type Async<T> = FPromise<Sync<T>>;
-/**
- * Task adapter for bridging promise-based code with functional error handling patterns
- */
-export declare const Task: <T = unknown>(params?: TaskParams) => {
-    _type: string;
-    /**
-     * Run an async operation with explicit try/catch/finally semantics
-     * Returns a raw Promise that can interact with traditional Promise-based code
-     */
-    Async: <U = T>(t: () => U | Promise<U>, e?: (error: unknown) => unknown, f?: () => Promise<void> | void) => FPromise<U>;
-    /**
-     * Run a synchronous operation with explicit try/catch/finally semantics
-     * Returns an Either for functional error handling
-     */
-    Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => Sync<U>;
-    /**
-     * Create a successful Task result
-     */
-    success: (data: T) => TaskResult<T>;
-    /**
-     * Create a failed Task result
-     */
-    fail: (error: unknown) => TaskException<T>;
-    /**
-     * Convert a Promise-returning function to a Task-compatible function
-     */
-    fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>) => ((...args: Args) => FPromise<U>);
-    /**
-     * Convert a Task result to a Promise
-     */
-    toPromise: <U>(taskResult: TaskResult<U> | TaskException<U>) => Promise<U>;
-    toString(): string;
-    _tag: string;
-};

package/dist/core/task/index.d.ts

@@ -1 +0,0 @@
-export * from './Task';

package/dist/core/throwable/Throwable.d.ts

@@ -1,18 +0,0 @@
-import { Typeable } from '../../typeable/Typeable';
-declare const NAME: "Throwable";
-export type ThrowableType = Error & Typeable<typeof NAME> & {
-    readonly data?: unknown;
-    readonly cause?: Error;
-};
-export declare class Throwable extends Error implements ThrowableType {
-    readonly _tag: typeof NAME;
-    readonly data?: unknown;
-    readonly cause?: Error;
-    protected constructor(message: string, options?: {
-        data?: unknown | undefined;
-        cause?: Error | undefined;
-        stack?: string | undefined;
-    });
-    static apply(srcError: unknown, data?: unknown): ThrowableType;
-}
-export {};

package/dist/core/throwable/index.d.ts

@@ -1 +0,0 @@
-export * from './Throwable';

package/dist/either/Either.d.ts

@@ -1,57 +0,0 @@
-import { AsyncFunctor, Functor, Type } from '../functor';
-import { List } from '../list/List';
-import { Option } from '../option/Option';
-import { Typeable } from '../typeable/Typeable';
-import { Valuable } from '../valuable/Valuable';
-/**
- * Either type module
- * @module Either
- * @category Core
- */
-export type Either<L extends Type, R extends Type> = {
-    readonly _tag: "Left" | "Right";
-    value: L | R;
-    isLeft: () => boolean;
-    isRight: () => boolean;
-    getOrElse: (defaultValue: R) => R;
-    getOrThrow: () => R;
-    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
-    merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
-    mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
-    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
-    flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
-    toOption: () => Option<R>;
-    toList: () => List<R>;
-    toString: () => string;
-    [Symbol.iterator]: () => Iterator<R>;
-    yield: () => Generator<R, void, unknown>;
-    traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
-    lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
-    tap: (f: (value: R) => void) => Either<L, R>;
-    tapLeft: (f: (value: L) => void) => Either<L, R>;
-    mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
-    bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
-    fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
-    swap: () => Either<R, L>;
-} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<R> & AsyncFunctor<R>;
-export type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R> & AsyncFunctor<R>;
-export declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
-export declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
-export declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: R;
-};
-export declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: L;
-};
-export declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
-export declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
-export declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
-export declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
-export declare const Either: {
-    sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
-    traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
-    fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
-    fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
-    ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
-    fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
-};

package/dist/error/ParseError.d.ts

@@ -1,6 +0,0 @@
-export declare const ParseError: (message?: string) => Error & {
-    name: "ParseError";
-};
-export type ParseError = Error & {
-    name: "ParseError";
-};

package/dist/error/index.d.ts

@@ -1 +0,0 @@
-export * from './ParseError';