functype 0.48.0 → 0.50.0

package/dist/index.d.ts

@@ -1,12 +1,4 @@
-import { Brand, BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unwrap, createBrander, hasBrand, unwrap as unwrapBrand } from "./branded/index.js";
-import { $ as Validation, $t as UrlString, A as UIO, At as isTaggedThrowable, B as Tag, Bt as isCompanion, C as TestClockTag, Ct as TaskFailure, D as RIO, Dt as TaskResult, E as InterruptedError, Et as TaskParams, F as Exit, Ft as Match, G as Kind, Gt as ISO8601Date, H as Identity, Ht as BoundedNumber, I as ExitTag, It as UntypedMatch, J as TryKind, Jt as NonNegativeNumber, K as ListKind, Kt as IntegerNumber, L as Context, Lt as Cond, M as LayerError, Mt as Throwable, N as LayerInput, Nt as ThrowableType, O as Task, Ot as TaskSuccess, P as LayerOutput, Pt as Base, Q as FormValidation, Qt as UUID, R as ContextServices, Rt as CompanionMethods, S as TestClock, St as Task$1, T as IO, Tt as TaskOutcome, U as EitherKind, Ut as BoundedString, V as TagService, Vt as Companion, W as HKT, Wt as EmailAddress, X as FoldableUtils, Xt as PositiveInteger, Y as UniversalContainer, Yt as PatternString, Z as FieldValidation, Zt as PositiveNumber, _ as MatchableUtils, _t as CancellationTokenSource, a as Stack, an as AsyncMonad, at as TypedError, b as Traversable, bt as Sync, c as SerializationResult, cn as CollectionOps, ct as ErrorFormatterOptions, d as createSerializer, dn as Extractable, dt as createErrorSerializer, en as ValidatedBrand, et as ValidationRule, f as fromBinary, fn as isExtractable, ft as formatError, g as Matchable, gt as CancellationToken, h as Ref, hn as ParseError, ht as Async, i as Collection, in as Applicative, it as ErrorStatus, j as Layer, jt as NAME, k as TimeoutError, kt as createCancellationTokenSource, l as createCustomSerializer, ln as ContainerOps, lt as ErrorWithTaskInfo, m as fromYAML, mn as Doable, mt as safeStringify, n as FunctypeBase, nt as ErrorCode, o as Valuable, on as Functor, ot as TypedErrorContext, p as fromJSON, pn as DoResult, pt as formatStackTrace, q as OptionKind, qt as NonEmptyString, r as FunctypeCollection, rn as Promisable, rt as ErrorMessage, s as ValuableParams, sn as Monad, st as ErrorChainElement, t as Functype, tn as ValidatedBrandCompanion, tt as Validator, u as createSerializationCompanion, un as LazyList, ut as TaskErrorInfo, v as ESMap, vt as Err, w as TestContext, wt as TaskMetadata, x as Lazy, xt as TaggedThrowable, y as ESMapType, yt as Ok, z as HasService, zt as InstanceType } from "./Functype-rgysbeU6.js";
-import { a as Serializable, c as Foldable, i as isTypeable, l as Type, n as Typeable, o as SerializationMethods, r as TypeableParams, s as Pipe, t as ExtractTag } from "./Typeable-lfO2nRVW.js";
-import { Try, TypeNames } from "./try/index.js";
-import { Tuple } from "./tuple/index.js";
-import { Map, SafeTraversable } from "./map/index.js";
-import { Set } from "./set/index.js";
-import { None, Option, OptionConstructor, Some } from "./option/index.js";
-import { List } from "./list/index.js";
-import { Either, Left, Right, TestEither, TypeCheckLeft, TypeCheckRight, isLeft, isRight, tryCatch, tryCatchAsync } from "./either/index.js";
-import { $, Do, DoAsync, DoGenerator, EmptyListError, FailureError, FailureErrorType, LeftError, LeftErrorType, NoneError, isDoCapable, unwrap } from "./do/index.js";
-export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, type BrandedBoolean as BrandedBooleanType, BrandedNumber, type BrandedNumber as BrandedNumberType, BrandedString, type BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, type ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, HKT, HasService, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NonEmptyString, NonNegativeNumber, None, NoneError, Ok, Option, OptionConstructor, OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, SafeTraversable, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, type Unwrap, UrlString, ValidatedBrand, type ValidatedBrand as ValidatedBrandType, type ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };
+import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "./Brand-BJIRbUKB.js";
+import { $ as TestClockTag, $t as TaskFailure, A as OptionConstructor, An as ValidatedBrand, At as ValidationRule, B as fromBinary, Bn as ContainerOps, Bt as TaskErrorInfo, C as Functype, Cn as NonEmptyString, Ct as OptionKind, D as List, Dn as PositiveNumber, Dt as FieldValidation, E as Collection, En as PositiveInteger, Et as FoldableUtils, F as Set, Fn as Applicative, Ft as TypedError, G as MatchableUtils, Gn as Doable, Gt as Async, H as fromYAML, Hn as Extractable, Ht as formatError, I as SerializationResult, In as AsyncMonad, It as TypedErrorContext, J as Map, Jt as Err, K as ESMap, Kn as ParseError, Kt as CancellationToken, L as createCustomSerializer, Ln as Functor, Lt as ErrorChainElement, M as Stack, Mn as Try, Mt as ErrorCode, N as Valuable, Nn as TypeNames, Nt as ErrorMessage, O as None, On as UUID, Ot as FormValidation, P as ValuableParams, Pn as Promisable, Pt as ErrorStatus, Q as TestClock, Qt as Task$1, R as createSerializationCompanion, Rn as Monad, Rt as ErrorFormatterOptions, S as tryCatchAsync, Sn as IntegerNumber, St as ListKind, T as FunctypeCollection, Tn as PatternString, Tt as UniversalContainer, U as Ref, Un as isExtractable, Ut as formatStackTrace, V as fromJSON, Vn as LazyList, Vt as createErrorSerializer, W as Matchable, Wn as DoResult, Wt as safeStringify, X as Traversable, Xt as Sync, Y as SafeTraversable, Yt as Ok, Z as Lazy, Zt as TaggedThrowable, _ as TypeCheckLeft, _n as Companion, _t as TagService, a as EmptyListError, an as createCancellationTokenSource, at as TimeoutError, b as isRight, bn as EmailAddress, bt as HKT, c as LeftError, cn as Throwable, ct as LayerError, d as isDoCapable, dn as Match, dt as Exit, en as TaskMetadata, et as TestContext, f as unwrap, fn as UntypedMatch, ft as ExitTag, g as TestEither, gn as isCompanion, gt as Tag, h as Right, hn as InstanceType, ht as HasService, i as DoGenerator, in as TaskSuccess, it as Task, j as Some, jn as ValidatedBrandCompanion, jt as Validator, k as Option, kn as UrlString, kt as Validation, l as LeftErrorType, ln as ThrowableType, lt as LayerInput, m as Left, mn as CompanionMethods, mt as ContextServices, n as Do, nn as TaskParams, nt as InterruptedError, o as FailureError, on as isTaggedThrowable, ot as UIO, p as Either, pn as Cond, pt as Context, q as ESMapType, qt as CancellationTokenSource, r as DoAsync, rn as TaskResult, rt as RIO, s as FailureErrorType, sn as NAME, st as Layer, t as $, tn as TaskOutcome, tt as IO, u as NoneError, un as Base, ut as LayerOutput, v as TypeCheckRight, vn as BoundedNumber, vt as Identity, w as FunctypeBase, wn as NonNegativeNumber, wt as TryKind, x as tryCatch, xn as ISO8601Date, xt as Kind, y as isLeft, yn as BoundedString, yt as EitherKind, z as createSerializer, zn as CollectionOps, zt as ErrorWithTaskInfo } from "./index-OdnROQtM.js";
+import { a as isTypeable, c as Pipe, i as TypeableParams, l as Foldable, n as ExtractTag, o as Serializable, r as Typeable, s as SerializationMethods, t as Tuple, u as Type } from "./Tuple-DmywDCE9.js";
+export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, HKT, HasService, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NonEmptyString, NonNegativeNumber, None, NoneError, Ok, Option, OptionConstructor, OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, SafeTraversable, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, Unwrap, UrlString, ValidatedBrand, ValidatedBrand as ValidatedBrandType, ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };

package/dist/index.js

@@ -1 +1 @@
-import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,B as l,C as u,D as d,E as f,F as p,G as m,H as h,I as g,J as _,K as v,L as y,M as b,N as x,O as S,P as C,Q as w,R as T,S as E,T as D,U as O,V as k,W as A,X as j,Y as M,Z as N,_ as P,a as F,at as I,b as L,c as R,d as z,et as B,f as V,g as H,h as U,i as W,it as G,j as K,k as q,l as J,m as Y,n as X,nt as Z,o as Q,ot as $,p as ee,q as te,r as ne,rt as re,s as ie,t as ae,tt as oe,u as se,v as ce,w as le,x as ue,y as de,z as fe}from"./Valuable-CXh58HBk.js";import{t as pe}from"./Companion-VlxcFhzb.js";import{None as me,Option as he,OptionConstructor as ge,Some as _e}from"./option/index.js";import{Set as ve}from"./set/index.js";import{Try as ye}from"./try/index.js";import{List as be}from"./list/index.js";import{Either as xe,Left as Se,Right as Ce,TypeCheckLeft as we,TypeCheckRight as Te,isLeft as Ee,isRight as De,tryCatch as Oe,tryCatchAsync as ke}from"./either/index.js";import{$ as Ae,Do as je,DoAsync as Me,EmptyListError as Ne,FailureError as Pe,LeftError as Fe,NoneError as Ie,isDoCapable as Le,unwrap as Re}from"./do/index.js";import{Tuple as ze}from"./tuple/index.js";import{Map as Be}from"./map/index.js";export{Ae as $,x as Base,y as BoundedNumber,T as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,pe as Companion,p as Cond,U as Context,je as Do,Me as DoAsync,W as ESMap,xe as Either,fe as EmailAddress,Ne as EmptyListError,f as Err,Y as Exit,Pe as FailureError,ce as FoldableUtils,P as HKT,z as IO,l as ISO8601Date,H as Identity,k as IntegerNumber,V as InterruptedError,se as Layer,F as Lazy,w as LazyList,Se as Left,Fe as LeftError,be as List,Be as Map,C as Match,ne as MatchableUtils,K as NAME,h as NonEmptyString,O as NonNegativeNumber,me as None,Ie as NoneError,d as Ok,he as Option,ge as OptionConstructor,$ as ParseError,A as PatternString,m as PositiveInteger,v as PositiveNumber,s as Ref,Ce as Right,ve as Set,_e as Some,X as Stack,J as Tag,S as Task,Q as TestClock,ie as TestClockTag,R as TestContext,b as Throwable,ee as TimeoutError,ye as Try,ze as Tuple,we as TypeCheckLeft,Te as TypeCheckRight,j as Typeable,ue as TypedError,te as UUID,_ as UrlString,M as ValidatedBrand,L as Validation,ae as Valuable,i as createBrander,q as createCancellationTokenSource,B as createCustomSerializer,E as createErrorSerializer,oe as createSerializationCompanion,Z as createSerializer,u as formatError,le as formatStackTrace,re as fromBinary,G as fromJSON,I as fromYAML,a as hasBrand,g as isCompanion,Le as isDoCapable,de as isExtractable,Ee as isLeft,De as isRight,c as isTaggedThrowable,N as isTypeable,D as safeStringify,Oe as tryCatch,ke as tryCatchAsync,Re as unwrap,o as unwrapBrand};
+import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,At as l,B as u,C as d,Ct as f,D as p,Dt as m,E as h,Et as g,F as _,G as v,H as y,I as b,J as x,K as S,L as C,M as w,Mt as T,N as E,O as D,Ot as O,P as k,Q as A,R as j,S as M,St as N,T as P,Tt as F,U as I,V as L,W as R,X as z,Y as B,Z as V,_ as H,_t as U,a as W,at as G,b as K,bt as q,c as J,ct as Y,d as X,dt as Z,et as Q,f as $,ft as ee,g as te,gt as ne,h as re,ht as ie,i as ae,it as oe,j as se,jt as ce,k as le,kt as ue,l as de,lt as fe,m as pe,mt as me,n as he,nt as ge,o as _e,ot as ve,p as ye,pt as be,q as xe,r as Se,rt as Ce,s as we,st as Te,t as Ee,tt as De,u as Oe,ut as ke,v as Ae,vt as je,w as Me,wt as Ne,x as Pe,xt as Fe,y as Ie,yt as Le,z as Re}from"./src-ByDeJzWj.js";import{r as ze,t as Be}from"./Tuple-eVwTSeSr.js";export{p as $,I as Base,xe as BoundedNumber,x as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,ze as Companion,v as Cond,te as Context,D as Do,le as DoAsync,W as ESMap,ve as Either,B as EmailAddress,c as EmptyListError,b as Err,re as Exit,se as FailureError,Ie as FoldableUtils,Ae as HKT,$ as IO,z as ISO8601Date,H as Identity,V as IntegerNumber,ye as InterruptedError,X as Layer,_e as Lazy,Le as LazyList,Te as Left,w as LeftError,ie as List,ae as Map,R as Match,Se as MatchableUtils,L as NAME,A as NonEmptyString,s as NonNegativeNumber,N as None,E as NoneError,C as Ok,f as Option,Ne as OptionConstructor,T as ParseError,Q as PatternString,De as PositiveInteger,ge as PositiveNumber,q as Ref,Y as Right,Fe as Set,F as Some,he as Stack,Oe as Tag,j as Task,we as TestClock,J as TestClockTag,de as TestContext,y as Throwable,pe as TimeoutError,je as Try,Be as Tuple,fe as TypeCheckLeft,ke as TypeCheckRight,ne as Typeable,M as TypedError,Ce as UUID,oe as UrlString,G as ValidatedBrand,Pe as Validation,Ee as Valuable,i as createBrander,Re as createCancellationTokenSource,g as createCustomSerializer,d as createErrorSerializer,m as createSerializationCompanion,O as createSerializer,Me as formatError,P as formatStackTrace,ue as fromBinary,l as fromJSON,ce as fromYAML,a as hasBrand,S as isCompanion,k as isDoCapable,K as isExtractable,Z as isLeft,ee as isRight,u as isTaggedThrowable,U as isTypeable,h as safeStringify,be as tryCatch,me as tryCatchAsync,_ as unwrap,o as unwrapBrand};

package/dist/list/index.d.ts

@@ -1,85 +1,2 @@
-import { mn as Doable, nn as Reshapeable, r as FunctypeCollection } from "../Functype-rgysbeU6.js";
-import { l as Type, n as Typeable } from "../Typeable-lfO2nRVW.js";
-import { Option } from "../option/index.js";
-
-//#region src/list/List.d.ts
-interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<A> {
-  readonly length: number;
-  readonly [Symbol.iterator]: () => Iterator<A>;
-  map: <B>(f: (a: A) => B) => List<B>;
-  ap: <B>(ff: List<(value: A) => B>) => List<B>;
-  flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>;
-  flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>;
-  filter<S extends A>(predicate: (a: A) => a is S): List<S>;
-  filter(predicate: (a: A) => unknown): List<A>;
-  filterNot: (p: (a: A) => boolean) => List<A>;
-  /** @internal */
-  filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>;
-  remove: (value: A) => List<A>;
-  removeAt: (index: number) => List<A>;
-  add: (item: A) => List<A>;
-  get: (index: number) => Option<A>;
-  concat: (other: List<A>) => List<A>;
-  take: (n: number) => List<A>;
-  takeWhile: (p: (a: A) => boolean) => List<A>;
-  takeRight: (n: number) => List<A>;
-  get last(): A | undefined;
-  get lastOption(): Option<A>;
-  get tail(): List<A>;
-  get init(): List<A>;
-  reverse: () => List<A>;
-  indexOf: (value: A) => number;
-  prepend: (item: A) => List<A>;
-  distinct: () => List<A>;
-  sorted: (compareFn?: (a: A, b: A) => number) => List<A>;
-  sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>;
-  zip: <B>(other: List<B>) => List<[A, B]>;
-  zipWithIndex: () => List<[A, number]>;
-  groupBy: <K>(f: (a: A) => K) => globalThis.Map<K, List<A>>;
-  partition: (p: (a: A) => boolean) => [List<A>, List<A>];
-  span: (p: (a: A) => boolean) => [List<A>, List<A>];
-  slice: (start: number, end: number) => List<A>;
-  /**
-   * Pattern matches over the List, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: {
-    Empty: () => R;
-    NonEmpty: (values: A[]) => R;
-  }): R;
-}
-declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
-  /**
-   * Creates an empty List
-   * Returns a singleton instance for efficiency
-   * @returns An empty List instance
-   */
-  empty: <A extends Type>() => List<A>;
-  /**
-   * Creates a List from variadic arguments
-   * @param values - Values to create list from
-   * @returns A List containing the values
-   */
-  of: <A extends Type>(...values: A[]) => List<A>;
-  /**
-   * Creates a List from JSON string
-   * @param json - The JSON string
-   * @returns List instance
-   */
-  fromJSON: <A>(json: string) => List<A>;
-  /**
-   * Creates a List from YAML string
-   * @param yaml - The YAML string
-   * @returns List instance
-   */
-  fromYAML: <A>(yaml: string) => List<A>;
-  /**
-   * Creates a List from binary string
-   * @param binary - The binary string
-   * @returns List instance
-   */
-  fromBinary: <A>(binary: string) => List<A>;
-};
-//#endregion
+import { D as List } from "../index-OdnROQtM.js";
 export { List };

package/dist/list/index.js

@@ -1,2 +1 @@
-import{Z as e,nt as t}from"../Valuable-CXh58HBk.js";import{t as n}from"../Companion-VlxcFhzb.js";import{None as r,Option as i}from"../option/index.js";import{Set as a}from"../set/index.js";import{Try as o}from"../try/index.js";import{Left as s,Right as c}from"../either/index.js";import l from"safe-stable-stringify";const u=n=>{let d=Array.from(n??[]),f={[Symbol.toStringTag]:`List`,_tag:`List`,[Symbol.iterator]:()=>d[Symbol.iterator](),get size(){return d.length},get length(){return d.length},map:e=>u(d.map(e)),ap:e=>u(d.flatMap(t=>Array.from(e).map(e=>e(t)))),flatMap:e=>u(d.flatMap(t=>Array.from(e(t)))),flatMapAsync:async e=>u((await Promise.all(d.map(async t=>await e(t)))).flatMap(e=>Array.from(e))),forEach:e=>d.forEach(e),contains:e=>d.includes(e),count:e=>d.filter(e).length,exists:e=>d.some(e),filter:e=>u(d.filter(e)),filterNot:e=>u(d.filter(t=>!e(t))),filterType:t=>u(d.filter(n=>e(n,t))),find:(t,n)=>i(d.find(r=>t(r)&&(n?e(r,n):!0))),get head(){return d[0]},get headOption(){return d.length>0?i(d[0]):r()},get isEmpty(){return d.length===0},toArray:()=>[...d],reduce:e=>d.reduce(e),reduceRight:e=>d.reduceRight(e),fold:(e,t)=>{if(d.length===0)return e();let n=d[0];return t(n)},foldLeft:e=>t=>d.reduce(t,e),foldRight:e=>t=>d.reduceRight((e,n)=>t(n,e),e),match:e=>d.length===0?e.Empty():e.NonEmpty([...d]),remove:e=>u(d.filter(t=>t!==e)),removeAt:e=>e<0||e>=d.length?f:u([...d.slice(0,e),...d.slice(e+1)]),add:e=>u([...d,e]),get:e=>i(d[e]),concat:e=>u([...d,...e.toArray()]),take:e=>u(d.slice(0,Math.max(0,e))),takeWhile:e=>{let t=[];for(let n of d){if(!e(n))break;t.push(n)}return u(t)},takeRight:e=>u(e<=0?[]:d.slice(-e)),get last(){return d[d.length-1]},get lastOption(){return d.length>0?i(d[d.length-1]):r()},get tail(){return u(d.slice(1))},get init(){return u(d.length===0?[]:d.slice(0,-1))},reverse:()=>u([...d].reverse()),indexOf:e=>d.indexOf(e),prepend:e=>u([e,...d]),distinct:()=>{let e=new globalThis.Set,t=[];for(let n of d)e.has(n)||(e.add(n),t.push(n));return u(t)},sorted:e=>u([...d].sort(e)),sortBy:(e,t)=>u([...d].sort((n,r)=>{let i=e(n),a=e(r);return t?t(i,a):i<a?-1:i>a?1:0})),zip:e=>{let t=e.toArray(),n=Math.min(d.length,t.length),r=[];for(let e=0;e<n;e++)r.push([d[e],t[e]]);return u(r)},zipWithIndex:()=>u(d.map((e,t)=>[e,t])),groupBy:e=>{let t=new globalThis.Map;for(let n of d){let r=e(n),i=t.get(r)??[];i.push(n),t.set(r,i)}let n=new globalThis.Map;for(let[e,r]of t)n.set(e,u(r));return n},partition:e=>{let t=[],n=[];for(let r of d)e(r)?t.push(r):n.push(r);return[u(t),u(n)]},span:e=>{let t=d.findIndex(t=>!e(t));return t===-1?[u([...d]),u([])]:[u(d.slice(0,t)),u(d.slice(t))]},slice:(e,t)=>u(d.slice(e,t)),drop:e=>u(d.slice(e)),dropRight:e=>u(d.slice(0,-e)),dropWhile:e=>u(d.slice(d.findIndex(t=>!e(t)))),flatten:()=>u(d.flatMap(e=>Array.isArray(e)?e:[e])),toList:()=>f,toSet:()=>a(d),toOption:()=>d.length>0?i(d[0]):r(),toEither:e=>d.length>0?c(d[0]):s(e),toTry:()=>d.length>0?o(()=>d[0]):o(()=>{throw Error(`Empty list`)}),toString:()=>`List(${l(d)})`,toValue:()=>({_tag:`List`,value:d}),pipe:e=>e([...d]),serialize:()=>t(`List`,d),doUnwrap(){return d.length===0?{ok:!1,empty:!0}:{ok:!0,value:d[0]}}};return f},d=e=>u(e),f=u([]),p={empty:()=>f,of:(...e)=>u(e),fromJSON:e=>m(JSON.parse(e).value),fromYAML:e=>{let t=e.split(`
-`)[1]?.split(`: `)[1];return m(t?JSON.parse(t):[])},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return p.fromJSON(t)}},m=n(d,p);export{m as List};
+import{ht as e}from"../src-ByDeJzWj.js";export{e as List};

package/dist/map/index.d.ts

@@ -1,73 +1,2 @@
-import { b as Traversable, i as Collection } from "../Functype-rgysbeU6.js";
-import { a as Serializable, c as Foldable, l as Type, n as Typeable, s as Pipe } from "../Typeable-lfO2nRVW.js";
-import { Tuple } from "../tuple/index.js";
-import { Option } from "../option/index.js";
-
-//#region src/map/Map.d.ts
-/**
- * A traversable interface for map that excludes map and flatMap operations
- */
-type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
-interface Map<K, V> extends SafeTraversable<K, V>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
-  readonly [Symbol.toStringTag]: string;
-  readonly _tag: "Map";
-  add(item: Tuple<[K, V]>): Map<K, V>;
-  remove(value: K): Map<K, V>;
-  map<U>(f: (value: V) => U): Map<K, U>;
-  ap<U>(ff: Map<K, (value: V) => U>): Map<K, U>;
-  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map<K2, V2>;
-  flatMapAsync<U>(f: (value: V) => PromiseLike<Map<K, U>>): PromiseLike<Map<K, U>>;
-  get(key: K): Option<V>;
-  getOrElse(key: K, defaultValue: V): V;
-  orElse(key: K, alternative: Option<V>): Option<V>;
-  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U;
-  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
-  foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B;
-  /**
-   * Pattern matches over the Map, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: {
-    Empty: () => R;
-    NonEmpty: (entries: Array<Tuple<[K, V]>>) => R;
-  }): R;
-  toValue(): {
-    _tag: "Map";
-    value: [K, V][];
-  };
-}
-declare const Map: (<K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>) & {
-  /**
-   * Creates an empty Map
-   * Returns a singleton instance for efficiency
-   * @returns An empty Map instance
-   */
-  empty: <K, V>() => Map<K, V>;
-  /**
-   * Creates a Map from variadic key-value pair arguments
-   * @param entries - Key-value pairs to create map from
-   * @returns A Map containing the entries
-   */
-  of: <K, V>(...entries: [K, V][]) => Map<K, V>;
-  /**
-   * Creates a Map from JSON string
-   * @param json - The JSON string
-   * @returns Map instance
-   */
-  fromJSON: <K, V>(json: string) => Map<K, V>;
-  /**
-   * Creates a Map from YAML string
-   * @param yaml - The YAML string
-   * @returns Map instance
-   */
-  fromYAML: <K, V>(yaml: string) => Map<K, V>;
-  /**
-   * Creates a Map from binary string
-   * @param binary - The binary string
-   * @returns Map instance
-   */
-  fromBinary: <K, V>(binary: string) => Map<K, V>;
-};
-//#endregion
+import { J as Map, Y as SafeTraversable } from "../index-OdnROQtM.js";
 export { Map, SafeTraversable };

package/dist/map/index.js

@@ -1,2 +1 @@
-import{i as e,nt as t}from"../Valuable-CXh58HBk.js";import{t as n}from"../Companion-VlxcFhzb.js";import{Option as r}from"../option/index.js";import{Set as i}from"../set/index.js";import{List as a}from"../list/index.js";import{Tuple as o}from"../tuple/index.js";const s=n=>{let c={values:new e(n)},l=()=>Array.from(c.values.entries()).map(([e,t])=>o([e,t])),u=t=>s(new e(c.values).set(t.toArray()[0],t.toArray()[1]).entries()),d=t=>{let n=new e(c.values);return n.delete(t)?s(n.entries()):s(c.values.entries())},f=e=>{let t=e.toArray();return c.values.get(t[0])===t[1]},p=()=>c.values.size,m=e=>s(Array.from(c.values.entries()).map(([t,n])=>[t,e(n)])),h=e=>s(s(c.values.entries()).toList().flatMap(e).toArray()),g=e=>{let t=[];for(let[n,r]of c.values.entries()){let i=e.get(n);i._tag===`Some`&&i.value&&t.push([n,i.value(r)])}return s(t)},_=async t=>{let n=new e;for(let[e,r]of c.values.entries()){let e=await t(r);for(let t of e.toList()){let[e,r]=t.toArray();n.set(e,r)}}return s(n.entries())},v=e=>a(l()).reduce(e),y=e=>a(l()).reduceRight(e),b=e=>t=>a(l()).foldLeft(e)(t),x=e=>t=>a(l()).foldRight(e)(t),S=e=>r(c.values.get(e)),C=(e,t)=>r(c.values.get(e)).orElse(t),w=()=>c.values.size===0,T=(e,t)=>r(c.values.get(e)).or(t),E=(e,t)=>{if(w())return e();let n=l();if(n.length===0)return e();let r=n[0];return r===void 0?e():t(r)},D=()=>a(l()),O=()=>i(l()),k=()=>`Map(${l().toString()})`,A=e=>w()?e.Empty():e.NonEmpty(l());return{[Symbol.toStringTag]:`FunctypeMap`,_tag:`Map`,[Symbol.iterator]:()=>c.values.entries(),add:u,remove:d,contains:f,get size(){return p()},map:m,ap:g,flatMap:h,flatMapAsync:_,reduce:v,reduceRight:y,foldLeft:b,foldRight:x,fold:E,match:A,get:S,getOrElse:C,get isEmpty(){return w()},orElse:T,toList:D,toSet:O,toString:k,toValue:()=>({_tag:`Map`,value:Array.from(c.values.entries())}),pipe:e=>e(Array.from(c.values.entries())),serialize:()=>t(`Map`,Array.from(c.values.entries()))}},c=e=>s(e),l=s([]),u={empty:()=>l,of:(...e)=>s(e),fromJSON:e=>d(JSON.parse(e).value),fromYAML:e=>{let t=e.split(`
-`)[1]?.split(`: `)[1];return d(t?JSON.parse(t):[])},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return u.fromJSON(t)}},d=n(c,u);export{d as Map};
+import{i as e}from"../src-ByDeJzWj.js";export{e as Map};

package/dist/option/index.d.ts

@@ -1,243 +1,2 @@
-import { mn as Doable, nn as Reshapeable, rn as Promisable, t as Functype } from "../Functype-rgysbeU6.js";
-import { l as Type } from "../Typeable-lfO2nRVW.js";
-import { List } from "../list/index.js";
-import { Either } from "../either/index.js";
-
-//#region src/option/Option.d.ts
-/**
- * Option type module
- * @module Option
- * @category Core
- */
-/**
- * The Option type represents a value that may or may not exist.
- * It's used to handle potentially null or undefined values in a type-safe way.
- * @typeParam T - The type of the value contained in the Option
- */
-interface Option<T extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
-  /** The contained value (undefined for None) */
-  readonly value: T | undefined;
-  /** Whether this Option contains no value */
-  isEmpty: boolean;
-  /**
-   * Returns true if this Option is a Some (contains a value)
-   * @returns true if this Option contains a value, false otherwise
-   */
-  isSome(): this is Option<T> & {
-    value: T;
-    isEmpty: false;
-  };
-  /**
-   * Returns true if this Option is a None (contains no value)
-   * @returns true if this Option is empty, false otherwise
-   */
-  isNone(): this is Option<T> & {
-    value: undefined;
-    isEmpty: true;
-  };
-  /**
-   * Returns the contained value or a default value if None
-   * @param defaultValue - The value to return if this Option is None
-   * @returns The contained value or defaultValue
-   */
-  orElse(defaultValue: T): T;
-  /**
-   * Returns the contained value or throws an error if None
-   * @param error - Optional custom error to throw. If not provided, throws a default error
-   * @returns The contained value
-   * @throws The specified error or a default error if the Option is None
-   */
-  orThrow(error?: Error): T;
-  /**
-   * Returns this Option if it contains a value, otherwise returns the alternative container
-   * @param alternative - The alternative Option to return if this is None
-   * @returns This Option or the alternative
-   */
-  or(alternative: Option<T>): Option<T>;
-  /**
-   * Returns the contained value or null if None
-   * @returns The contained value or null
-   */
-  orNull(): T | null;
-  /**
-   * Returns the contained value or undefined if None
-   * @returns The contained value or undefined
-   */
-  orUndefined(): T | undefined;
-  /**
-   * Maps the value inside the Option using the provided function
-   * @param f - The mapping function
-   * @returns A new Option containing the mapped value, or None if this Option is None
-   */
-  map<U extends Type>(f: (value: T) => U): Option<U>;
-  /**
-   * Applies a wrapped function to a wrapped value (Applicative pattern)
-   * @param ff - An Option containing a function from T to U
-   * @returns A new Option containing the result of applying the function
-   */
-  ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>;
-  /**
-   * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
-   * @param predicate - The predicate function to test the value
-   * @returns This Option or None
-   */
-  filter(predicate: (value: T) => boolean): Option<T>;
-  /**
-   * Maps the value using a function that returns an Option
-   * @param f - The mapping function returning an Option
-   * @returns The result of applying f to the contained value, or None if this Option is None
-   */
-  flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-  /**
-   * Maps the value using an async function that returns an Option
-   * @param f - The async mapping function returning an Option
-   * @returns Promise of the result of applying f to the contained value, or None if this Option is None
-   */
-  flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>;
-  /**
-   * Applies a binary operator to a start value and the contained value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduce<U>(f: (acc: U, value: T) => U): U;
-  /**
-   * Applies a binary operator to the contained value and a start value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduceRight<U>(f: (acc: U, value: T) => U): U;
-  /**
-   * Pattern matches over the Option, applying onNone if None and onSome if Some
-   * @param onNone - Function to apply if the Option is None
-   * @param onSome - Function to apply if the Option has a value
-   * @returns The result of applying the appropriate function
-   */
-  fold<U>(onNone: () => U, onSome: (value: T) => U): U;
-  /**
-   * Left-associative fold using the provided zero value and operation
-   * @param z - Zero/identity value
-   * @returns A function that takes an operation to apply
-   */
-  foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
-  /**
-   * Right-associative fold using the provided zero value and operation
-   * @param z - Zero/identity value
-   * @returns A function that takes an operation to apply
-   */
-  foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
-  /**
-   * Converts this Option to a List
-   * @returns A List containing the value if Some, or empty List if None
-   */
-  toList(): List<T>;
-  /**
-   * Checks if this Option contains the specified value
-   * @param value - The value to check for
-   * @returns true if this Option contains the value, false otherwise
-   */
-  contains(value: T): boolean;
-  /** The number of elements in this Option (0 or 1) */
-  size: number;
-  /**
-   * Converts this Option to an Either
-   * @param left - The value to use for Left if this Option is None
-   * @returns Either.Right with the contained value if Some, or Either.Left with left if None
-   */
-  toEither<E>(left: E): Either<E, T>;
-  /**
-   * Returns a string representation of this Option
-   * @returns A string representation
-   */
-  toString(): string;
-  /**
-   * Returns a simple object representation of this Option
-   * @returns An object with _tag and value properties
-   */
-  toValue(): {
-    _tag: "Some" | "None";
-    value: T;
-  };
-  /**
-   * Pattern matches over the Option, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Some and None variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: {
-    Some: (value: T) => R;
-    None: () => R;
-  }): R;
-}
-/**
- * Creates a Some variant of Option containing a value.
- * @param value - The value to wrap in Some
- * @returns A new Some instance containing the value
- * @typeParam T - The type of the value
- */
-declare const Some: <T extends Type>(value: T) => Option<T>;
-/**
- * Creates a None variant of Option representing absence of a value.
- * @returns A new None instance
- * @typeParam T - The type that would be contained if this was a Some
- */
-declare const None: <T extends Type>() => Option<T>;
-/**
- * Safely wraps a value that might be null or undefined in an Option.
- * Creates Some if the value is defined, None otherwise.
- * @param value - The value to wrap (might be null/undefined)
- * @returns Some(value) if value is defined, None otherwise
- * @typeParam T - The type of the value
- */
-declare const OptionConstructor: <T extends Type>(value: T | null | undefined) => Option<T>;
-declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
-  /**
-   * Creates an Option from any value. Alias for Option function.
-   * @param value - The value to wrap
-   * @returns Some(value) if value is defined, None otherwise
-   * @typeParam T - The type of the value
-   */
-  from: <T>(value: T) => Option<T>;
-  /**
-   * Returns a None instance. Alias for None function.
-   * @returns A None instance
-   * @typeParam T - The type that would be contained if this was a Some
-   */
-  none: <T>() => Option<T>;
-  /**
-   * Type guard to check if an Option is Some
-   * @param option - The Option to check
-   * @returns True if Option is Some
-   */
-  isSome: <T>(option: Option<T>) => option is Option<T> & {
-    value: T;
-    isEmpty: false;
-  };
-  /**
-   * Type guard to check if an Option is None
-   * @param option - The Option to check
-   * @returns True if Option is None
-   */
-  isNone: <T>(option: Option<T>) => option is Option<T> & {
-    value: undefined;
-    isEmpty: true;
-  };
-  /**
-   * Creates an Option from JSON string
-   * @param json - The JSON string
-   * @returns Option instance
-   */
-  fromJSON: <T>(json: string) => Option<T>;
-  /**
-   * Creates an Option from YAML string
-   * @param yaml - The YAML string
-   * @returns Option instance
-   */
-  fromYAML: <T>(yaml: string) => Option<T>;
-  /**
-   * Creates an Option from binary string
-   * @param binary - The binary string
-   * @returns Option instance
-   */
-  fromBinary: <T>(binary: string) => Option<T>;
-};
-//#endregion
+import { A as OptionConstructor, O as None, j as Some, k as Option } from "../index-OdnROQtM.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

@@ -1,2 +1 @@
-import{nt as e}from"../Valuable-CXh58HBk.js";import{t}from"../Companion-VlxcFhzb.js";import{Try as n}from"../try/index.js";import{List as r}from"../list/index.js";import{Left as i,Right as a}from"../either/index.js";import o from"safe-stable-stringify";const s=t=>({[Symbol.toStringTag]:`Option`,_tag:`Some`,value:t,isEmpty:!1,isSome(){return!0},isNone(){return!1},orElse:()=>t,orThrow:()=>t,or:e=>s(t),orNull:()=>t,orUndefined:()=>t,map:e=>s(e(t)),ap:e=>e._tag===`Some`&&e.value?s(e.value(t)):c,filter(e){return e(t)?s(t):c},count:e=>e(t)?1:0,find:e=>e(t)?s(t):c,exists:e=>e(t),forEach:e=>e(t),fold:(e,n)=>n(t),match:e=>e.Some(t),flatMap:e=>e(t),flatMapAsync:async e=>await e(t),reduce:e=>e(void 0,t),reduceRight:e=>e(void 0,t),foldLeft:e=>n=>n(e,t),foldRight:e=>n=>n(t,e),toList:()=>r([t]),contains:e=>e===t,size:1,toOption:()=>s(t),toEither:e=>a(t),toTry:()=>n(()=>t),toPromise:()=>Promise.resolve(t),toString:()=>`Some(${o(t)})`,toValue:()=>({_tag:`Some`,value:t}),pipe:e=>e(t),serialize:()=>e(`Some`,t),doUnwrap(){return{ok:!0,value:t}}}),c={[Symbol.toStringTag]:`Option`,_tag:`None`,value:void 0,isEmpty:!0,isSome(){return!1},isNone(){return!0},orElse:e=>e,orThrow(e){throw e??Error(`Cannot extract value from None`)},or:e=>e,orNull:()=>null,orUndefined:()=>void 0,map:e=>c,ap:e=>c,filter(e){return c},count:e=>0,find:e=>c,exists:e=>!1,forEach:e=>{},flatMap:e=>c,flatMapAsync:e=>Promise.resolve(c),reduce:()=>void 0,reduceRight:()=>void 0,fold:(e,t)=>e(),match:e=>e.None(),foldLeft:e=>()=>e,foldRight:e=>()=>e,toList:()=>r([]),contains:()=>!1,size:0,toOption:()=>c,toEither:e=>i(e),toTry:()=>n(()=>{throw Error(`None`)}),toPromise:()=>Promise.reject(Error(`Cannot convert None to Promise`)),toString:()=>`None`,toValue:()=>({_tag:`None`,value:void 0}),pipe:e=>e(void 0),serialize:()=>e(`None`,null),doUnwrap(){return{ok:!1,empty:!0}}},l=()=>c,u=e=>e==null?l():s(e),d={from:e=>f(e),none:()=>l(),isSome:e=>e.isSome(),isNone:e=>e.isNone(),fromJSON:e=>{let t=JSON.parse(e);return t._tag===`Some`?s(t.value):l()},fromYAML:e=>{let t=e.split(`
-`),n=t[0]?.split(`: `)[1],r=t[1]?.split(`: `)[1];if(!n||!r)return l();let i=r===`null`?null:JSON.parse(r);return n===`Some`?s(i):l()},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return d.fromJSON(t)}},f=t(u,d);export{l as None,f as Option,u as OptionConstructor,s as Some};
+import{Ct as e,St as t,Tt as n,wt as r}from"../src-ByDeJzWj.js";export{t as None,e as Option,r as OptionConstructor,n as Some};

package/dist/set/index.d.ts

@@ -1,54 +1,2 @@
-import { i as Collection, r as FunctypeCollection } from "../Functype-rgysbeU6.js";
-import { l as Type } from "../Typeable-lfO2nRVW.js";
-import { List } from "../list/index.js";
-
-//#region src/set/Set.d.ts
-interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
-  add: (value: A) => Set<A>;
-  remove: (value: A) => Set<A>;
-  contains: (value: A) => boolean;
-  has: (value: A) => boolean;
-  map: <B>(f: (a: A) => B) => Set<B>;
-  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
-  filter: (p: (a: A) => boolean) => Set<A>;
-  filterNot: (p: (a: A) => boolean) => Set<A>;
-  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
-  toList: () => List<A>;
-  toSet: () => Set<A>;
-  toArray: <B = A>() => B[];
-  toString: () => string;
-}
-declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
-  /**
-   * Creates an empty Set
-   * Returns a singleton instance for efficiency
-   * @returns An empty Set instance
-   */
-  empty: <A extends Type>() => Set<A>;
-  /**
-   * Creates a Set from variadic arguments
-   * @param values - Values to create set from
-   * @returns A Set containing the unique values
-   */
-  of: <A extends Type>(...values: A[]) => Set<A>;
-  /**
-   * Creates a Set from JSON string
-   * @param json - The JSON string
-   * @returns Set instance
-   */
-  fromJSON: <A>(json: string) => Set<A>;
-  /**
-   * Creates a Set from YAML string
-   * @param yaml - The YAML string
-   * @returns Set instance
-   */
-  fromYAML: <A>(yaml: string) => Set<A>;
-  /**
-   * Creates a Set from binary string
-   * @param binary - The binary string
-   * @returns Set instance
-   */
-  fromBinary: <A>(binary: string) => Set<A>;
-};
-//#endregion
+import { F as Set } from "../index-OdnROQtM.js";
 export { Set };

package/dist/set/index.js

@@ -1,2 +1 @@
-import{nt as e}from"../Valuable-CXh58HBk.js";import{t}from"../Companion-VlxcFhzb.js";import{Option as n}from"../option/index.js";import{List as r}from"../list/index.js";const i=globalThis.Set,a=t=>{let o=new i(t),s={[Symbol.toStringTag]:`FunctypeSet`,_tag:`Set`,[Symbol.iterator]:()=>o[Symbol.iterator](),add:e=>a([...o,e]),remove:e=>{let t=new i(o);return t.delete(e),a(t)},contains:e=>o.has(e),has:e=>o.has(e),map:e=>a(Array.from(o).map(e)),ap:e=>{let t=new i;for(let n of o)for(let r of e)t.add(r(n));return a(t)},flatMap:e=>{let t=new i;for(let n of o)for(let r of e(n))t.add(r);return a(t)},flatMapAsync:async e=>{let t=new i;for(let n of o){let r=await e(n);for(let e of r)t.add(e)}return a(t)},fold:(e,t)=>{if(o.size===0)return e();let n=Array.from(o);if(n.length===0)return e();let r=n[0];return r===void 0?e():t(r)},foldLeft:e=>t=>{let n=e;for(let e of o)n=t(n,e);return n},foldRight:e=>t=>Array.from(o).reduceRight((e,n)=>t(n,e),e),get size(){return o.size},get isEmpty(){return o.size===0},reduce:e=>{let t=Array.from(o);if(t.length===0)throw Error(`Cannot reduce empty Set`);return t.reduce(e)},reduceRight:e=>{let t=Array.from(o);if(t.length===0)throw Error(`Cannot reduceRight empty Set`);return t.reduceRight(e)},count:e=>{let t=0;for(let n of o)e(n)&&t++;return t},find:e=>{for(let t of o)if(e(t))return n(t);return n(null)},exists:e=>{for(let t of o)if(e(t))return!0;return!1},forEach:e=>{o.forEach(e)},filter:e=>{let t=new i;for(let n of o)e(n)&&t.add(n);return a(t)},filterNot:e=>{let t=new i;for(let n of o)e(n)||t.add(n);return a(t)},drop:e=>a(Array.from(o).slice(e)),dropRight:e=>a(Array.from(o).slice(0,-e)),dropWhile:e=>{let t=Array.from(o),n=t.findIndex(t=>!e(t));return a(n===-1?[]:t.slice(n))},flatten:()=>{let e=new i;for(let t of o)if(Array.isArray(t))for(let n of t)e.add(n);else if(t&&typeof t==`object`&&Symbol.iterator in t)for(let n of t)e.add(n);else e.add(t);return a(e)},get head(){return Array.from(o)[0]},get headOption(){let e=Array.from(o)[0];return n(e)},take:e=>a(Array.from(o).slice(0,Math.max(0,e))),takeWhile:e=>{let t=Array.from(o),n=[];for(let r of t){if(!e(r))break;n.push(r)}return a(n)},takeRight:e=>{let t=Array.from(o);return a(e<=0?[]:t.slice(-e))},get last(){let e=Array.from(o);return e[e.length-1]},get lastOption(){let e=Array.from(o);return n(e[e.length-1])},get tail(){return a(Array.from(o).slice(1))},get init(){let e=Array.from(o);return a(e.length===0?[]:e.slice(0,-1))},toList:()=>r(Array.from(o)),toSet:()=>s,toArray:()=>Array.from(o),toString:()=>`Set(${Array.from(o).toString()})`,toValue:()=>({_tag:`Set`,value:Array.from(o)}),pipe:e=>e(Array.from(o)),serialize:()=>e(`Set`,Array.from(o))};return s},o=e=>a(e),s=a([]),c={empty:()=>s,of:(...e)=>a(e),fromJSON:e=>l(JSON.parse(e).value),fromYAML:e=>{let t=e.split(`
-`)[1]?.split(`: `)[1];return l(t?JSON.parse(t):[])},fromBinary:e=>{let t=Buffer.from(e,`base64`).toString();return c.fromJSON(t)}},l=t(o,c);export{l as Set};
+import{xt as e}from"../src-ByDeJzWj.js";export{e as Set};