t-tasks 1.0.1 → 1.0.2

package/dist/t-tasks.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"t-tasks.esm.js","sources":["../src/maybe.ts","../src/either.ts","../src/task.ts"],"sourcesContent":["/**\n * Just a value\n *\n * Maybe data type specialization representing an existing value\n *\n * @template R underlying value\n */\nexport interface Just<R> {\n  readonly just: R;\n\n  /**\n   * Maybe peeker function\n   *\n   * Applied to 'just value' returns self invoking op(value) in process\n   * Applied to 'nothing' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Maybe fallback peeker function\n   *\n   * Applied to 'just value' returns self without invoking callback\n   * Applied to 'nothing' returns self invoking op() in process\n   *\n   * @param op function to be invoked\n   * @returns self\n   */\n  orTap(op: () => void): this;\n\n  /**\n   * Maybe patter matching peeker function\n   *\n   * Applied to 'just value' returns self invoking op.just(value) in process\n   * Applied to 'nothing' returns self invoking op.nothing() in process\n   *\n   * @param op.just function to be invoked with underlying value in case of just\n   * @param op.nothing function to be invoked in case of nothing\n   * @returns self\n   */\n  matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n  /**\n   * Maybe transformer function\n   *\n   * Applied to 'just value' returns 'just op(value)'\n   * Applied to 'nothing' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'just op(value)' or 'nothing'\n   */\n  // Just case\n  map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;\n  // Generic case\n  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n  /**\n   * Maybe fallback transformer function\n   *\n   * Applied to 'just value' returns self without invoking transformer\n   * Applied to 'nothing' returns 'just op()'\n   *\n   * @param op function to be invoked\n   * @returns 'just value' or 'just op()'\n   */\n  // Just case\n  orMap<R2>(this: Just<R>, op: () => R2): Just<R>;\n  // Generic case\n  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;\n\n  /**\n   * Maybe patter matching transformer function\n   *\n   * Applied to 'just value' returns 'just op.just(value)'\n   * Applied to 'nothing' returns 'just op.nothing()'\n   *\n   * @template R2 just transformer function's return type\n   * @template R3 nothing transformer function's return type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'just op.just(value)' or 'just op.nothing()'\n   */\n  // Just cases\n  matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;\n\n  /**\n   * Maybe composition function\n   *\n   * Applied to 'just value' returns 'op(value)'\n   * Applied to 'nothing' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'nothing'\n   */\n  // Just cases\n  chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;\n  chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n  // General cases\n  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n  /**\n   * Maybe fallback composition function\n   *\n   * Applied to 'just value' returns self witjout invoking composition function\n   * Applied to 'nothing' returns op()\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked\n   * @returns 'just value' or 'op()'\n   */\n  // Just cases\n  orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;\n  orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;\n  orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;\n  // General case\n  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;\n  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;\n\n  /**\n   * Maybe patter matching composition function\n   *\n   * Applied to 'just value' returns 'op.just(value)'\n   * Applied to 'nothing' returns op.nothing()\n   *\n   * @template R2 just transformer function result's underlying type\n   * @template R3 nothing transformer function result's underlying type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'op.just(value)' or 'op.nothing()'\n   */\n  // Just cases\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2>;\n  // General cases\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n\n  /**\n   * Maybe type guard for 'just'\n   *\n   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isJust()) {\n   *   console.log(maybe.just);\n   * }\n   * ```\n   */\n  isJust(): this is Just<R>;\n\n  /**\n   * Maybe type guard for 'nothing'\n   *\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isNohing()) {\n   *   console.log('nothing');\n   * }\n   * ```\n   */\n  isNothing(): this is Nothing<R>;\n}\n\n/**\n * Absolutely Nothing\n *\n * Maybe data type specialiation representing an absence of any value\n */\nexport interface Nothing<R> {\n  /**\n   * Maybe peeker function\n   *\n   * Applied to 'just value' returns self invoking op(value) in process\n   * Applied to 'nothing' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Maybe fallback peeker function\n   *\n   * Applied to 'just value' returns self without invoking callback\n   * Applied to 'nothing' returns self invoking op() in process\n   *\n   * @param op function to be invoked\n   * @returns self\n   */\n  orTap(op: () => void): this;\n\n  /**\n   * Maybe patter matching peeker function\n   *\n   * Applied to 'just value' returns self invoking op.just(value) in process\n   * Applied to 'nothing' returns self invoking op.nothing() in process\n   *\n   * @param op.just function to be invoked with underlying value in case of just\n   * @param op.nothing function to be invoked in case of nothing\n   * @returns self\n   */\n  matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n  /**\n   * Maybe transformer function\n   *\n   * Applied to 'just value' returns 'just op(value)'\n   * Applied to 'nothing' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'just op(value)' or 'nothing'\n   */\n  // Nothing case\n  map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;\n  // Generic case\n  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n  /**\n   * Maybe fallback transformer function\n   *\n   * Applied to 'just value' returns self without invoking transformer\n   * Applied to 'nothing' returns 'just op()'\n   *\n   * @param op function to be invoked\n   * @returns 'just value' or 'just op()'\n   */\n  // Nothing case\n  orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;\n  // Generic case\n  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;\n\n  /**\n   * Maybe patter matching transformer function\n   *\n   * Applied to 'just value' returns 'just op.just(value)'\n   * Applied to 'nothing' returns 'just op.nothing()'\n   *\n   * @template R2 just transformer function's return type\n   * @template R3 nothing transformer function's return type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'just op.just(value)' or 'just op.nothing()'\n   */\n  // Nothing cases\n  matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;\n  // General cases\n  matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;\n\n  /**\n   * Maybe composition function\n   *\n   * Applied to 'just value' returns 'op(value)'\n   * Applied to 'nothing' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'nothing'\n   */\n  // Nothing cases\n  chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;\n  chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;\n  // General cases\n  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n  /**\n   * Maybe fallback composition function\n   *\n   * Applied to 'just value' returns self witjout invoking composition function\n   * Applied to 'nothing' returns op()\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked\n   * @returns 'just value' or 'op()'\n   */\n  // Nothing cases\n  orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;\n  orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;\n  orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;\n  // General cases\n  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;\n  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;\n\n  /**\n   * Maybe patter matching composition function\n   *\n   * Applied to 'just value' returns 'op.just(value)'\n   * Applied to 'nothing' returns op.nothing()\n   *\n   * @template R2 just transformer function result's underlying type\n   * @template R3 nothing transformer function result's underlying type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'op.just(value)' or 'op.nothing()'\n   */\n  // Nothing cases\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  // General cases\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n\n  /**\n   * Maybe type guard for 'just'\n   *\n   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isJust()) {\n   *   console.log(maybe.just);\n   * }\n   * ```\n   */\n  isJust(): this is Just<R>;\n\n  /**\n   * Maybe type guard for 'nothing'\n   *\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isNohing()) {\n   *   console.log('nothing');\n   * }\n   * ```\n   */\n  isNothing(): this is Nothing<R>;\n}\n\n/**\n * Genric Maybe monad interface\n *\n * As per classic Maybe monad implementation can eithr contain just a value or contain nothing\n * Used throughout the library to represent optional return type, specifically return type of cancelled tasks\n *\n * @template R underlying value\n */\nexport type Maybe<R> = Just<R> | Nothing<R>;\n\nexport namespace Just {\n  /**\n   * Standalone Just value extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @param just Just instance\n   * @returns underlying value\n   */\n  export function just<R>(just: Just<R>) {\n    return just.just;\n  }\n}\n\nexport namespace Nothing {}\n\nexport namespace Maybe {\n  /**\n   * Non-empty monad constructor\n   *\n   * @template R underlying type\n   * @param value underlying value\n   * @returns 'just value'\n   */\n  export function just<R>(value: R): Just<R> {\n    return new JustClass<R>(value);\n  }\n\n  /**\n   * Empty monad constructor\n   *\n   * @returns 'nothing'\n   */\n  export function nothing(): Nothing<never> {\n    return staticNothing;\n  }\n\n  /**\n   * Maybe constructor from optional value\n   *\n   * Resolves to 'nothing' in case of undefined value and 'just value' otherwise\n   *\n   * @param value possibly undefined value\n   * @returns either 'just value' or 'nothing'\n   */\n  export function fromOptional(value: undefined): Nothing<never>;\n  export function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;\n  export function fromOptional<R>(value: R | undefined): Maybe<R>;\n  export function fromOptional<R>(value: R | undefined) {\n    return typeof value !== 'undefined' ? Maybe.just(value) : Maybe.nothing();\n  }\n\n  /**\n   * Maybe constructor from optional or nullable value\n   *\n   * Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise\n   *\n   * @param value possibly undefined value\n   * @returns either 'just value' or 'nothing'\n   */\n  export function fromNullable(value: undefined): Nothing<never>;\n  export function fromNullable(value: null): Nothing<never>;\n  export function fromNullable<R>(value: Exclude<R, null | undefined>): Just<R>;\n  export function fromNullable<R>(value: R | null | undefined): Maybe<R>;\n  export function fromNullable<R>(value: R | null | undefined) {\n    return Maybe.fromOptional(value).chain((v) => (v !== null ? Maybe.just(v) : Maybe.nothing()));\n  }\n\n  /**\n   * Standalone type guard for 'just'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param maybe Maybe instance\n   * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')\n   */\n  export function isJust<R>(maybe: Maybe<R>): maybe is Just<R> {\n    return maybe.isJust();\n  }\n\n  /**\n   * Standalone type guard for 'nothing'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param maybe Maybe instance\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')\n   */\n  export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<never> {\n    return maybe.isNothing();\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case every list element is Just\n   */\n  export function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {\n    return maybes.every(Maybe.isJust);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case al east one list element is Just\n   */\n  export function someJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {\n    return maybes.some(Maybe.isJust);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case every list element is Nothing\n   */\n  export function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {\n    return maybes.every(Maybe.isNothing);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case at least one list element is Nothing\n   */\n  export function someNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {\n    return maybes.some(Maybe.isNothing);\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass JustClass<R> implements Just<R> {\n  constructor(readonly just: R) {}\n\n  tap(op: (value: R) => void) {\n    op(this.just);\n\n    return this;\n  }\n  orTap() {\n    return this;\n  }\n  map<R2>(op: (value: R) => R2) {\n    return Maybe.just(op(this.just));\n  }\n  orMap() {\n    return this;\n  }\n  chain<RR extends Maybe<unknown>>(op: (value: R) => RR) {\n    return op(this.just);\n  }\n  orChain() {\n    return this;\n  }\n  isJust(): this is Just<R> {\n    return true;\n  }\n  isNothing(): this is Nothing<R> {\n    return false;\n  }\n  matchTap(op: { just: (value: R) => void }) {\n    return this.tap(op.just);\n  }\n  matchMap<R2>(op: { just: (value: R) => R2 }) {\n    return this.map(op.just);\n  }\n  matchChain<RR extends Maybe<unknown>>(op: { just: (value: R) => RR }) {\n    return this.chain(op.just);\n  }\n}\n\nclass NothingClass implements Nothing<never> {\n  tap() {\n    return this;\n  }\n  orTap(op: () => void) {\n    op();\n\n    return this;\n  }\n  map() {\n    return this;\n  }\n  orMap<R2>(op: () => R2) {\n    return Maybe.just(op());\n  }\n  chain() {\n    return this;\n  }\n  orChain<RR extends Maybe<unknown>>(op: () => RR) {\n    return op();\n  }\n  isJust(): this is Just<never> {\n    return false;\n  }\n  isNothing(): this is Nothing<never> {\n    return true;\n  }\n  matchTap(op: { nothing: () => void }) {\n    return this.orTap(op.nothing);\n  }\n  matchMap<R2>(op: { nothing: () => R2 }) {\n    return this.orMap(op.nothing);\n  }\n  matchChain<RR extends Maybe<unknown>>(op: { nothing: () => RR }) {\n    return this.orChain(op.nothing);\n  }\n}\n\nconst staticNothing = new NothingClass();\n","/**\n * Right (correct) value of type R\n *\n * Either data type specialization representing a correct value\n *\n * @template R underlying value type\n * @template L underlying error type (needed for type merging, in fact alwas considered to be never)\n */\nexport interface Right<R, L> {\n  readonly right: R;\n\n  /**\n   * Either peeker function\n   *\n   * Applied to 'right value' returns self invoking op(value) in process\n   * Applied to 'left error' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Either fallback peeker function\n   *\n   * Applied to 'right value' returns self without invoking callback\n   * Applied to 'left error' returns self invoking op(error) in process\n   *\n   * @param op function to be invoked with underlying error\n   * @returns self\n   */\n  orTap(op: (error: L) => void): this;\n\n  /**\n   * Either pattern matching peeker function\n   *\n   * Applied to 'right value' returns self invoking op.right(value) in process\n   * Applied to 'left error' returns self invoking op.left(error) in process\n   *\n   * @param op.right function to be invoked with underlying value in case of 'right'\n   * @param op.left function to be invoked with underlying error in case of 'left'\n   * @returns self\n   */\n  matchTap(op: { right: (value: R) => void; left: (error: any) => void }): this;\n\n  /**\n   * Either transformer function\n   *\n   * Applied to 'right value' returns 'right op(value)'\n   * Applied to 'left error' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right op(value)' or 'left error'\n   */\n  // Right case\n  map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;\n  // General case\n  map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n  /**\n   * Either fallback transformer function\n   *\n   * Applied to 'right value' returns self without invoking transformer\n   * Applied to 'left error' returns 'right op(error)'\n   *\n   * @param op transformer to be invoked with underlying error\n   * @returns 'right value' or 'right op(error)'\n   */\n  // Right case\n  orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;\n  // General case\n  orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;\n\n  /**\n   * Either pattern matching transformer function\n   *\n   * Applied to 'right value' returns 'right op.right(value)'\n   * Applied to 'left error' returns 'right op.left(error)'\n   *\n   * @template R2 right transformer function's return type\n   * @template R3 left transformer function's return type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'right op.right(value)' or 'right op.left(error)'\n   */\n  // Right case\n  matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2, never>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2 | R3, never>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns 'op(value)'\n   * Applied to 'left error' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'left error'\n   */\n  // Right cases\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;\n  // General cases\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns self without invoking composition function\n   * Applied to 'left error' returns 'op(error)'\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right value' or 'op(error)'\n   */\n  // Right cases\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;\n  // General cases\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;\n\n  /**\n   * Either pattern matching composition function\n   *\n   * Applied to 'right value' returns 'op.right(value)'\n   * Applied to 'left error' returns 'op.left(error)'\n   *\n   * @template R2 right transformer function result's underlying value type\n   * @template L2 right transformer function result's underlying error type\n   * @template R3 left transformer function result's underlying value type\n   * @template L3 left transformer function result's underlying error type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'op(value)' or 'op(error)'\n   */\n  // Right cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Right<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Left<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Right<R3, L3> }): Either<R2, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Left<R3, L3> }): Either<R2, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Either<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Either<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R2, L2>;\n  // General cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R2 | R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Right<R3, L3> }): Either<R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Left<R3, L3> }): Either<R2, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Right<R3, L3> }): Either<R2 | R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Left<R3, L3> }): Either<R2, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R2 | R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R3, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R2 | R3, L2 | L3>;\n\n  /**\n   * Either type guard for 'right'\n   *\n   * @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n   *\n   * @example\n   * ```typescript\n   * if (either.isRight()) {\n   *   console.log(either.right)\n   * }\n   * ```\n   */\n  isRight(): this is Right<R, L>;\n\n  /**\n   * Either type guard for 'left'\n   *\n   * @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n   *\n   * @example\n   * ```typescript\n   * if (either.isLeft()) {\n   *   console.error(either.left)\n   * }\n   * ```\n   */\n  isLeft(): this is Left<R, L>;\n}\n\n/**\n * Left (erroneous) value of type L\n *\n * Either data type specialization representing an erroneous value\n *\n * @remplate R underlying value type (needed for type merging, in fact alwas considered to be never)\n * @template L underlying error type\n */\nexport interface Left<R, L> {\n  readonly left: L;\n\n  /**\n   * Either peeker function\n   *\n   * Applied to 'right value' returns self invoking op(value) in process\n   * Applied to 'left error' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Either fallback peeker function\n   *\n   * Applied to 'right value' returns self without invoking callback\n   * Applied to 'left error' returns self invoking op(error) in process\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  orTap(op: (error: L) => void): this;\n\n  /**\n   * Either pattern matching peeker function\n   *\n   * Applied to 'right value' returns self invoking op.right(value) in process\n   * Applied to 'left error' returns self invoking op.left(error) in process\n   *\n   * @param op.right function to be invoked with underlying value in case of 'right'\n   * @param op.left function to be invoked with underlying error in case of 'left'\n   * @returns self\n   */\n  matchTap(op: { right: (value: R) => void; left: (error: any) => void }): this;\n\n  /**\n   * Either transformer function\n   *\n   * Applied to 'right value' returns 'right op(value)'\n   * Applied to 'left error' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right op(value)' or 'left error'\n   */\n  // Left case\n  map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;\n  // General case\n  map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n  /**\n   * Either fallback transformer function\n   *\n   * Applied to 'right value' returns self without invoking transformer\n   * Applied to 'left error' returns 'right op(error)'\n   *\n   * @param op transformer to be invoked with underlying error\n   * @returns 'right value' or 'right op(error)'\n   */\n  // Left case\n  orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;\n  // General case\n  orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;\n\n  /**\n   * Either pattern matching transformer function\n   *\n   * Applied to 'right value' returns 'right op.right(value)'\n   * Applied to 'left error' returns 'right op.left(error)'\n   *\n   * @template R2 right transformer function's return type\n   * @template R3 left transformer function's return type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'right op.right(value)' or 'right op.left(error)'\n   */\n  // Left case\n  matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R3, never>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2 | R3, never>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns 'op(value)'\n   * Applied to 'left error' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'left error'\n   */\n  // Right cases\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;\n  // General cases\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;\n\n  /**\n   * Either fallback composition function\n   *\n   * Applied to 'right value' returns self without invoking composition function\n   * Applied to 'left error' returns 'op(error)'\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right value' or 'op(error)'\n   */\n  // Left cases\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;\n  // General cases\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;\n\n  /**\n   * Either pattern matching composition function\n   *\n   * Applied to 'right value' returns 'op.right(value)'\n   * Applied to 'left error' returns 'op.left(error)'\n   *\n   * @template R2 right transformer function result's underlying value type\n   * @template L2 right transformer function result's underlying error type\n   * @template R3 left transformer function result's underlying value type\n   * @template L3 left transformer function result's underlying error type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'op(value)' or 'op(error)'\n   */\n  // Left cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R3, L3>;\n  // General cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Right<R3, L3> }): Right<R2 | R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Right<R3, L3> }): Either<R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Left<R3, L3> }): Either<R2, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Left<R3, L3> }): Left<never, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Right<R3, L3> }): Either<R2 | R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Left<R3, L3> }): Either<R2, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R2 | R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R3, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: any) => Either<R3, L3> }): Either<R2 | R3, L2 | L3>;\n\n  /**\n   * Either type guard for 'right'\n   *\n   * @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n   *\n   * @example\n   * ```typescript\n   * if (either.isRight()) {\n   *   console.log(either.right)\n   * }\n   * ```\n   */\n  isRight(): this is Right<R, L>;\n\n  /**\n   * Either type guard for 'left'\n   *\n   * @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n   *\n   * @example\n   * ```typescript\n   * if (either.isLeft()) {\n   *   console.error(either.left)\n   * }\n   * ```\n   */\n  isLeft(): this is Left<R, L>;\n}\n\n/**\n * Either data type: either Right value of type R or Left value of type L\n *\n * As per classic Either monad implementation can eithr contain a right (correct) value or a left (erroneous) value\n * Used throughout the library to represent the result of failable operations, namely failed tasks\n *\n * @template R underlying value type\n * @template L underlying error type\n */\nexport type Either<R, L> = Right<R, L> | Left<R, L>;\n\nexport namespace Right {\n  /**\n   * Standalone Right value extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @template L underlying error type\n   * @param right Right instance\n   * @returns underlying value\n   */\n  export function right<R, L>(right: Right<R, L>) {\n    return right.right;\n  }\n}\n\nexport namespace Left {\n  /**\n   * Standalone Left error extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @template L underlying error type\n   * @param left Left instance\n   * @returns underlying error\n   */\n  export function left<R, L>(left: Left<R, L>) {\n    return left.left;\n  }\n}\n\nexport namespace Either {\n  /**\n   * Right monad constructor\n   *\n   * @template R underlying value type\n   * @param value underlying value\n   * @returns 'right value'\n   */\n  export function right<R>(value: R): Right<R, never> {\n    return new RightClass<R>(value);\n  }\n\n  /**\n   * Left monad constructor\n   *\n   * @template L underlying error type\n   * @param error underlying error\n   * @returns 'left error'\n   */\n  export function left<L>(error: L): Left<never, L> {\n    return new LeftClass<L>(error);\n  }\n\n  /**\n   * Either constructor from optional value\n   *\n   * Resolves to 'left error' in case of undefined value and 'right value' otherwise\n   *\n   * @param value possibly undefined value\n   * @param error error to use in case of undefined value\n   * @returns either 'right value' or 'left error'\n   */\n  export function fromOptional<L>(value: undefined, error: L): Left<never, L>;\n  export function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;\n  export function fromOptional<R, L>(value: R | undefined, error: L): Either<R, L>;\n  export function fromOptional<R, L>(value: R | undefined, error: L) {\n    return typeof value !== 'undefined' ? Either.right(value) : Either.left(error);\n  }\n\n  /**\n   * Either constructor from optional or nullable value\n   *\n   * Resolves to 'left error' in case of undefined or null value and 'right value' otherwise\n   *\n   * @param value possibly undefined or nullable value\n   * @param error error to use in case of undefined or nullable value\n   * @returns either 'right value' or 'left error'\n   */\n  export function fromNullable<L>(value: undefined, error: L): Left<never, L>;\n  export function fromNullable<L>(value: null, error: L): Left<never, L>;\n  export function fromNullable<R>(value: Exclude<R, null | undefined>, error: unknown): Right<R, never>;\n  export function fromNullable<R, L>(value: R | null | undefined, error: L): Either<R, L>;\n  export function fromNullable<R, L>(value: R | null | undefined, error: L) {\n    return Either.fromOptional(value, error).chain((v) => (v !== null ? Either.right(value) : Either.left(error)));\n  }\n\n  /**\n   * Standalone type guard for 'right'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param either Either instance\n   * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')\n   */\n  export function isRight<R, L>(either: Either<R, L>): either is Right<R, never> {\n    return either.isRight();\n  }\n\n  /**\n   * Standalone type guard for 'left'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param either Either instance\n   * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')\n   */\n  export function isLeft<R, L>(either: Either<R, L>): either is Left<never, L> {\n    return either.isLeft();\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case every list element is Right\n   */\n  export function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {\n    return eithers.every(Either.isRight);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case at least one list element is Right\n   */\n  export function someRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {\n    return eithers.some(Either.isRight);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case every list element is Left\n   */\n  export function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {\n    return eithers.every(Either.isLeft);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case at least one list element is Left\n   */\n  export function someLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {\n    return eithers.some(Either.isLeft);\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass RightClass<R> implements Right<R, never> {\n  constructor(readonly right: R) {}\n\n  tap(op: (value: R) => void) {\n    op(this.right);\n\n    return this;\n  }\n  orTap() {\n    return this;\n  }\n  map<R2>(op: (value: R) => R2) {\n    return Either.right(op(this.right));\n  }\n  orMap() {\n    return this;\n  }\n  chain<TT extends Either<unknown, unknown>>(op: (value: R) => TT) {\n    return op(this.right);\n  }\n  orChain() {\n    return this;\n  }\n  isRight(): this is Right<R, never> {\n    return true;\n  }\n  isLeft(): this is Left<R, never> {\n    return false;\n  }\n  matchTap(op: { right: (value: R) => void }) {\n    return this.tap(op.right);\n  }\n  matchMap<R2>(op: { right: (value: R) => R2 }) {\n    return this.map(op.right);\n  }\n  matchChain<TT extends Either<unknown, unknown>>(op: { right: (value: R) => TT }) {\n    return this.chain(op.right);\n  }\n}\n\nclass LeftClass<L> implements Left<never, L> {\n  constructor(readonly left: L) {}\n\n  tap() {\n    return this;\n  }\n  orTap(op: (error: L) => void) {\n    op(this.left);\n\n    return this;\n  }\n  map() {\n    return this;\n  }\n  orMap<R2>(op: (error: L) => R2) {\n    return Either.right(op(this.left));\n  }\n  chain() {\n    return this;\n  }\n  orChain<TT extends Either<unknown, unknown>>(op: (error: L) => TT) {\n    return op(this.left);\n  }\n  isRight(): this is Right<never, L> {\n    return false;\n  }\n  isLeft(): this is Left<never, L> {\n    return true;\n  }\n  matchTap(op: { left: (error: any) => void }) {\n    return this.orTap(op.left);\n  }\n  matchMap<R2>(op: { left: (error: any) => R2 }) {\n    return this.orMap(op.left);\n  }\n  matchChain<TT extends Either<unknown, unknown>>(op: { left: (error: any) => TT }) {\n    return this.orChain(op.left);\n  }\n}\n","import { Maybe, Just } from './maybe';\nimport { Either, Right } from './either';\n\n/**\n * Shortcut for monadic Either type, where erroneous value is of type any\n *\n * @template R underlying type\n */\nexport type Rejectable<R> = Either<R, any>;\n\n/**\n * Shortcut for underlying task result type\n *\n * @template R underlying type\n */\nexport type Cancelable<R> = Maybe<Rejectable<R>>;\n\n/**\n * Function returning Task\n *\n * @template A argument types\n * @template R returned task resolve type\n */\nexport type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;\n\n/**\n * Task generator\n *\n * @template TT yielded task type\n * @template R returned task resolve type\n *\n * @example\n * ```typescript\n * const generatorFunction = function*(): TaskGenerator<unknown, Task<string>, number> {\n *   const v = yield* someTaskFunction().generator();\n *\n *   return v.length;\n * };\n * ```\n */\nexport type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;\n\n/**\n * Function returning task generator (generator function)\n *\n * @template A argument types\n * @template TT yielded task type\n * @template R returned task resolve type\n *\n * @example\n * ```typescript\n * const generatorFunction: TaskGeneratorFunction<[], unknown, Task<string>, number> = function*() {\n *   const v = yield* someTaskFunction().generator();\n *\n *   return v.length;\n * };\n * ```\n */\nexport type TaskGeneratorFunction<A extends unknown[], T, TT extends Task<T>, R> = (...args: A) => TaskGenerator<T, TT, R>;\n\n/**\n * Task monad interface\n *\n * @template R task resolve type\n */\nexport interface Task<R> extends TaskBase<R> {\n  /**\n   * Invoke callback when task is resolved (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tap(op: (value: R) => void): Task<R>;\n\n  /**\n   * Invoke callback when task is rejected (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tapRejected(op: (error: any) => void): Task<R>;\n\n  /**\n   * Invoke callback when task is canceled (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tapCanceled(op: () => void): Task<R>;\n\n  /**\n   * Invoke a dedicated callback according to task resolution\n   *\n   * @param op.resolved callback to invoke on success\n   * @param op.rejected callback to invoke on failure\n   * @param op.canceled callback to invoke on cancelation\n   * @returns self\n   */\n  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R>;\n\n  /**\n   * Invoke transformer when task is resolved (and only then) and return it's result instead\n   *\n   * @template R2 transformer return type\n   * @param op transformer to invoke\n   * @returns task returning transformer result\n   */\n  map<R2>(op: (value: R) => R2): Task<R2>;\n\n  /**\n   * Invoke transformer when task is rejected (and only then) and return it's result instead\n   *\n   * @template R2 fallback return type\n   * @param op transformer to invoke\n   * @returns task returning fallback result in case of failure\n   */\n  mapRejected<R2>(op: (error: any) => R2): Task<R | R2>;\n\n  /**\n   * Invoke transformer when task is canceled (and only then) and return it's result instead\n   *\n   * @template R2 fallback return type\n   * @param op transformer to invoke\n   * @returns task returning fallback result in case of cancelation\n   */\n  mapCanceled<R2>(op: () => R2): Task<R | R2>;\n\n  /**\n   * Invoke a dedicated transformer according to task resolution\n   *\n   * @template R2 success transformer return type\n   * @template R3 failure transformer return type\n   * @template R4 cancelation transformer return type\n   * @param op.resolved transformer to invoke on success\n   * @param op.rejected transformer to invoke on failure\n   * @param op.canceled transformer to invoke on cancelation\n   * @returns task resolving to a corresponding transformer result\n   */\n  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 | R3 | R4>;\n\n  /**\n   * Invoke transformer when task is resolved (and only then) and continue execution with it's result\n   *\n   * @template R2 transformer task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to transformer result task\n   */\n  chain<R2>(op: (value: R) => Task<R2>): Task<R2>;\n\n  /**\n   * Invoke transformer when task is rejected (and only then) and continue execution with it's result\n   *\n   * @template R2 fallback task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to fallback task in case of failure\n   */\n  chainRejected<R2>(op: (error: any) => Task<R2>): Task<R | R2>;\n\n  /**\n   * Invoke transformer when task is canceled (and only then) and continue execution with it's result\n   *\n   * @template R2 fallback task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to fallback task in case of cancelation\n   */\n  chainCanceled<R2>(op: () => Task<R2>): Task<R | R2>;\n\n  /**\n   * Invoke a dedicated transformer according to task resolution and continue execution with it's result\n   *\n   * @template R2 success transformer resolve type\n   * @template R3 failure transformer resolve type\n   * @template R4 cancelation transformer resolve type\n   * @param op.resolved transformer to invoke on success\n   * @param op.rejected transformer to invoke on failure\n   * @param op.canceled transformer to invoke on cancelation\n   * @returns task chaining to a corresponding transformer result\n   */\n  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 | R3 | R4>;\n\n  /**\n   * Return underlying promise in order to await result\n   *\n   * @returns underlying promise\n   */\n  resolve: () => TaskInvoke<R>;\n\n  /**\n   * Invoke underlying canel method without error\n   */\n  cancel: () => void;\n\n  /**\n   * Invoke underlying canel method with error\n   *\n   * @param error error value to be injected from outside\n   */\n  reject: (error: any) => void;\n\n  /**\n   * Wrap task to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of task wrapping the task\n   * @example\n   * ```typescript\n   * const getString = () => Task.resolved('hello');\n   * const getLength = (data: string) => Task.resolved(data.length);\n   *\n   * // ..... //\n   *\n   * Task.generate(function* () {\n   *   const data = yield getString(); // data: string | number\n   *   const length = yield getLength(data); // length: string | number\n   *\n   *   return length;\n   * });\n   *\n   * // ..... //\n   *\n   * Task.generate(function* () {\n   *   const data = yield* getString().generator(); // data: string\n   *   const length = yield* getLength(data).generator(); // length: number\n   *\n   *   return length;\n   * });\n   * ```\n   */\n  generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;\n}\n\nexport namespace Task {\n  /**\n   * Custom task monad constructor\n   *\n   * @template R returned task's resolve type\n   * @param invoke promise defining task execution\n   * @param cancel cancelation function\n   * @returns task resolving to resolve value of invoke\n   *\n   * @note low-level primitive for creating custom tasks, not intended for general use\n   */\n  export function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R> {\n    return new TaskClass<R>(invoke, cancel);\n  }\n\n  /**\n   * Invariant task constructor creating resolved task from plain value\n   *\n   * @template R returned task's resolve type\n   * @param value value to be returned upon awaiting\n   * @returns task resolving to specified value\n   */\n  export function resolved<R>(value: R) {\n    return Task.create<R>(Promise.resolve(Maybe.just(Either.right(value))), () => void undefined);\n  }\n\n  /**\n   * Invariant task constructor creating rejected task from error value\n   *\n   * @template R returned task's resolve type\n   * @param error error to be returned upon awaiting\n   * @returns task resolving to specified value\n   */\n  export function rejected<R>(error: any) {\n    return Task.create<R>(Promise.resolve(Maybe.just(Either.left(error))), () => void undefined);\n  }\n\n  /**\n   * Invariant task constructor creating canceled task\n   *\n   * @template R returned task's resolve type\n   * @returns task resolving to specified value\n   */\n  export function canceled<R>() {\n    return Task.create<R>(Promise.resolve(Maybe.nothing()), () => void undefined);\n  }\n\n  /**\n   * Lift from promise to task resolving to that promise result\n   *\n   * Userfull for converting promises to tasks\n   * If converted task is canceled or failed externally return value will be ignored without side-effects\n   * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n   *\n   * @template R returned task resolve type\n   * @param promise promise to be resolved\n   * @returns task resolving to specified promise value\n   *\n   * @example\n   * ```typescript\n   * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);\n   * ```\n   */\n  export function fromPromise<R>(promise: PromiseLike<R>): Task<R> {\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        promise\n          .then(Either.right, Either.left)\n          .then(Maybe.just)\n          .then(resolve);\n      }),\n      (error: Maybe<any>) => resolve(error.map(Either.left)),\n    );\n  }\n\n  /**\n   * Lift from sync function to task resolving to said function result\n   *\n   * Generally, functions are not considered tasks as they cannot be interrupted in any way\n   * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from\n   * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain\n   * This function is mostly used internally and is not expected to be widely used except of some edge scenarios\n   *\n   * If converted task is canceled or failed externally return value will be ignored without side-effects\n   * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n   *\n   * @template R returned task resolve type\n   * @param producer function to be wrapped to a task\n   * @param cancelRef reference object allowing to set cancelation function prior to invoking function\n   * @returns task resolving to the specified function's result\n   *\n   * @example\n   * ```typescript\n   * const cancelRef = { cancel: () => {} };\n   *\n   * const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);\n   * ```\n   */\n  export function fromFunction<R>(producer: () => R, cancelRef: { cancel: TaskCancel }): Task<R> {\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    const cancel = (error: Maybe<any>) => resolve(error.map(Either.left));\n\n    cancelRef.cancel = cancel;\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        try {\n          resolve(Maybe.just(Either.right(producer())));\n        } catch (e) {\n          resolve(Maybe.just(Either.left(e)));\n        }\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Convinience shortcut for yielding async functions as tasks\n   *\n   * @template R returned generator resolve type\n   * @param promise promise to be resolved\n   * @returns generator to be be used with yield*\n   */\n  export function promiseGenerator<R>(promise: PromiseLike<R>) {\n    return Task.fromPromise(promise).generator();\n  }\n\n  /**\n   * Lift from function returning value/promise to function returning task resolving to that value\n   *\n   * Userfull for converting exising async functions to task functions for further use\n   *\n   * @template A returned function's argument types\n   * @template R returned function's result task's resolve type\n   * @param promiseFunction function returning promise or plain value to be resolved\n   * @returns task function wrapping specified promise function\n   * @see Task.fromPromise\n   *\n   * @example\n   * ```typescript\n   * const taskFunction = liftPromiseFunction(someAsyncOperation);\n   *\n   * const task = taskFunction('someData').map((result) => result.length);\n   * ```\n   */\n  export function lift<A extends unknown[], R>(promiseFunction: (...args: A) => PromiseLike<R>): TaskFunction<A, R> {\n    return (...args: A) => Task.fromPromise(promiseFunction(...args));\n  }\n\n  /**\n   * Create compound task from generator function\n   *\n   * Applying yield to task within the generator function awaits the task and returns underlying value in case of success\n   * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types\n   *\n   * In case of failure an error is thrown and may be caught by try-catch\n   *\n   * If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately\n   *\n   * @template TT yielded task type\n   * @template R returned task resolve type\n   * @param taskGeneratorFunction task generator function\n   * @returns task resolving to generator's return type\n   *\n   * @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield\n   * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly\n   *\n   * @example\n   * ```typescript\n   * const task = Task.generate(function*() {\n   *   try {\n   *     const value1 = yield* delayedValueTask('data', 400).generator();\n   *\n   *     const value2 = yield* delayedValueTask(value1.length, 300).generator();\n   *\n   *     return value2;\n   *   } catch (e) {\n   *     return -1;\n   *   }\n   * });\n   * ```\n   */\n  export function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R> {\n    const generator = taskGeneratorFunction();\n\n    const sequentor = (next: IteratorResult<TT, R>): Task<R> => {\n      return next.done\n        ? Task.resolved(next.value)\n        : next.value.matchChain<R>({\n            resolved: (value) => sequentor(generator.next(value)),\n            rejected: (error) => sequentor(generator.throw(error)),\n            canceled: Task.canceled,\n          });\n    };\n\n    return Task.resolved(undefined).chain(() => sequentor(generator.next()));\n  }\n\n  /**\n   * Generic timeout task\n   *\n   * Usefull for creating delays in task chains or implementing limiting tasks\n   *\n   * @param delay duration in ms after that the task resolves to void\n   * @returns task resolving to void (undefined) after specified delay\n   *\n   * @example\n   * ```typescript\n   * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);\n   * // ... //\n   * const value = yield* delayedValueTask(42, 1000).generator();\n   *\n   * console.log(\"It's past 1 second and here's a value:\", value)\n   * ```\n   */\n  export function timeout(delay: number) {\n    return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n  }\n\n  /**\n   * Generic callback task\n   *\n   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction\n   *\n   * @param create task body with success and error callbacks\n   * @param cancel cancelation function intended for stopping task execution\n   * @returns task resolving to success value\n   *\n   * @example\n   * ```typescript\n   * export function timeout(delay: number) {\n   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n   * }\n   * ```\n   */\n  export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void) => H, cancel: (handler: H) => void): Task<R> {\n    let handler: H;\n\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        handler = create(\n          (r) => resolve(Maybe.just(Either.right(r))),\n          (e) => resolve(Maybe.just(Either.left(e))),\n        );\n      }),\n      (error: Maybe<any>) => {\n        resolve(error.map(Either.left));\n\n        cancel(handler);\n      },\n    );\n  }\n\n  /**\n   * Start multiple tasks one after another\n   *\n   * @param taskFunctions list of task functions (without arguments)\n   * @returns composite task invoring every task in order and resolving to the list of results\n   */\n  export function sequence<T>(taskFunctions: Iterable<TaskFunction<[], T>>): Task<T[]> {\n    return Array.from(taskFunctions).reduce((prev, taskFunction) => {\n      return prev.chain((list) => {\n        return taskFunction().map((value) => list.concat(value));\n      });\n    }, Task.resolved<T[]>([]));\n  }\n\n  /**\n   * Execute all tasks in parallel and return list of results\n   *\n   * Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order\n   * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled\n   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n   *\n   * @note direct equivalent of Promise.all\n   *\n   * @template T underlying task type\n   * @param tasks iterable of tasks to execute\n   * @retuirns task resolving to the list of results\n   */\n  export function all<T>(tasks: Iterable<Task<T>>) {\n    const [resolve, setResolve] = resolver<Cancelable<T[]>>();\n\n    const taskArray = Array.from(tasks);\n\n    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));\n\n    const list = taskArray.map<Maybe<T>>(Maybe.nothing);\n\n    const resolved = (value: T, i: number) => {\n      list[i] = Maybe.just(value);\n\n      if (Maybe.everyJust(list)) {\n        resolve(Maybe.just(Either.right(list.map(Just.just))));\n      }\n    };\n    const rejected = (error: Maybe<any>) => {\n      resolve(error.map(Either.left));\n      cancel(error);\n    };\n\n    return Task.create(\n      new Promise<Cancelable<T[]>>((_resolve) => {\n        setResolve(_resolve);\n\n        if (taskArray.length < 1) {\n          return resolve(Maybe.just(Either.right([])));\n        }\n\n        taskArray.map((task, i) => {\n          return task.matchTap({\n            resolved: (value) => resolved(value, i),\n            rejected: (error) => rejected(Maybe.just(error)),\n            canceled: () => rejected(Maybe.nothing()),\n          });\n        });\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Execute all tasks in parallel and return the result of the first successful one\n   *\n   * Resulting task resolves when the first tasks is successfuly resolved, returning it's result\n   * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors\n   * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors\n   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n   *\n   * @note direct equivalent of Promise.any\n   *\n   * @template T underlying task type\n   * @param tasks iterable of tasks to execute\n   * @retuirns task resolving to the result of first successfull task\n   */\n  export function any<T>(tasks: Iterable<Task<T>>) {\n    const [resolve, setResolve] = resolver<Cancelable<T>>();\n\n    const taskArray = Array.from(tasks);\n\n    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));\n\n    const list = taskArray.map<Maybe<any>>(Maybe.nothing);\n\n    const resolved = (value: Maybe<T>) => {\n      resolve(value.map(Either.right));\n      cancel(Maybe.nothing());\n    };\n    const rejected = (error: any, i: number) => {\n      list[i] = Maybe.just(error);\n\n      if (Maybe.everyJust(list)) {\n        resolve(Maybe.just(Either.left(list.map(Just.just))));\n      }\n    };\n\n    return Task.create(\n      new Promise<Cancelable<T>>((_resolve) => {\n        setResolve(_resolve);\n\n        if (taskArray.length < 1) {\n          return resolve(Maybe.nothing());\n        }\n\n        taskArray.map((task, i) => {\n          return task.matchTap({\n            resolved: (value) => resolved(Maybe.just(value)),\n            rejected: (error) => rejected(error, i),\n            canceled: () => resolved(Maybe.nothing()),\n          });\n        });\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Limit task execution based on another task\n   *\n   * If the second task resolves sooner than the first, resulting task is canceled\n   * Otherwise the resulting task resolves together with the first one\n   *\n   * @param task task to limit\n   * @param limitTask limiting task\n   * @returns task limites according to limitTask\n   */\n  export function limit<T>(task: Task<T>, limitTask: Task<void>) {\n    return Task.any<T>([task, limitTask.chain<T>(Task.canceled)]).chainRejected((errors) => Task.rejected<T>(errors[0]));\n  }\n\n  /**\n   * Repeat task untill successful\n   *\n   * Given task is re-generated in case of failure (both external and internal)\n   * Resulting task is still cancelable by standard means\n   *\n   * @param taskFunction task preoducing function\n   */\n  export function repeat<T>(taskFunction: TaskFunction<[], T>) {\n    const sequentor = (): Task<T> => taskFunction().chainRejected(sequentor);\n\n    return sequentor();\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\ntype TaskInvoke<R> = Promise<Cancelable<R>>;\ntype TaskCancel = (error: Maybe<any>) => void;\n\n/**\n * @hidden\n */\ninterface TaskBase<R> {\n  /**\n   * @hidden\n   */\n  readonly _invoke: TaskInvoke<R>;\n  /**\n   * @hidden\n   */\n  readonly _cancel: TaskCancel;\n}\n\nconst resolver = <T>() => {\n  const stub: (t: T) => void = () => void undefined;\n\n  let globalResolve = stub;\n\n  const resolve = (value: T) => {\n    const r = globalResolve;\n\n    globalResolve = stub;\n\n    r(value);\n  };\n\n  const setResolve = (value: typeof resolve) => {\n    globalResolve = value;\n  };\n\n  return [resolve, setResolve] as [typeof resolve, typeof setResolve];\n};\n\nfunction chainTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Task<R2>) {\n  const globalCancel = { cancel: _task._cancel };\n\n  return Task.create(\n    _task._invoke.then(async (result) => {\n      // Tecnically it's not possible to throw here anymore as op is lifted into task now, but just in case\n      try {\n        const { _invoke: invoke2, _cancel: cancel2 } = Task.fromFunction(() => op(result), globalCancel);\n\n        globalCancel.cancel = cancel2;\n\n        const produced = await invoke2;\n\n        if (produced.isNothing()) {\n          return Maybe.nothing();\n        }\n\n        if (produced.just.isLeft()) {\n          return Maybe.just(Either.left(produced.just.left));\n        }\n\n        const { _invoke: invoke3, _cancel: cancel3 } = produced.just.right;\n\n        globalCancel.cancel = cancel3;\n\n        return invoke3;\n      } catch (e) {\n        return Maybe.just(Either.left(e));\n      }\n    }),\n    (error: Maybe<any>) => globalCancel.cancel(error),\n  );\n}\n\nfunction chainTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Task<R2>) {\n  return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);\n}\n\nfunction mapTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Cancelable<R2>) {\n  return chainTaskMaybe<R, R2>(_task, (maybe) => {\n    return op(maybe).matchMap<Task<R2>>({\n      just: (either) =>\n        either.matchMap<Task<R2>>({\n          right: Task.resolved,\n          left: Task.rejected,\n        }).right,\n      nothing: Task.canceled,\n    }).just;\n  });\n}\n\nfunction mapTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Rejectable<R2>) {\n  return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));\n}\n\nfunction tapTaskMaybe<R>(_task: TaskBase<R>, op: (value: Cancelable<R>) => void) {\n  return mapTaskMaybe<R, R>(_task, (value) => {\n    op(value);\n\n    return value;\n  });\n}\n\nfunction tapTaskEither<R>(_task: TaskBase<R>, op: (value: Rejectable<R>) => void) {\n  return tapTaskMaybe<R>(_task, (maybe) => maybe.tap(op));\n}\n\nclass TaskClass<R> implements Task<R> {\n  constructor(readonly _invoke: TaskInvoke<R>, readonly _cancel: TaskCancel) {}\n\n  tapCanceled(op: () => void) {\n    return tapTaskMaybe<R>(this, (maybe) => maybe.orTap(op));\n  }\n  tapRejected(op: (error: any) => void) {\n    return tapTaskEither<R>(this, (either) => either.orTap(op));\n  }\n  tap(op: (value: R) => void) {\n    return tapTaskEither<R>(this, (either) => either.tap(op));\n  }\n\n  mapCanceled<R2>(op: () => R2) {\n    return mapTaskMaybe<R, R | R2>(this, (maybe) => maybe.orMap(() => Either.right(op())));\n  }\n  mapRejected<R2>(op: (error: any) => R2) {\n    return mapTaskEither<R, R | R2>(this, (either) => either.orMap(op));\n  }\n  map<R2>(op: (value: R) => R2) {\n    return mapTaskEither<R, R2>(this, (either) => either.map(op));\n  }\n\n  chainCanceled<R2>(op: () => Task<R2>) {\n    const mapEither = (either: Rejectable<R>) => either.map(Task.resolved).orMap<Task<R>>(Task.rejected).right;\n\n    return chainTaskMaybe<R, R | R2>(this, (maybe) => maybe.map(mapEither).orMap(op).just);\n  }\n  chainRejected<R2>(op: (error: any) => Task<R2>) {\n    return chainTaskEither<R, R | R2>(this, (either) => either.map(Task.resolved).orMap(op).right);\n  }\n  chain<R2>(op: (value: R) => Task<R2>) {\n    return chainTaskEither<R, R2>(this, (either) => either.map(op).orMap<Task<R2>>(Task.rejected).right);\n  }\n\n  resolve() {\n    return this._invoke;\n  }\n  cancel() {\n    return this._cancel(Maybe.nothing());\n  }\n  reject(error: any) {\n    return this._cancel(Maybe.just(error));\n  }\n\n  generator() {\n    return (function*(task) {\n      return (yield task) as R;\n    })(this);\n  }\n\n  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }) {\n    return tapTaskMaybe(this, (maybe) => {\n      return maybe.matchTap({\n        just: (either) => {\n          return either.matchTap({\n            right: op.resolved,\n            left: op.rejected,\n          });\n        },\n        nothing: op.canceled,\n      });\n    });\n  }\n\n  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }) {\n    return mapTaskMaybe(this, (maybe) => {\n      return maybe.matchMap<Right<R2 | R3 | R4, any>>({\n        just: (either) => {\n          return either.matchMap({\n            right: op.resolved,\n            left: op.rejected,\n          });\n        },\n        nothing: () => Either.right(op.canceled()),\n      });\n    });\n  }\n\n  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }) {\n    return chainTaskMaybe(this, (maybe) => {\n      return maybe.matchMap<Task<R2 | R3 | R4>>({\n        just: (either) => {\n          return either.matchMap<Task<R2 | R3>>({\n            right: op.resolved,\n            left: op.rejected,\n          }).right;\n        },\n        nothing: op.canceled,\n      }).just;\n    });\n  }\n}\n"],"names":["Just","Maybe","just","value","JustClass","staticNothing","nothing","fromOptional","chain","v","maybe","isJust","isNothing","maybes","every","some","constructor","this","tap","op","orTap","map","orMap","orChain","matchTap","matchMap","matchChain","Right","Left","Either","Task","right","left","RightClass","error","LeftClass","either","isRight","isLeft","eithers","fromCallback","create","cancel","handler","resolve","setResolve","resolver","Promise","_resolve","r","e","invoke","TaskClass","promise","then","producer","cancelRef","fromPromise","generator","promiseFunction","taskGeneratorFunction","sequentor","next","done","resolved","rejected","throw","canceled","undefined","delay","setTimeout","clearTimeout","taskFunctions","Array","from","reduce","prev","taskFunction","list","concat","tasks","taskArray","forEach","task","_cancel","length","i","everyJust","limitTask","any","chainRejected","errors","stub","globalResolve","chainTaskMaybe","_task","globalCancel","_invoke","result","invoke2","cancel2","fromFunction","produced","invoke3","cancel3","chainTaskEither","mapTaskMaybe","mapTaskEither","tapTaskMaybe","tapTaskEither","tapCanceled","tapRejected","mapCanceled","mapRejected","chainCanceled","mapEither","reject"],"mappings":"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"}
+{"version":3,"file":"t-tasks.esm.js","sources":["../src/maybe.ts","../src/either.ts","../src/task.ts"],"sourcesContent":["/**\n * Just a value\n *\n * Maybe data type specialization representing an existing value\n *\n * @template R underlying value\n */\nexport interface Just<R> {\n  readonly just: R;\n\n  /**\n   * Maybe peeker function\n   *\n   * Applied to 'just value' returns self invoking op(value) in process\n   * Applied to 'nothing' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Maybe fallback peeker function\n   *\n   * Applied to 'just value' returns self without invoking callback\n   * Applied to 'nothing' returns self invoking op() in process\n   *\n   * @param op function to be invoked\n   * @returns self\n   */\n  orTap(op: () => void): this;\n\n  /**\n   * Maybe patter matching peeker function\n   *\n   * Applied to 'just value' returns self invoking op.just(value) in process\n   * Applied to 'nothing' returns self invoking op.nothing() in process\n   *\n   * @param op.just function to be invoked with underlying value in case of just\n   * @param op.nothing function to be invoked in case of nothing\n   * @returns self\n   */\n  matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n  /**\n   * Maybe transformer function\n   *\n   * Applied to 'just value' returns 'just op(value)'\n   * Applied to 'nothing' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'just op(value)' or 'nothing'\n   */\n  // Just case\n  map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;\n  // Generic case\n  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n  /**\n   * Maybe fallback transformer function\n   *\n   * Applied to 'just value' returns self without invoking transformer\n   * Applied to 'nothing' returns 'just op()'\n   *\n   * @param op function to be invoked\n   * @returns 'just value' or 'just op()'\n   */\n  // Just case\n  orMap<R2>(this: Just<R>, op: () => R2): Just<R>;\n  // Generic case\n  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;\n\n  /**\n   * Maybe patter matching transformer function\n   *\n   * Applied to 'just value' returns 'just op.just(value)'\n   * Applied to 'nothing' returns 'just op.nothing()'\n   *\n   * @template R2 just transformer function's return type\n   * @template R3 nothing transformer function's return type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'just op.just(value)' or 'just op.nothing()'\n   */\n  // Just cases\n  matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;\n\n  /**\n   * Maybe composition function\n   *\n   * Applied to 'just value' returns 'op(value)'\n   * Applied to 'nothing' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'nothing'\n   */\n  // Just cases\n  chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;\n  chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n  // General cases\n  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n  /**\n   * Maybe fallback composition function\n   *\n   * Applied to 'just value' returns self witjout invoking composition function\n   * Applied to 'nothing' returns op()\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked\n   * @returns 'just value' or 'op()'\n   */\n  // Just cases\n  orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;\n  orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;\n  orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;\n  // General case\n  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;\n  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;\n\n  /**\n   * Maybe patter matching composition function\n   *\n   * Applied to 'just value' returns 'op.just(value)'\n   * Applied to 'nothing' returns op.nothing()\n   *\n   * @template R2 just transformer function result's underlying type\n   * @template R3 nothing transformer function result's underlying type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'op.just(value)' or 'op.nothing()'\n   */\n  // Just cases\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Just<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2>;\n  // General cases\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n\n  /**\n   * Maybe type guard for 'just'\n   *\n   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isJust()) {\n   *   console.log(maybe.just);\n   * }\n   * ```\n   */\n  isJust(): this is Just<R>;\n\n  /**\n   * Maybe type guard for 'nothing'\n   *\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isNohing()) {\n   *   console.log('nothing');\n   * }\n   * ```\n   */\n  isNothing(): this is Nothing<R>;\n\n  /**\n   * Wrap Maybe to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of Maybe wrapping this\n   */\n  generator: MaybeGeneratorFunction<[], R, Just<R>, R>\n}\n\n/**\n * Absolutely Nothing\n *\n * Maybe data type specialiation representing an absence of any value\n */\nexport interface Nothing<R> {\n  /**\n   * Maybe peeker function\n   *\n   * Applied to 'just value' returns self invoking op(value) in process\n   * Applied to 'nothing' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Maybe fallback peeker function\n   *\n   * Applied to 'just value' returns self without invoking callback\n   * Applied to 'nothing' returns self invoking op() in process\n   *\n   * @param op function to be invoked\n   * @returns self\n   */\n  orTap(op: () => void): this;\n\n  /**\n   * Maybe patter matching peeker function\n   *\n   * Applied to 'just value' returns self invoking op.just(value) in process\n   * Applied to 'nothing' returns self invoking op.nothing() in process\n   *\n   * @param op.just function to be invoked with underlying value in case of just\n   * @param op.nothing function to be invoked in case of nothing\n   * @returns self\n   */\n  matchTap(op: { just: (value: R) => void; nothing: () => void }): this;\n\n  /**\n   * Maybe transformer function\n   *\n   * Applied to 'just value' returns 'just op(value)'\n   * Applied to 'nothing' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'just op(value)' or 'nothing'\n   */\n  // Nothing case\n  map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;\n  // Generic case\n  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;\n\n  /**\n   * Maybe fallback transformer function\n   *\n   * Applied to 'just value' returns self without invoking transformer\n   * Applied to 'nothing' returns 'just op()'\n   *\n   * @param op function to be invoked\n   * @returns 'just value' or 'just op()'\n   */\n  // Nothing case\n  orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;\n  // Generic case\n  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;\n\n  /**\n   * Maybe patter matching transformer function\n   *\n   * Applied to 'just value' returns 'just op.just(value)'\n   * Applied to 'nothing' returns 'just op.nothing()'\n   *\n   * @template R2 just transformer function's return type\n   * @template R3 nothing transformer function's return type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'just op.just(value)' or 'just op.nothing()'\n   */\n  // Nothing cases\n  matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;\n  // General cases\n  matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;\n\n  /**\n   * Maybe composition function\n   *\n   * Applied to 'just value' returns 'op(value)'\n   * Applied to 'nothing' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'nothing'\n   */\n  // Nothing cases\n  chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;\n  chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;\n  // General cases\n  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;\n  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;\n\n  /**\n   * Maybe fallback composition function\n   *\n   * Applied to 'just value' returns self witjout invoking composition function\n   * Applied to 'nothing' returns op()\n   *\n   * @template R2 transformer function result's underlying type\n   * @param op transformer to be invoked\n   * @returns 'just value' or 'op()'\n   */\n  // Nothing cases\n  orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;\n  orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;\n  orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;\n  // General cases\n  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;\n  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;\n  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;\n\n  /**\n   * Maybe patter matching composition function\n   *\n   * Applied to 'just value' returns 'op.just(value)'\n   * Applied to 'nothing' returns op.nothing()\n   *\n   * @template R2 just transformer function result's underlying type\n   * @template R3 nothing transformer function result's underlying type\n   * @param op.just transformer to be invoked with underlying value in case of just\n   * @param op.nothing transformer to be invoked in case of nothing\n   * @returns 'op.just(value)' or 'op.nothing()'\n   */\n  // Nothing cases\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Just<R3>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  // General cases\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Just<R3> }): Just<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Just<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Nothing<R3> }): Nothing<never>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Just<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Nothing<R2>; nothing: () => Maybe<R3> }): Maybe<R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Just<R3> }): Maybe<R2 | R3>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Nothing<R3> }): Maybe<R2>;\n  matchChain<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => Maybe<R2>; nothing: () => Maybe<R3> }): Maybe<R2 | R3>;\n\n  /**\n   * Maybe type guard for 'just'\n   *\n   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isJust()) {\n   *   console.log(maybe.just);\n   * }\n   * ```\n   */\n  isJust(): this is Just<R>;\n\n  /**\n   * Maybe type guard for 'nothing'\n   *\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')\n   *\n   * @example\n   * ```typescript\n   * if (maybe.isNohing()) {\n   *   console.log('nothing');\n   * }\n   * ```\n   */\n  isNothing(): this is Nothing<R>;\n\n  /**\n   * Wrap Maybe to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of Maybe wrapping this\n   */\n  generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>\n}\n\n/**\n * Genric Maybe monad interface\n *\n * As per classic Maybe monad implementation can eithr contain just a value or contain nothing\n * Used throughout the library to represent optional return type, specifically return type of cancelled tasks\n *\n * @template R underlying value\n */\nexport type Maybe<R> = Just<R> | Nothing<R>;\n\nexport namespace Just {\n  /**\n   * Standalone Just value extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @param just Just instance\n   * @returns underlying value\n   */\n  export function just<R>(just: Just<R>) {\n    return just.just;\n  }\n}\n\nexport namespace Nothing {}\n\nexport type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;\nexport type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;\n\nexport namespace Maybe {\n  /**\n   * Non-empty monad constructor\n   *\n   * @template R underlying type\n   * @param value underlying value\n   * @returns 'just value'\n   */\n  export function just<R>(value: R): Just<R> {\n    return new JustClass<R>(value);\n  }\n\n  /**\n   * Empty monad constructor\n   *\n   * @returns 'nothing'\n   */\n  export function nothing(): Nothing<never> {\n    return staticNothing;\n  }\n\n  /**\n   * Maybe constructor from optional value\n   *\n   * Resolves to 'nothing' in case of undefined value and 'just value' otherwise\n   *\n   * @param value possibly undefined value\n   * @returns either 'just value' or 'nothing'\n   */\n  export function fromOptional(value: undefined): Nothing<never>;\n  export function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;\n  export function fromOptional<R>(value: R | undefined): Maybe<R>;\n  export function fromOptional<R>(value: R | undefined) {\n    return typeof value !== 'undefined' ? Maybe.just(value) : Maybe.nothing();\n  }\n\n  /**\n   * Maybe constructor from optional or nullable value\n   *\n   * Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise\n   *\n   * @param value possibly undefined value\n   * @returns either 'just value' or 'nothing'\n   */\n  export function fromNullable(value: undefined): Nothing<never>;\n  export function fromNullable(value: null): Nothing<never>;\n  export function fromNullable<R>(value: Exclude<R, null | undefined>): Just<R>;\n  export function fromNullable<R>(value: R | null | undefined): Maybe<R>;\n  export function fromNullable<R>(value: R | null | undefined) {\n    return Maybe.fromOptional(value).chain((v) => (v !== null ? Maybe.just(v) : Maybe.nothing()));\n  }\n\n  /**\n   * Standalone type guard for 'just'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param maybe Maybe instance\n   * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')\n   */\n  export function isJust<R>(maybe: Maybe<R>): maybe is Just<R> {\n    return maybe.isJust();\n  }\n\n  /**\n   * Standalone type guard for 'nothing'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param maybe Maybe instance\n   * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')\n   */\n  export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<never> {\n    return maybe.isNothing();\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case every list element is Just\n   */\n  export function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {\n    return maybes.every(Maybe.isJust);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case al east one list element is Just\n   */\n  export function someJust<R>(maybes: Maybe<R>[]): boolean {\n    return maybes.some(Maybe.isJust);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case every list element is Nothing\n   */\n  export function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {\n    return maybes.every(Maybe.isNothing);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param maybes a list of Maybe\n   * @returns true in case at least one list element is Nothing\n   */\n  export function someNothing<R>(maybes: Maybe<R>[]): boolean {\n    return maybes.some(Maybe.isNothing);\n  }\n\n  /**\n   * Create compound Maybe from generator function\n   *\n   * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success\n   * However the convinient option for typescript is to use ```yield* maybe.generator()``` as othervise one may have to deal with union types\n   *\n   * @template TT yielded Maybe type\n   * @template R returned underlying type\n   * @param maybeGeneratorFunction Maybe generator function\n   * @returns Just wrapping the result of generator function or Nothing\n   * ```\n   */\n  export function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R> {\n    const generator = maybeGeneratorFunction();\n\n    const sequentor = (next: IteratorResult<TT, R>): Maybe<R> => {\n      return next.done ? (\n        Maybe.just(next.value)\n      ) : (\n        next.value.matchChain<R>({\n          just: (value) => sequentor(generator.next(value)),\n          nothing: Maybe.nothing,\n        })\n      );\n    };\n\n    return Maybe.just(undefined).chain(() => sequentor(generator.next()));\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass JustClass<R> implements Just<R> {\n  constructor(readonly just: R) {}\n\n  tap(op: (value: R) => void) {\n    op(this.just);\n\n    return this;\n  }\n  orTap() {\n    return this;\n  }\n  map<R2>(op: (value: R) => R2) {\n    return Maybe.just(op(this.just));\n  }\n  orMap() {\n    return this;\n  }\n  chain<RR extends Maybe<unknown>>(op: (value: R) => RR) {\n    return op(this.just);\n  }\n  orChain() {\n    return this;\n  }\n  isJust(): this is Just<R> {\n    return true;\n  }\n  isNothing(): this is Nothing<R> {\n    return false;\n  }\n  matchTap(op: { just: (value: R) => void }) {\n    return this.tap(op.just);\n  }\n  matchMap<R2>(op: { just: (value: R) => R2 }) {\n    return this.map(op.just);\n  }\n  matchChain<RR extends Maybe<unknown>>(op: { just: (value: R) => RR }) {\n    return this.chain(op.just);\n  }\n  generator() {\n    return (function*(value) {\n      return (yield value) as R;\n    })(this);\n  }\n}\n\nclass NothingClass implements Nothing<never> {\n  tap() {\n    return this;\n  }\n  orTap(op: () => void) {\n    op();\n\n    return this;\n  }\n  map() {\n    return this;\n  }\n  orMap<R2>(op: () => R2) {\n    return Maybe.just(op());\n  }\n  chain() {\n    return this;\n  }\n  orChain<RR extends Maybe<unknown>>(op: () => RR) {\n    return op();\n  }\n  isJust(): this is Just<never> {\n    return false;\n  }\n  isNothing(): this is Nothing<never> {\n    return true;\n  }\n  matchTap(op: { nothing: () => void }) {\n    return this.orTap(op.nothing);\n  }\n  matchMap<R2>(op: { nothing: () => R2 }) {\n    return this.orMap(op.nothing);\n  }\n  matchChain<RR extends Maybe<unknown>>(op: { nothing: () => RR }) {\n    return this.orChain(op.nothing);\n  }\n  generator() {\n    return (function*(value) {\n      return (yield value) as never;\n    })(this);\n  }\n}\n\nconst staticNothing = new NothingClass();\n","/**\n * Right (correct) value of type R\n *\n * Either data type specialization representing a correct value\n *\n * @template R underlying value type\n * @template L underlying error type (needed for type merging, in fact alwas considered to be never)\n */\nexport interface Right<R, L> {\n  readonly right: R;\n\n  /**\n   * Either peeker function\n   *\n   * Applied to 'right value' returns self invoking op(value) in process\n   * Applied to 'left error' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Either fallback peeker function\n   *\n   * Applied to 'right value' returns self without invoking callback\n   * Applied to 'left error' returns self invoking op(error) in process\n   *\n   * @param op function to be invoked with underlying error\n   * @returns self\n   */\n  orTap(op: (error: L) => void): this;\n\n  /**\n   * Either pattern matching peeker function\n   *\n   * Applied to 'right value' returns self invoking op.right(value) in process\n   * Applied to 'left error' returns self invoking op.left(error) in process\n   *\n   * @param op.right function to be invoked with underlying value in case of 'right'\n   * @param op.left function to be invoked with underlying error in case of 'left'\n   * @returns self\n   */\n  matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n  /**\n   * Either transformer function\n   *\n   * Applied to 'right value' returns 'right op(value)'\n   * Applied to 'left error' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right op(value)' or 'left error'\n   */\n  // Right case\n  map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;\n  // General case\n  map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n  /**\n   * Either fallback transformer function\n   *\n   * Applied to 'right value' returns self without invoking transformer\n   * Applied to 'left error' returns 'right op(error)'\n   *\n   * @param op transformer to be invoked with underlying error\n   * @returns 'right value' or 'right op(error)'\n   */\n  // Right case\n  orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;\n  // General case\n  orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;\n\n  /**\n   * Either pattern matching transformer function\n   *\n   * Applied to 'right value' returns 'right op.right(value)'\n   * Applied to 'left error' returns 'right op.left(error)'\n   *\n   * @template R2 right transformer function's return type\n   * @template R3 left transformer function's return type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'right op.right(value)' or 'right op.left(error)'\n   */\n  // Right case\n  matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 | R3, never>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns 'op(value)'\n   * Applied to 'left error' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'left error'\n   */\n  // Right cases\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;\n  chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;\n  // General cases\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns self without invoking composition function\n   * Applied to 'left error' returns 'op(error)'\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right value' or 'op(error)'\n   */\n  // Right cases\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;\n  orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;\n  // General cases\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;\n\n  /**\n   * Either pattern matching composition function\n   *\n   * Applied to 'right value' returns 'op.right(value)'\n   * Applied to 'left error' returns 'op.left(error)'\n   *\n   * @template R2 right transformer function result's underlying value type\n   * @template L2 right transformer function result's underlying error type\n   * @template R3 left transformer function result's underlying value type\n   * @template L3 left transformer function result's underlying error type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'op(value)' or 'op(error)'\n   */\n  // Right cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Right<R2, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Left<never, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2, L2>;\n  // General cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 | R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 | R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 | R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 | R3, L2 | L3>;\n\n  /**\n   * Either type guard for 'right'\n   *\n   * @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n   *\n   * @example\n   * ```typescript\n   * if (either.isRight()) {\n   *   console.log(either.right)\n   * }\n   * ```\n   */\n  isRight(): this is Right<R, L>;\n\n  /**\n   * Either type guard for 'left'\n   *\n   * @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n   *\n   * @example\n   * ```typescript\n   * if (either.isLeft()) {\n   *   console.error(either.left)\n   * }\n   * ```\n   */\n  isLeft(): this is Left<R, L>;\n\n  /**\n   * Wrap Maybe to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of Maybe wrapping this\n   */\n   generator: EitherGeneratorFunction<[], R, Right<R, L>, R>\n}\n\n/**\n * Left (erroneous) value of type L\n *\n * Either data type specialization representing an erroneous value\n *\n * @remplate R underlying value type (needed for type merging, in fact alwas considered to be never)\n * @template L underlying error type\n */\nexport interface Left<R, L> {\n  readonly left: L;\n\n  /**\n   * Either peeker function\n   *\n   * Applied to 'right value' returns self invoking op(value) in process\n   * Applied to 'left error' returns self without invoking callback\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  tap(op: (value: R) => void): this;\n\n  /**\n   * Either fallback peeker function\n   *\n   * Applied to 'right value' returns self without invoking callback\n   * Applied to 'left error' returns self invoking op(error) in process\n   *\n   * @param op function to be invoked with underlying value\n   * @returns self\n   */\n  orTap(op: (error: L) => void): this;\n\n  /**\n   * Either pattern matching peeker function\n   *\n   * Applied to 'right value' returns self invoking op.right(value) in process\n   * Applied to 'left error' returns self invoking op.left(error) in process\n   *\n   * @param op.right function to be invoked with underlying value in case of 'right'\n   * @param op.left function to be invoked with underlying error in case of 'left'\n   * @returns self\n   */\n  matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;\n\n  /**\n   * Either transformer function\n   *\n   * Applied to 'right value' returns 'right op(value)'\n   * Applied to 'left error' returns self without invoking transformer\n   *\n   * @template R2 transformer function's return type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right op(value)' or 'left error'\n   */\n  // Left case\n  map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;\n  // General case\n  map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;\n\n  /**\n   * Either fallback transformer function\n   *\n   * Applied to 'right value' returns self without invoking transformer\n   * Applied to 'left error' returns 'right op(error)'\n   *\n   * @param op transformer to be invoked with underlying error\n   * @returns 'right value' or 'right op(error)'\n   */\n  // Left case\n  orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;\n  // General case\n  orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;\n\n  /**\n   * Either pattern matching transformer function\n   *\n   * Applied to 'right value' returns 'right op.right(value)'\n   * Applied to 'left error' returns 'right op.left(error)'\n   *\n   * @template R2 right transformer function's return type\n   * @template R3 left transformer function's return type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'right op.right(value)' or 'right op.left(error)'\n   */\n  // Left case\n  matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;\n  // General case\n  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2 | R3, never>;\n\n  /**\n   * Either composition function\n   *\n   * Applied to 'right value' returns 'op(value)'\n   * Applied to 'left error' returns self without invoking composition function\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'op(value)' or 'left error'\n   */\n  // Right cases\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;\n  chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;\n  // General cases\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;\n  chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;\n\n  /**\n   * Either fallback composition function\n   *\n   * Applied to 'right value' returns self without invoking composition function\n   * Applied to 'left error' returns 'op(error)'\n   *\n   * @template R2 transformer function result's underlying value type\n   * @template L2 transformer function result's underlying error type\n   * @param op transformer to be invoked with underlying value\n   * @returns 'right value' or 'op(error)'\n   */\n  // Left cases\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;\n  orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;\n  // General cases\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;\n  orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;\n\n  /**\n   * Either pattern matching composition function\n   *\n   * Applied to 'right value' returns 'op.right(value)'\n   * Applied to 'left error' returns 'op.left(error)'\n   *\n   * @template R2 right transformer function result's underlying value type\n   * @template L2 right transformer function result's underlying error type\n   * @template R3 left transformer function result's underlying value type\n   * @template L3 left transformer function result's underlying error type\n   * @param op.right transformer to be invoked with underlying value in case of 'right'\n   * @param op.left transformer to be invoked with underlying error in case of 'left'\n   * @returns 'op(value)' or 'op(error)'\n   */\n  // Left cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L3>;\n  // General cases\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Right<R3, L3> }): Right<R2 | R3, never>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Left<R3, L3> }): Left<never, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Right<R3, L3> }): Either<R2 | R3, L2>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Left<R3, L3> }): Either<R2, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 | R3, L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Left<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R3, L2 | L3>;\n  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Either<R2, L2>; left: (error: L) => Either<R3, L3> }): Either<R2 | R3, L2 | L3>;\n\n  /**\n   * Either type guard for 'right'\n   *\n   * @returns 'true' in case this is 'right value' (and resolves type to be 'right')\n   *\n   * @example\n   * ```typescript\n   * if (either.isRight()) {\n   *   console.log(either.right)\n   * }\n   * ```\n   */\n  isRight(): this is Right<R, L>;\n\n  /**\n   * Either type guard for 'left'\n   *\n   * @returns 'true' in case this is 'left error' (and resolves type to be 'left')\n   *\n   * @example\n   * ```typescript\n   * if (either.isLeft()) {\n   *   console.error(either.left)\n   * }\n   * ```\n   */\n  isLeft(): this is Left<R, L>;\n\n  /**\n   * Wrap Maybe to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of Maybe wrapping this\n   */\n   generator: EitherGeneratorFunction<[], R, Left<R, L>, R>\n}\n\n/**\n * Either data type: either Right value of type R or Left value of type L\n *\n * As per classic Either monad implementation can eithr contain a right (correct) value or a left (erroneous) value\n * Used throughout the library to represent the result of failable operations, namely failed tasks\n *\n * @template R underlying value type\n * @template L underlying error type\n */\nexport type Either<R, L> = Right<R, L> | Left<R, L>;\n\nexport namespace Right {\n  /**\n   * Standalone Right value extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @template L underlying error type\n   * @param right Right instance\n   * @returns underlying value\n   */\n  export function right<R, L>(right: Right<R, L>) {\n    return right.right;\n  }\n}\n\nexport namespace Left {\n  /**\n   * Standalone Left error extractor\n   *\n   * Userful for passing as a function to collection transformers\n   *\n   * @template R underlying value type\n   * @template L underlying error type\n   * @param left Left instance\n   * @returns underlying error\n   */\n  export function left<R, L>(left: Left<R, L>) {\n    return left.left;\n  }\n}\n\nexport type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;\nexport type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;\n\nexport namespace Either {\n  /**\n   * Right monad constructor\n   *\n   * @template R underlying value type\n   * @param value underlying value\n   * @returns 'right value'\n   */\n  export function right<R>(value: R): Right<R, never> {\n    return new RightClass<R>(value);\n  }\n\n  /**\n   * Left monad constructor\n   *\n   * @template L underlying error type\n   * @param error underlying error\n   * @returns 'left error'\n   */\n  export function left<L>(error: L): Left<never, L> {\n    return new LeftClass<L>(error);\n  }\n\n  /**\n   * Either constructor from optional value\n   *\n   * Resolves to 'left error' in case of undefined value and 'right value' otherwise\n   *\n   * @param value possibly undefined value\n   * @param error error to use in case of undefined value\n   * @returns either 'right value' or 'left error'\n   */\n  export function fromOptional<L>(value: undefined, error: L): Left<never, L>;\n  export function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;\n  export function fromOptional<R, L>(value: R | undefined, error: L): Either<R, L>;\n  export function fromOptional<R, L>(value: R | undefined, error: L) {\n    return typeof value !== 'undefined' ? Either.right(value) : Either.left(error);\n  }\n\n  /**\n   * Either constructor from optional or nullable value\n   *\n   * Resolves to 'left error' in case of undefined or null value and 'right value' otherwise\n   *\n   * @param value possibly undefined or nullable value\n   * @param error error to use in case of undefined or nullable value\n   * @returns either 'right value' or 'left error'\n   */\n  export function fromNullable<L>(value: undefined, error: L): Left<never, L>;\n  export function fromNullable<L>(value: null, error: L): Left<never, L>;\n  export function fromNullable<R>(value: Exclude<R, null | undefined>, error: unknown): Right<R, never>;\n  export function fromNullable<R, L>(value: R | null | undefined, error: L): Either<R, L>;\n  export function fromNullable<R, L>(value: R | null | undefined, error: L) {\n    return Either.fromOptional(value, error).chain((v) => (v !== null ? Either.right(value) : Either.left(error)));\n  }\n\n  /**\n   * Standalone type guard for 'right'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param either Either instance\n   * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')\n   */\n  export function isRight<R, L>(either: Either<R, L>): either is Right<R, never> {\n    return either.isRight();\n  }\n\n  /**\n   * Standalone type guard for 'left'\n   *\n   * Userful for passing as a predicate to collection transformers\n   *\n   * @template R underlying value type\n   * @param either Either instance\n   * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')\n   */\n  export function isLeft<R, L>(either: Either<R, L>): either is Left<never, L> {\n    return either.isLeft();\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case every list element is Right\n   */\n  export function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {\n    return eithers.every(Either.isRight);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case at least one list element is Right\n   */\n  export function someRight<R, L>(eithers: Either<R, L>[]): boolean {\n    return eithers.some(Either.isRight);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case every list element is Left\n   */\n  export function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {\n    return eithers.every(Either.isLeft);\n  }\n\n  /**\n   * Standalone list predicate\n   *\n   * @param eithers a list of Either\n   * @returns true in case at least one list element is Left\n   */\n  export function someLeft<R, L>(eithers: Either<R, L>[]): boolean {\n    return eithers.some(Either.isLeft);\n  }\n\n  /**\n   * Create compound Either from generator function\n   *\n   * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success\n   * However the convinient option for typescript is to use ```yield* maybe.generator()``` as othervise one may have to deal with union types\n   *\n   * @template TT yielded Maybe type\n   * @template R returned underlying type\n   * @param maybeGeneratorFunction Maybe generator function\n   * @returns Just wrapping the result of generator function or Nothing\n   * ```\n   */\n  export function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any> {\n    const generator = eitherGeneratorFunction();\n\n    const sequentor = (next: IteratorResult<TT, R>): Either<R, any> => {\n      return next.done ? (\n        Either.right(next.value)\n      ) : (\n        next.value.matchChain<R, any>({\n          right: (value) => sequentor(generator.next(value)),\n          left: Either.left,\n        })\n      );\n    };\n\n    return Either.right(undefined).chain(() => sequentor(generator.next()));\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\nclass RightClass<R> implements Right<R, never> {\n  constructor(readonly right: R) {}\n\n  tap(op: (value: R) => void) {\n    op(this.right);\n\n    return this;\n  }\n  orTap() {\n    return this;\n  }\n  map<R2>(op: (value: R) => R2) {\n    return Either.right(op(this.right));\n  }\n  orMap() {\n    return this;\n  }\n  chain<TT extends Either<unknown, unknown>>(op: (value: R) => TT) {\n    return op(this.right);\n  }\n  orChain() {\n    return this;\n  }\n  isRight(): this is Right<R, never> {\n    return true;\n  }\n  isLeft(): this is Left<R, never> {\n    return false;\n  }\n  matchTap(op: { right: (value: R) => void }) {\n    return this.tap(op.right);\n  }\n  matchMap<R2>(op: { right: (value: R) => R2 }) {\n    return this.map(op.right);\n  }\n  matchChain<TT extends Either<unknown, unknown>>(op: { right: (value: R) => TT }) {\n    return this.chain(op.right);\n  }\n  generator() {\n    return (function*(value) {\n      return (yield value) as R;\n    })(this);\n  }\n}\n\nclass LeftClass<L> implements Left<never, L> {\n  constructor(readonly left: L) {}\n\n  tap() {\n    return this;\n  }\n  orTap(op: (error: L) => void) {\n    op(this.left);\n\n    return this;\n  }\n  map() {\n    return this;\n  }\n  orMap<R2>(op: (error: L) => R2) {\n    return Either.right(op(this.left));\n  }\n  chain() {\n    return this;\n  }\n  orChain<TT extends Either<unknown, unknown>>(op: (error: L) => TT) {\n    return op(this.left);\n  }\n  isRight(): this is Right<never, L> {\n    return false;\n  }\n  isLeft(): this is Left<never, L> {\n    return true;\n  }\n  matchTap(op: { left: (error: L) => void }) {\n    return this.orTap(op.left);\n  }\n  matchMap<R2>(op: { left: (error: L) => R2 }) {\n    return this.orMap(op.left);\n  }\n  matchChain<TT extends Either<unknown, unknown>>(op: { left: (error: L) => TT }) {\n    return this.orChain(op.left);\n  }\n  generator() {\n    return (function*(value) {\n      return (yield value) as never;\n    })(this);\n  }\n}\n","import { Maybe, Just } from './maybe';\nimport { Either, Right } from './either';\n\n/**\n * Shortcut for monadic Either type, where erroneous value is of type any\n *\n * @template R underlying type\n */\nexport type Rejectable<R> = Either<R, any>;\n\n/**\n * Shortcut for underlying task result type\n *\n * @template R underlying type\n */\nexport type Cancelable<R> = Maybe<Rejectable<R>>;\n\n/**\n * Function returning Task\n *\n * @template A argument types\n * @template R returned task resolve type\n */\nexport type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;\n\n/**\n * Task generator\n *\n * @template TT yielded task type\n * @template R returned task resolve type\n *\n * @example\n * ```typescript\n * const generatorFunction = function*(): TaskGenerator<unknown, Task<string>, number> {\n *   const v = yield* someTaskFunction().generator();\n *\n *   return v.length;\n * };\n * ```\n */\nexport type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;\n\n/**\n * Function returning task generator (generator function)\n *\n * @template A argument types\n * @template TT yielded task type\n * @template R returned task resolve type\n *\n * @example\n * ```typescript\n * const generatorFunction: TaskGeneratorFunction<[], unknown, Task<string>, number> = function*() {\n *   const v = yield* someTaskFunction().generator();\n *\n *   return v.length;\n * };\n * ```\n */\nexport type TaskGeneratorFunction<A extends unknown[], T, TT extends Task<T>, R> = (...args: A) => TaskGenerator<T, TT, R>;\n\n/**\n * Task monad interface\n *\n * @template R task resolve type\n */\nexport interface Task<R> extends TaskBase<R> {\n  /**\n   * Invoke callback when task is resolved (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tap(op: (value: R) => void): Task<R>;\n\n  /**\n   * Invoke callback when task is rejected (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tapRejected(op: (error: any) => void): Task<R>;\n\n  /**\n   * Invoke callback when task is canceled (and only then)\n   *\n   * @param op callback to invoke\n   * @returns self\n   */\n  tapCanceled(op: () => void): Task<R>;\n\n  /**\n   * Invoke a dedicated callback according to task resolution\n   *\n   * @param op.resolved callback to invoke on success\n   * @param op.rejected callback to invoke on failure\n   * @param op.canceled callback to invoke on cancelation\n   * @returns self\n   */\n  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }): Task<R>;\n\n  /**\n   * Invoke transformer when task is resolved (and only then) and return it's result instead\n   *\n   * @template R2 transformer return type\n   * @param op transformer to invoke\n   * @returns task returning transformer result\n   */\n  map<R2>(op: (value: R) => R2): Task<R2>;\n\n  /**\n   * Invoke transformer when task is rejected (and only then) and return it's result instead\n   *\n   * @template R2 fallback return type\n   * @param op transformer to invoke\n   * @returns task returning fallback result in case of failure\n   */\n  mapRejected<R2>(op: (error: any) => R2): Task<R | R2>;\n\n  /**\n   * Invoke transformer when task is canceled (and only then) and return it's result instead\n   *\n   * @template R2 fallback return type\n   * @param op transformer to invoke\n   * @returns task returning fallback result in case of cancelation\n   */\n  mapCanceled<R2>(op: () => R2): Task<R | R2>;\n\n  /**\n   * Invoke a dedicated transformer according to task resolution\n   *\n   * @template R2 success transformer return type\n   * @template R3 failure transformer return type\n   * @template R4 cancelation transformer return type\n   * @param op.resolved transformer to invoke on success\n   * @param op.rejected transformer to invoke on failure\n   * @param op.canceled transformer to invoke on cancelation\n   * @returns task resolving to a corresponding transformer result\n   */\n  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }): Task<R2 | R3 | R4>;\n\n  /**\n   * Invoke transformer when task is resolved (and only then) and continue execution with it's result\n   *\n   * @template R2 transformer task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to transformer result task\n   */\n  chain<R2>(op: (value: R) => Task<R2>): Task<R2>;\n\n  /**\n   * Invoke transformer when task is rejected (and only then) and continue execution with it's result\n   *\n   * @template R2 fallback task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to fallback task in case of failure\n   */\n  chainRejected<R2>(op: (error: any) => Task<R2>): Task<R | R2>;\n\n  /**\n   * Invoke transformer when task is canceled (and only then) and continue execution with it's result\n   *\n   * @template R2 fallback task resolve type\n   * @param op transformer to invoke\n   * @returns task chaining to fallback task in case of cancelation\n   */\n  chainCanceled<R2>(op: () => Task<R2>): Task<R | R2>;\n\n  /**\n   * Invoke a dedicated transformer according to task resolution and continue execution with it's result\n   *\n   * @template R2 success transformer resolve type\n   * @template R3 failure transformer resolve type\n   * @template R4 cancelation transformer resolve type\n   * @param op.resolved transformer to invoke on success\n   * @param op.rejected transformer to invoke on failure\n   * @param op.canceled transformer to invoke on cancelation\n   * @returns task chaining to a corresponding transformer result\n   */\n  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }): Task<R2 | R3 | R4>;\n\n  /**\n   * Return underlying promise in order to await result\n   *\n   * @returns underlying promise\n   */\n  resolve: () => TaskInvoke<R>;\n\n  /**\n   * Invoke underlying canel method without error\n   */\n  cancel: () => void;\n\n  /**\n   * Invoke underlying canel method with error\n   *\n   * @param error error value to be injected from outside\n   */\n  reject: (error: any) => void;\n\n  /**\n   * Wrap task to singleton generator\n   *\n   * Userful in order to avoid ambiguous yied types\n   *\n   * @returns generator of task wrapping the task\n   * @example\n   * ```typescript\n   * const getString = () => Task.resolved('hello');\n   * const getLength = (data: string) => Task.resolved(data.length);\n   *\n   * // ..... //\n   *\n   * Task.generate(function* () {\n   *   const data = yield getString(); // data: string | number\n   *   const length = yield getLength(data); // length: string | number\n   *\n   *   return length;\n   * });\n   *\n   * // ..... //\n   *\n   * Task.generate(function* () {\n   *   const data = yield* getString().generator(); // data: string\n   *   const length = yield* getLength(data).generator(); // length: number\n   *\n   *   return length;\n   * });\n   * ```\n   */\n  generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;\n}\n\nexport namespace Task {\n  /**\n   * Custom task monad constructor\n   *\n   * @template R returned task's resolve type\n   * @param invoke promise defining task execution\n   * @param cancel cancelation function\n   * @returns task resolving to resolve value of invoke\n   *\n   * @note low-level primitive for creating custom tasks, not intended for general use\n   */\n  export function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R> {\n    return new TaskClass<R>(invoke, cancel);\n  }\n\n  /**\n   * Invariant task constructor creating resolved task from plain value\n   *\n   * @template R returned task's resolve type\n   * @param value value to be returned upon awaiting\n   * @returns task resolving to specified value\n   */\n  export function resolved<R>(value: R) {\n    return Task.create<R>(Promise.resolve(Maybe.just(Either.right(value))), () => void undefined);\n  }\n\n  /**\n   * Invariant task constructor creating rejected task from error value\n   *\n   * @template R returned task's resolve type\n   * @param error error to be returned upon awaiting\n   * @returns task resolving to specified value\n   */\n  export function rejected<R>(error: any) {\n    return Task.create<R>(Promise.resolve(Maybe.just(Either.left(error))), () => void undefined);\n  }\n\n  /**\n   * Invariant task constructor creating canceled task\n   *\n   * @template R returned task's resolve type\n   * @returns task resolving to specified value\n   */\n  export function canceled<R>() {\n    return Task.create<R>(Promise.resolve(Maybe.nothing()), () => void undefined);\n  }\n\n  /**\n   * Lift from promise to task resolving to that promise result\n   *\n   * Userfull for converting promises to tasks\n   * If converted task is canceled or failed externally return value will be ignored without side-effects\n   * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n   *\n   * @template R returned task resolve type\n   * @param promise promise to be resolved\n   * @returns task resolving to specified promise value\n   *\n   * @example\n   * ```typescript\n   * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);\n   * ```\n   */\n  export function fromPromise<R>(promise: PromiseLike<R>): Task<R> {\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        promise\n          .then(Either.right, Either.left)\n          .then(Maybe.just)\n          .then(resolve);\n      }),\n      (error: Maybe<any>) => resolve(error.map(Either.left)),\n    );\n  }\n\n  /**\n   * Lift from sync function to task resolving to said function result\n   *\n   * Generally, functions are not considered tasks as they cannot be interrupted in any way\n   * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from\n   * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain\n   * This function is mostly used internally and is not expected to be widely used except of some edge scenarios\n   *\n   * If converted task is canceled or failed externally return value will be ignored without side-effects\n   * All tasks are no-trowing by default, any occured errors are returned as Left<any>\n   *\n   * @template R returned task resolve type\n   * @param producer function to be wrapped to a task\n   * @param cancelRef reference object allowing to set cancelation function prior to invoking function\n   * @returns task resolving to the specified function's result\n   *\n   * @example\n   * ```typescript\n   * const cancelRef = { cancel: () => {} };\n   *\n   * const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);\n   * ```\n   */\n  export function fromFunction<R>(producer: () => R, cancelRef: { cancel: TaskCancel }): Task<R> {\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    const cancel = (error: Maybe<any>) => resolve(error.map(Either.left));\n\n    cancelRef.cancel = cancel;\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        try {\n          resolve(Maybe.just(Either.right(producer())));\n        } catch (e) {\n          resolve(Maybe.just(Either.left(e)));\n        }\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Convinience shortcut for yielding async functions as tasks\n   *\n   * @template R returned generator resolve type\n   * @param promise promise to be resolved\n   * @returns generator to be be used with yield*\n   */\n  export function promiseGenerator<R>(promise: PromiseLike<R>) {\n    return Task.fromPromise(promise).generator();\n  }\n\n  /**\n   * Convinience shortcut for yielding timers\n   *\n   * @template R returned generator resolve type\n   * @param promise promise to be resolved\n   * @returns generator to be be used with yield*\n   */\n   export function timeoutGenerator(delay: number) {\n    return Task.timeout(delay).generator();\n  }\n\n  /**\n   * Lift from function returning value/promise to function returning task resolving to that value\n   *\n   * Userfull for converting exising async functions to task functions for further use\n   *\n   * @template A returned function's argument types\n   * @template R returned function's result task's resolve type\n   * @param promiseFunction function returning promise or plain value to be resolved\n   * @returns task function wrapping specified promise function\n   * @see Task.fromPromise\n   *\n   * @example\n   * ```typescript\n   * const taskFunction = liftPromiseFunction(someAsyncOperation);\n   *\n   * const task = taskFunction('someData').map((result) => result.length);\n   * ```\n   */\n  export function lift<A extends unknown[], R>(promiseFunction: (...args: A) => PromiseLike<R>): TaskFunction<A, R> {\n    return (...args: A) => Task.fromPromise(promiseFunction(...args));\n  }\n\n  /**\n   * Create compound task from generator function\n   *\n   * Applying yield to task within the generator function awaits the task and returns underlying value in case of success\n   * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types\n   *\n   * In case of failure an error is thrown and may be caught by try-catch\n   *\n   * If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately\n   *\n   * @template TT yielded task type\n   * @template R returned task resolve type\n   * @param taskGeneratorFunction task generator function\n   * @returns task resolving to generator's return type\n   *\n   * @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield\n   * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly\n   *\n   * @example\n   * ```typescript\n   * const task = Task.generate(function*() {\n   *   try {\n   *     const value1 = yield* delayedValueTask('data', 400).generator();\n   *\n   *     const value2 = yield* delayedValueTask(value1.length, 300).generator();\n   *\n   *     return value2;\n   *   } catch (e) {\n   *     return -1;\n   *   }\n   * });\n   * ```\n   */\n  export function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R> {\n    const generator = taskGeneratorFunction();\n\n    const sequentor = (next: IteratorResult<TT, R>): Task<R> => {\n      return next.done ? (\n        Task.resolved(next.value)\n      ) : (\n        next.value.matchChain<R>({\n          resolved: (value) => sequentor(generator.next(value)),\n          rejected: (error) => sequentor(generator.throw(error)),\n          canceled: Task.canceled,\n        })\n      );\n    };\n\n    return Task.resolved(undefined).chain(() => sequentor(generator.next()));\n  }\n\n  /**\n   * Generic timeout task\n   *\n   * Usefull for creating delays in task chains or implementing limiting tasks\n   *\n   * @param delay duration in ms after that the task resolves to void\n   * @returns task resolving to void (undefined) after specified delay\n   *\n   * @example\n   * ```typescript\n   * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);\n   * // ... //\n   * const value = yield* delayedValueTask(42, 1000).generator();\n   *\n   * console.log(\"It's past 1 second and here's a value:\", value)\n   * ```\n   */\n  export function timeout(delay: number) {\n    return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n  }\n\n  /**\n   * Generic callback task\n   *\n   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction\n   *\n   * @param create task body with success and error callbacks\n   * @param cancel cancelation function intended for stopping task execution\n   * @returns task resolving to success value\n   *\n   * @example\n   * ```typescript\n   * export function timeout(delay: number) {\n   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);\n   * }\n   * ```\n   */\n  export function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void) => H, cancel: (handler: H) => void): Task<R> {\n    let handler: H;\n\n    const [resolve, setResolve] = resolver<Cancelable<R>>();\n\n    return Task.create(\n      new Promise<Cancelable<R>>((_resolve) => {\n        setResolve(_resolve);\n\n        handler = create(\n          (r) => resolve(Maybe.just(Either.right(r))),\n          (e) => resolve(Maybe.just(Either.left(e))),\n        );\n      }),\n      (error: Maybe<any>) => {\n        resolve(error.map(Either.left));\n\n        cancel(handler);\n      },\n    );\n  }\n\n  /**\n   * Start multiple tasks one after another\n   *\n   * @param taskFunctions list of task functions (without arguments)\n   * @returns composite task invoring every task in order and resolving to the list of results\n   */\n  export function sequence<T>(taskFunctions: Iterable<TaskFunction<[], T>>): Task<T[]> {\n    return Array.from(taskFunctions).reduce((prev, taskFunction) => {\n      return prev.chain((list) => {\n        return taskFunction().map((value) => list.concat(value));\n      });\n    }, Task.resolved<T[]>([]));\n  }\n\n  /**\n   * Execute all tasks in parallel and return list of results\n   *\n   * Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order\n   * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled\n   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n   *\n   * @note direct equivalent of Promise.all\n   *\n   * @template T underlying task type\n   * @param tasks iterable of tasks to execute\n   * @retuirns task resolving to the list of results\n   */\n  export function all<T>(tasks: Iterable<Task<T>>) {\n    const [resolve, setResolve] = resolver<Cancelable<T[]>>();\n\n    const taskArray = Array.from(tasks);\n\n    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));\n\n    const list = taskArray.map<Maybe<T>>(Maybe.nothing);\n\n    const resolved = (value: T, i: number) => {\n      list[i] = Maybe.just(value);\n\n      if (Maybe.everyJust(list)) {\n        resolve(Maybe.just(Either.right(list.map(Just.just))));\n      }\n    };\n    const rejected = (error: Maybe<any>) => {\n      resolve(error.map(Either.left));\n      cancel(error);\n    };\n\n    return Task.create(\n      new Promise<Cancelable<T[]>>((_resolve) => {\n        setResolve(_resolve);\n\n        if (taskArray.length < 1) {\n          return resolve(Maybe.just(Either.right([])));\n        }\n\n        taskArray.map((task, i) => {\n          return task.matchTap({\n            resolved: (value) => resolved(value, i),\n            rejected: (error) => rejected(Maybe.just(error)),\n            canceled: () => rejected(Maybe.nothing()),\n          });\n        });\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Execute all tasks in parallel and return the result of the first successful one\n   *\n   * Resulting task resolves when the first tasks is successfuly resolved, returning it's result\n   * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors\n   * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors\n   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks\n   *\n   * @note direct equivalent of Promise.any\n   *\n   * @template T underlying task type\n   * @param tasks iterable of tasks to execute\n   * @retuirns task resolving to the result of first successfull task\n   */\n  export function any<T>(tasks: Iterable<Task<T>>) {\n    const [resolve, setResolve] = resolver<Cancelable<T>>();\n\n    const taskArray = Array.from(tasks);\n\n    const cancel = (error: Maybe<any>) => taskArray.forEach((task) => task._cancel(error));\n\n    const list = taskArray.map<Maybe<any>>(Maybe.nothing);\n\n    const resolved = (value: Maybe<T>) => {\n      resolve(value.map(Either.right));\n      cancel(Maybe.nothing());\n    };\n    const rejected = (error: any, i: number) => {\n      list[i] = Maybe.just(error);\n\n      if (Maybe.everyJust(list)) {\n        resolve(Maybe.just(Either.left(list.map(Just.just))));\n      }\n    };\n\n    return Task.create(\n      new Promise<Cancelable<T>>((_resolve) => {\n        setResolve(_resolve);\n\n        if (taskArray.length < 1) {\n          return resolve(Maybe.nothing());\n        }\n\n        taskArray.map((task, i) => {\n          return task.matchTap({\n            resolved: (value) => resolved(Maybe.just(value)),\n            rejected: (error) => rejected(error, i),\n            canceled: () => resolved(Maybe.nothing()),\n          });\n        });\n      }),\n      cancel,\n    );\n  }\n\n  /**\n   * Limit task execution based on another task\n   *\n   * If the second task resolves sooner than the first, resulting task is canceled\n   * Otherwise the resulting task resolves together with the first one\n   *\n   * @param task task to limit\n   * @param limitTask limiting task\n   * @returns task limites according to limitTask\n   */\n  export function limit<T>(task: Task<T>, limitTask: Task<void>) {\n    return Task.any<T>([task, limitTask.chain<T>(Task.canceled)]).chainRejected((errors) => Task.rejected<T>(errors[0]));\n  }\n\n  /**\n   * Repeat task untill successful\n   *\n   * Given task is re-generated in case of failure (both external and internal)\n   * Resulting task is still cancelable by standard means\n   *\n   * @param taskFunction task preoducing function\n   */\n  export function repeat<T>(taskFunction: TaskFunction<[], T>) {\n    const sequentor = (): Task<T> => taskFunction().chainRejected(sequentor);\n\n    return sequentor();\n  }\n}\n\n/// --------------------------------------------------------------------------------------\n/// Private section\n/// --------------------------------------------------------------------------------------\n\ntype TaskInvoke<R> = Promise<Cancelable<R>>;\ntype TaskCancel = (error: Maybe<any>) => void;\n\n/**\n * @hidden\n */\ninterface TaskBase<R> {\n  /**\n   * @hidden\n   */\n  readonly _invoke: TaskInvoke<R>;\n  /**\n   * @hidden\n   */\n  readonly _cancel: TaskCancel;\n}\n\nconst resolver = <T>() => {\n  const stub: (t: T) => void = () => void undefined;\n\n  let globalResolve = stub;\n\n  const resolve = (value: T) => {\n    const r = globalResolve;\n\n    globalResolve = stub;\n\n    r(value);\n  };\n\n  const setResolve = (value: typeof resolve) => {\n    globalResolve = value;\n  };\n\n  return [resolve, setResolve] as [typeof resolve, typeof setResolve];\n};\n\nfunction chainTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Task<R2>) {\n  const globalCancel = { cancel: _task._cancel };\n\n  return Task.create(\n    _task._invoke.then(async (result) => {\n      // Tecnically it's not possible to throw here anymore as op is lifted into task now, but just in case\n      try {\n        const { _invoke: invoke2, _cancel: cancel2 } = Task.fromFunction(() => op(result), globalCancel);\n\n        globalCancel.cancel = cancel2;\n\n        const produced = await invoke2;\n\n        if (produced.isNothing()) {\n          return Maybe.nothing();\n        }\n\n        if (produced.just.isLeft()) {\n          return Maybe.just(Either.left(produced.just.left));\n        }\n\n        const { _invoke: invoke3, _cancel: cancel3 } = produced.just.right;\n\n        globalCancel.cancel = cancel3;\n\n        return invoke3;\n      } catch (e) {\n        return Maybe.just(Either.left(e));\n      }\n    }),\n    (error: Maybe<any>) => globalCancel.cancel(error),\n  );\n}\n\nfunction chainTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Task<R2>) {\n  return chainTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op).orMap<Task<R2>>(Task.canceled).just);\n}\n\nfunction mapTaskMaybe<R, R2>(_task: TaskBase<R>, op: (value: Cancelable<R>) => Cancelable<R2>) {\n  return chainTaskMaybe<R, R2>(_task, (maybe) => {\n    return op(maybe).matchMap<Task<R2>>({\n      just: (either) =>\n        either.matchMap<Task<R2>>({\n          right: Task.resolved,\n          left: Task.rejected,\n        }).right,\n      nothing: Task.canceled,\n    }).just;\n  });\n}\n\nfunction mapTaskEither<R, R2>(_task: TaskBase<R>, op: (value: Rejectable<R>) => Rejectable<R2>) {\n  return mapTaskMaybe<R, R2>(_task, (maybe) => maybe.map(op));\n}\n\nfunction tapTaskMaybe<R>(_task: TaskBase<R>, op: (value: Cancelable<R>) => void) {\n  return mapTaskMaybe<R, R>(_task, (value) => {\n    op(value);\n\n    return value;\n  });\n}\n\nfunction tapTaskEither<R>(_task: TaskBase<R>, op: (value: Rejectable<R>) => void) {\n  return tapTaskMaybe<R>(_task, (maybe) => maybe.tap(op));\n}\n\nclass TaskClass<R> implements Task<R> {\n  constructor(readonly _invoke: TaskInvoke<R>, readonly _cancel: TaskCancel) {}\n\n  tapCanceled(op: () => void) {\n    return tapTaskMaybe<R>(this, (maybe) => maybe.orTap(op));\n  }\n  tapRejected(op: (error: any) => void) {\n    return tapTaskEither<R>(this, (either) => either.orTap(op));\n  }\n  tap(op: (value: R) => void) {\n    return tapTaskEither<R>(this, (either) => either.tap(op));\n  }\n\n  mapCanceled<R2>(op: () => R2) {\n    return mapTaskMaybe<R, R | R2>(this, (maybe) => maybe.orMap(() => Either.right(op())));\n  }\n  mapRejected<R2>(op: (error: any) => R2) {\n    return mapTaskEither<R, R | R2>(this, (either) => either.orMap(op));\n  }\n  map<R2>(op: (value: R) => R2) {\n    return mapTaskEither<R, R2>(this, (either) => either.map(op));\n  }\n\n  chainCanceled<R2>(op: () => Task<R2>) {\n    const mapEither = (either: Rejectable<R>) => either.map(Task.resolved).orMap<Task<R>>(Task.rejected).right;\n\n    return chainTaskMaybe<R, R | R2>(this, (maybe) => maybe.map(mapEither).orMap(op).just);\n  }\n  chainRejected<R2>(op: (error: any) => Task<R2>) {\n    return chainTaskEither<R, R | R2>(this, (either) => either.map(Task.resolved).orMap(op).right);\n  }\n  chain<R2>(op: (value: R) => Task<R2>) {\n    return chainTaskEither<R, R2>(this, (either) => either.map(op).orMap<Task<R2>>(Task.rejected).right);\n  }\n\n  resolve() {\n    return this._invoke;\n  }\n  cancel() {\n    return this._cancel(Maybe.nothing());\n  }\n  reject(error: any) {\n    return this._cancel(Maybe.just(error));\n  }\n\n  generator() {\n    return (function*(task) {\n      return (yield task) as R;\n    })(this);\n  }\n\n  matchTap(op: { resolved: (value: R) => void; rejected: (error: any) => void; canceled: () => void }) {\n    return tapTaskMaybe(this, (maybe) => {\n      return maybe.matchTap({\n        just: (either) => {\n          return either.matchTap({\n            right: op.resolved,\n            left: op.rejected,\n          });\n        },\n        nothing: op.canceled,\n      });\n    });\n  }\n\n  matchMap<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => R2; rejected: (error: any) => R3; canceled: () => R4 }) {\n    return mapTaskMaybe(this, (maybe) => {\n      return maybe.matchMap<Right<R2 | R3 | R4, any>>({\n        just: (either) => {\n          return either.matchMap({\n            right: op.resolved,\n            left: op.rejected,\n          });\n        },\n        nothing: () => Either.right(op.canceled()),\n      });\n    });\n  }\n\n  matchChain<R2, R3 = R2, R4 = R3>(op: { resolved: (value: R) => Task<R2>; rejected: (error: any) => Task<R3>; canceled: () => Task<R4> }) {\n    return chainTaskMaybe(this, (maybe) => {\n      return maybe.matchMap<Task<R2 | R3 | R4>>({\n        just: (either) => {\n          return either.matchMap<Task<R2 | R3>>({\n            right: op.resolved,\n            left: op.rejected,\n          }).right;\n        },\n        nothing: op.canceled,\n      }).just;\n    });\n  }\n}\n"],"names":["Just","Maybe","just","value","JustClass","staticNothing","nothing","fromOptional","chain","v","maybe","isJust","isNothing","maybes","every","some","maybeGeneratorFunction","generator","sequentor","next","done","matchChain","undefined","constructor","this","tap","op","orTap","map","orMap","orChain","matchTap","matchMap","Right","Left","Either","Task","right","left","RightClass","error","LeftClass","either","isRight","isLeft","eithers","eitherGeneratorFunction","fromCallback","create","cancel","handler","resolve","setResolve","resolver","Promise","_resolve","r","e","invoke","TaskClass","promise","then","producer","cancelRef","fromPromise","delay","timeout","promiseFunction","taskGeneratorFunction","resolved","rejected","throw","canceled","setTimeout","clearTimeout","taskFunctions","Array","from","reduce","prev","taskFunction","list","concat","tasks","taskArray","forEach","task","_cancel","length","i","everyJust","limitTask","any","chainRejected","errors","stub","globalResolve","chainTaskMaybe","_task","globalCancel","_invoke","result","invoke2","cancel2","fromFunction","produced","invoke3","cancel3","chainTaskEither","mapTaskMaybe","mapTaskEither","tapTaskMaybe","tapTaskEither","tapCanceled","tapRejected","mapCanceled","mapRejected","chainCanceled","mapEither","reject"],"mappings":"AAoZiBA,IAAAA,EAoBAC,GApBjB,SAAiBD,GAUCA,OAAhB,SAAwBE,GACtB,OAAOA,EAAKA,IACb,CAZH,CAAA,CAAiBF,IAAAA,OAoBjB,SAAiBC,GAQCA,OAAhB,SAAwBE,GACtB,WAAWC,EAAaD,EACzB,EAOeF,UAAhB,WACE,OAAOI,CACR,EAaeJ,eAAhB,SAAgCE,GAC9B,YAAwB,IAAVA,EAAwBF,EAAMC,KAAKC,GAASF,EAAMK,SACjE,EAceL,eAAhB,SAAgCE,GAC9B,OAAOF,EAAMM,aAAaJ,GAAOK,MAAOC,GAAa,OAANA,EAAaR,EAAMC,KAAKO,GAAKR,EAAMK,UACnF,EAWeL,SAAhB,SAA0BS,GACxB,OAAOA,EAAMC,QACd,EAWeV,YAAhB,SAA6BS,GAC3B,OAAOA,EAAME,WACd,EAQeX,YAAhB,SAA6BY,GAC3B,OAAOA,EAAOC,MAAMb,EAAMU,OAC3B,EAQeV,WAAhB,SAA4BY,GAC1B,OAAOA,EAAOE,KAAKd,EAAMU,OAC1B,EAQeV,eAAhB,SAAgCY,GAC9B,OAAOA,EAAOC,MAAMb,EAAMW,UAC3B,EAQeX,cAAhB,SAA+BY,GAC7B,OAAOA,EAAOE,KAAKd,EAAMW,UAC1B,EAceX,WAAhB,SAAoDe,GAClD,MAAMC,EAAYD,IAEZE,EAAaC,GACVA,EAAKC,KACVnB,EAAMC,KAAKiB,EAAKhB,OAEhBgB,EAAKhB,MAAMkB,WAAc,CACvBnB,KAAOC,GAAUe,EAAUD,EAAUE,KAAKhB,IAC1CG,QAASL,EAAMK,UAKrB,OAAOL,EAAMC,UAAKoB,GAAWd,MAAM,IAAMU,EAAUD,EAAUE,QAC9D,CAjJH,CAAA,CAAiBlB,IAAAA,OAwJjB,MAAMG,EACJmB,YAAqBrB,QAAAA,YAAAsB,UAAAtB,CAAW,CAEhCuB,IAAIC,GAGF,OAFAA,EAAGF,KAAKtB,UAGT,CACDyB,QACE,WACD,CACDC,IAAQF,GACN,OAAOzB,EAAMC,KAAKwB,EAAGF,KAAKtB,MAC3B,CACD2B,QACE,WACD,CACDrB,MAAiCkB,GAC/B,OAAOA,EAAGF,KAAKtB,KAChB,CACD4B,UACE,WACD,CACDnB,SACE,QACD,CACDC,YACE,QACD,CACDmB,SAASL,GACP,YAAYD,IAAIC,EAAGxB,KACpB,CACD8B,SAAaN,GACX,YAAYE,IAAIF,EAAGxB,KACpB,CACDmB,WAAsCK,GACpC,YAAYlB,MAAMkB,EAAGxB,KACtB,CACDe,yBACE,+BAAQ,WAAUd,kFACR,gBAAMA,EADR,gFAELqB,KACJ,EA8CH,MAAMnB,EAAgB,IA3CtB,MACEoB,MACE,WACD,CACDE,MAAMD,GAGJ,OAFAA,QAGD,CACDE,MACE,WACD,CACDC,MAAUH,GACR,OAAOzB,EAAMC,KAAKwB,IACnB,CACDlB,QACE,WACD,CACDsB,QAAmCJ,GACjC,OAAOA,GACR,CACDf,SACE,QACD,CACDC,YACE,QACD,CACDmB,SAASL,GACP,YAAYC,MAAMD,EAAGpB,QACtB,CACD0B,SAAaN,GACX,YAAYG,MAAMH,EAAGpB,QACtB,CACDe,WAAsCK,GACpC,YAAYI,QAAQJ,EAAGpB,QACxB,CACDW,yBACE,+BAAQ,WAAUd,kFACR,gBAAMA,EADR,gFAELqB,KACJ,GClPcS,IAAAA,EAgBAC,EAmBAC,EC9NAC,GD2LjB,SAAiBH,GAWCA,QAAhB,SAA4BI,GAC1B,OAAOA,EAAMA,KACd,CAbH,CAAA,CAAiBJ,IAAAA,OAgBjB,SAAiBC,GAWCA,OAAhB,SAA2BI,GACzB,OAAOA,EAAKA,IACb,CAbH,CAAA,CAAiBJ,IAAAA,OAmBjB,SAAiBC,GAQCA,QAAhB,SAAyBhC,GACvB,WAAWoC,EAAcpC,EAC1B,EASegC,OAAhB,SAAwBK,GACtB,WAAWC,EAAaD,EACzB,EAceL,eAAhB,SAAmChC,EAAsBqC,GACvD,YAAwB,IAAVrC,EAAwBgC,EAAOE,MAAMlC,GAASgC,EAAOG,KAAKE,EACzE,EAeeL,eAAhB,SAAmChC,EAA6BqC,GAC9D,OAAOL,EAAO5B,aAAaJ,EAAOqC,GAAOhC,MAAOC,GAAa,OAANA,EAAa0B,EAAOE,MAAMlC,GAASgC,EAAOG,KAAKE,GACvG,EAWeL,UAAhB,SAA8BO,GAC5B,OAAOA,EAAOC,SACf,EAWeR,SAAhB,SAA6BO,GAC3B,OAAOA,EAAOE,QACf,EAQeT,aAAhB,SAAiCU,GAC/B,OAAOA,EAAQ/B,MAAMqB,EAAOQ,QAC7B,EAQeR,YAAhB,SAAgCU,GAC9B,OAAOA,EAAQ9B,KAAKoB,EAAOQ,QAC5B,EAQeR,YAAhB,SAAgCU,GAC9B,OAAOA,EAAQ/B,MAAMqB,EAAOS,OAC7B,EAQeT,WAAhB,SAA+BU,GAC7B,OAAOA,EAAQ9B,KAAKoB,EAAOS,OAC5B,EAceT,WAAhB,SAA0DW,GACxD,MAAM7B,EAAY6B,IAEZ5B,EAAaC,GACVA,EAAKC,KACVe,EAAOE,MAAMlB,EAAKhB,OAElBgB,EAAKhB,MAAMkB,WAAmB,CAC5BgB,MAAQlC,GAAUe,EAAUD,EAAUE,KAAKhB,IAC3CmC,KAAMH,EAAOG,OAKnB,OAAOH,EAAOE,WAAMf,GAAWd,MAAM,IAAMU,EAAUD,EAAUE,QAChE,CArJH,CAAA,CAAiBgB,IAAAA,OA4JjB,MAAMI,EACJhB,YAAqBc,QAAAA,aAAAb,WAAAa,CAAY,CAEjCZ,IAAIC,GAGF,OAFAA,EAAGF,KAAKa,WAGT,CACDV,QACE,WACD,CACDC,IAAQF,GACN,OAAOS,EAAOE,MAAMX,EAAGF,KAAKa,OAC7B,CACDR,QACE,WACD,CACDrB,MAA2CkB,GACzC,OAAOA,EAAGF,KAAKa,MAChB,CACDP,UACE,WACD,CACDa,UACE,QACD,CACDC,SACE,QACD,CACDb,SAASL,GACP,YAAYD,IAAIC,EAAGW,MACpB,CACDL,SAAaN,GACX,YAAYE,IAAIF,EAAGW,MACpB,CACDhB,WAAgDK,GAC9C,YAAYlB,MAAMkB,EAAGW,MACtB,CACDpB,yBACE,+BAAQ,WAAUd,kFACR,gBAAMA,EADR,gFAELqB,KACJ,EAGH,MAAMiB,EACJlB,YAAqBe,QAAAA,YAAAd,UAAAc,CAAW,CAEhCb,MACE,WACD,CACDE,MAAMD,GAGJ,OAFAA,EAAGF,KAAKc,UAGT,CACDV,MACE,WACD,CACDC,MAAUH,GACR,OAAOS,EAAOE,MAAMX,EAAGF,KAAKc,MAC7B,CACD9B,QACE,WACD,CACDsB,QAA6CJ,GAC3C,OAAOA,EAAGF,KAAKc,KAChB,CACDK,UACE,QACD,CACDC,SACE,QACD,CACDb,SAASL,GACP,YAAYC,MAAMD,EAAGY,KACtB,CACDN,SAAaN,GACX,YAAYG,MAAMH,EAAGY,KACtB,CACDjB,WAAgDK,GAC9C,YAAYI,QAAQJ,EAAGY,KACxB,CACDrB,yBACE,+BAAQ,WAAUd,kFACR,gBAAMA,EADR,gFAELqB,KACJ,GCjdH,SAAiBY,GA+Pf,SAAgBW,EAAmBC,EAA2EC,GAC5G,IAAIC,EAEJ,MAAOC,EAASC,GAAcC,IAE9B,OAAOjB,EAAKY,OACV,IAAIM,QAAwBC,IAC1BH,EAAWG,GAEXL,EAAUF,EACPQ,GAAML,EAAQlD,EAAMC,KAAKiC,EAAOE,MAAMmB,KACtCC,GAAMN,EAAQlD,EAAMC,KAAKiC,EAAOG,KAAKmB,QAGzCjB,IACCW,EAAQX,EAAMZ,IAAIO,EAAOG,OAEzBW,EAAOC,IAGZ,CAxQed,SAAhB,SAA0BsB,EAAuBT,GAC/C,WAAWU,EAAaD,EAAQT,EACjC,EASeb,WAAhB,SAA4BjC,GAC1B,OAAOiC,EAAKY,OAAUM,QAAQH,QAAQlD,EAAMC,KAAKiC,EAAOE,MAAMlC,KAAU,KAAjE,EACR,EASeiC,WAAhB,SAA4BI,GAC1B,OAAOJ,EAAKY,OAAUM,QAAQH,QAAQlD,EAAMC,KAAKiC,EAAOG,KAAKE,KAAU,KAAhE,EACR,EAQeJ,WAAhB,WACE,OAAOA,EAAKY,OAAUM,QAAQH,QAAQlD,EAAMK,WAAY,KAAjD,EACR,EAkBe8B,cAAhB,SAA+BwB,GAC7B,MAAOT,EAASC,GAAcC,IAE9B,OAAOjB,EAAKY,OACV,IAAIM,QAAwBC,IAC1BH,EAAWG,GAEXK,EACGC,KAAK1B,EAAOE,MAAOF,EAAOG,MAC1BuB,KAAK5D,EAAMC,MACX2D,KAAKV,KAETX,GAAsBW,EAAQX,EAAMZ,IAAIO,EAAOG,OAEnD,EAyBeF,eAAhB,SAAgC0B,EAAmBC,GACjD,MAAOZ,EAASC,GAAcC,IAExBJ,EAAUT,GAAsBW,EAAQX,EAAMZ,IAAIO,EAAOG,OAI/D,OAFAyB,EAAUd,OAASA,EAEZb,EAAKY,OACV,IAAIM,QAAwBC,IAC1BH,EAAWG,GAEX,IACEJ,EAAQlD,EAAMC,KAAKiC,EAAOE,MAAMyB,MAGjC,CAFC,MAAOL,GACPN,EAAQlD,EAAMC,KAAKiC,EAAOG,KAAKmB,IAChC,IAEHR,EAEH,EASeb,mBAAhB,SAAoCwB,GAClC,OAAOxB,EAAK4B,YAAYJ,GAAS3C,WAClC,EASgBmB,mBAAhB,SAAiC6B,GAChC,OAAO7B,EAAK8B,QAAQD,GAAOhD,WAC5B,EAoBemB,OAAhB,SAA6C+B,GAC3C,yBAAuB/B,EAAK4B,YAAYG,+BAAjC,CACR,EAmCe/B,WAAhB,SAAmDgC,GACjD,MAAMnD,EAAYmD,IAEZlD,EAAaC,GACVA,EAAKC,KACVgB,EAAKiC,SAASlD,EAAKhB,OAEnBgB,EAAKhB,MAAMkB,WAAc,CACvBgD,SAAWlE,GAAUe,EAAUD,EAAUE,KAAKhB,IAC9CmE,SAAW9B,GAAUtB,EAAUD,EAAUsD,MAAM/B,IAC/CgC,SAAUpC,EAAKoC,WAKrB,OAAOpC,EAAKiC,cAAS/C,GAAWd,MAAM,IAAMU,EAAUD,EAAUE,QACjE,EAmBeiB,UAAhB,SAAwB6B,GACtB,OAAOlB,EAAoCI,GAAYsB,WAAW,IAAMtB,IAAWc,GAAQS,aAC5F,EAkBetC,iBA4BAA,WAAhB,SAA4BuC,GAC1B,OAAOC,MAAMC,KAAKF,GAAeG,OAAO,CAACC,EAAMC,IACtCD,EAAKvE,MAAOyE,GACVD,IAAepD,IAAKzB,GAAU8E,EAAKC,OAAO/E,KAElDiC,EAAKiC,SAAc,IACvB,EAeejC,MAAhB,SAAuB+C,GACrB,MAAOhC,EAASC,GAAcC,IAExB+B,EAAYR,MAAMC,KAAKM,GAEvBlC,EAAUT,GAAsB4C,EAAUC,QAASC,GAASA,EAAKC,QAAQ/C,IAEzEyC,EAAOG,EAAUxD,IAAc3B,EAAMK,SASrCgE,EAAY9B,IAChBW,EAAQX,EAAMZ,IAAIO,EAAOG,OACzBW,EAAOT,IAGT,OAAOJ,EAAKY,OACV,IAAIM,QAA0BC,IAG5B,GAFAH,EAAWG,GAEP6B,EAAUI,OAAS,EACrB,OAAOrC,EAAQlD,EAAMC,KAAKiC,EAAOE,MAAM,MAGzC+C,EAAUxD,IAAI,CAAC0D,EAAMG,IACZH,EAAKvD,SAAS,CACnBsC,SAAWlE,GAtBF,EAACA,EAAUsF,KAC1BR,EAAKQ,GAAKxF,EAAMC,KAAKC,GAEjBF,EAAMyF,UAAUT,IAClB9B,EAAQlD,EAAMC,KAAKiC,EAAOE,MAAM4C,EAAKrD,IAAI5B,EAAKE,QAC/C,EAiB0BmE,CAASlE,EAAOsF,GACrCnB,SAAW9B,GAAU8B,EAASrE,EAAMC,KAAKsC,IACzCgC,SAAU,IAAMF,EAASrE,EAAMK,gBAIrC2C,EAEH,EAgBeb,MAAhB,SAAuB+C,GACrB,MAAOhC,EAASC,GAAcC,IAExB+B,EAAYR,MAAMC,KAAKM,GAEvBlC,EAAUT,GAAsB4C,EAAUC,QAASC,GAASA,EAAKC,QAAQ/C,IAEzEyC,EAAOG,EAAUxD,IAAgB3B,EAAMK,SAEvC+D,EAAYlE,IAChBgD,EAAQhD,EAAMyB,IAAIO,EAAOE,QACzBY,EAAOhD,EAAMK,YAUf,OAAO8B,EAAKY,OACV,IAAIM,QAAwBC,IAG1B,GAFAH,EAAWG,GAEP6B,EAAUI,OAAS,EACrB,OAAOrC,EAAQlD,EAAMK,WAGvB8E,EAAUxD,IAAI,CAAC0D,EAAMG,IACZH,EAAKvD,SAAS,CACnBsC,SAAWlE,GAAUkE,EAASpE,EAAMC,KAAKC,IACzCmE,SAAW9B,GAnBF,EAACA,EAAYiD,KAC5BR,EAAKQ,GAAKxF,EAAMC,KAAKsC,GAEjBvC,EAAMyF,UAAUT,IAClB9B,EAAQlD,EAAMC,KAAKiC,EAAOG,KAAK2C,EAAKrD,IAAI5B,EAAKE,QAC9C,EAc0BoE,CAAS9B,EAAOiD,GACrCjB,SAAU,IAAMH,EAASpE,EAAMK,gBAIrC2C,EAEH,EAYeb,QAAhB,SAAyBkD,EAAeK,GACtC,OAAOvD,EAAKwD,IAAO,CAACN,EAAMK,EAAUnF,MAAS4B,EAAKoC,YAAYqB,cAAeC,GAAW1D,EAAKkC,SAAYwB,EAAO,IACjH,EAUe1D,SAAhB,SAA0B4C,GACxB,MAAM9D,EAAY,IAAe8D,IAAea,cAAc3E,GAE9D,OAAOA,GACR,CA1aH,CAAA,CAAiBkB,IAAAA,OAkcjB,MAAMiB,EAAW,KACf,MAAM0C,EAAuB,KAA7B,EAEA,IAAIC,EAAgBD,EAcpB,MAAO,CAZU5F,IACf,MAAMqD,EAAIwC,EAEVA,EAAgBD,EAEhBvC,EAAErD,IAGgBA,IAClB6F,EAAgB7F,GAGX,EAGT,SAAS8F,EAAsBC,EAAoBxE,GACjD,MAAMyE,EAAe,CAAElD,OAAQiD,EAAMX,SAErC,OAAOnD,EAAKY,OACVkD,EAAME,QAAQvC,cAAYwC,+HAGtB,MAAQD,QAASE,EAASf,QAASgB,GAAYnE,EAAKoE,aAAa,IAAM9E,EAAG2E,GAASF,GADjF,OAGFA,EAAalD,OAASsD,kBAECD,iBAAjBG,GAEN,GAAIA,EAAS7F,YACX,OAAOX,EAAMK,UAGf,GAAImG,EAASvG,KAAK0C,SAChB,OAAO3C,EAAMC,KAAKiC,EAAOG,KAAKmE,EAASvG,KAAKoC,OAG9C,MAAQ8D,QAASM,EAASnB,QAASoB,GAAYF,EAASvG,KAAKmC,MAI7D,OAFA8D,EAAalD,OAAS0D,EAEfD,CAnBL,EAoBH,WAAQjD,GACP,OAAOxD,EAAMC,KAAKiC,EAAOG,KAAKmB,GAC/B,IAxBH,qCA0BCjB,GAAsB2D,EAAalD,OAAOT,GAE9C,CAED,SAASoE,EAAuBV,EAAoBxE,GAClD,OAAOuE,EAAsBC,EAAQxF,GAAUA,EAAMkB,IAAIF,GAAIG,MAAgBO,EAAKoC,UAAUtE,KAC7F,CAED,SAAS2G,EAAoBX,EAAoBxE,GAC/C,OAAOuE,EAAsBC,EAAQxF,GAC5BgB,EAAGhB,GAAOsB,SAAmB,CAClC9B,KAAOwC,GACLA,EAAOV,SAAmB,CACxBK,MAAOD,EAAKiC,SACZ/B,KAAMF,EAAKkC,WACVjC,MACL/B,QAAS8B,EAAKoC,WACbtE,KAEN,CAED,SAAS4G,EAAqBZ,EAAoBxE,GAChD,OAAOmF,EAAoBX,EAAQxF,GAAUA,EAAMkB,IAAIF,GACxD,CAED,SAASqF,EAAgBb,EAAoBxE,GAC3C,OAAOmF,EAAmBX,EAAQ/F,IAChCuB,EAAGvB,GAEIA,GAEV,CAED,SAAS6G,EAAiBd,EAAoBxE,GAC5C,OAAOqF,EAAgBb,EAAQxF,GAAUA,EAAMe,IAAIC,GACpD,CAED,MAAMiC,EACJpC,YAAqB6E,EAAiCb,QAAjCa,oBAAiCb,eAAjC/D,aAAA4E,EAAiC5E,aAAA+D,CAAuB,CAE7E0B,YAAYvF,GACV,OAAOqF,EAAgBvF,KAAOd,GAAUA,EAAMiB,MAAMD,GACrD,CACDwF,YAAYxF,GACV,OAAOsF,EAAiBxF,KAAOkB,GAAWA,EAAOf,MAAMD,GACxD,CACDD,IAAIC,GACF,OAAOsF,EAAiBxF,KAAOkB,GAAWA,EAAOjB,IAAIC,GACtD,CAEDyF,YAAgBzF,GACd,OAAOmF,EAAwBrF,KAAOd,GAAUA,EAAMmB,MAAM,IAAMM,EAAOE,MAAMX,MAChF,CACD0F,YAAgB1F,GACd,OAAOoF,EAAyBtF,KAAOkB,GAAWA,EAAOb,MAAMH,GAChE,CACDE,IAAQF,GACN,OAAOoF,EAAqBtF,KAAOkB,GAAWA,EAAOd,IAAIF,GAC1D,CAED2F,cAAkB3F,GAChB,MAAM4F,EAAa5E,GAA0BA,EAAOd,IAAIQ,EAAKiC,UAAUxC,MAAeO,EAAKkC,UAAUjC,MAErG,OAAO4D,EAA0BzE,KAAOd,GAAUA,EAAMkB,IAAI0F,GAAWzF,MAAMH,GAAIxB,KAClF,CACD2F,cAAkBnE,GAChB,OAAOkF,EAA2BpF,KAAOkB,GAAWA,EAAOd,IAAIQ,EAAKiC,UAAUxC,MAAMH,GAAIW,MACzF,CACD7B,MAAUkB,GACR,OAAOkF,EAAuBpF,KAAOkB,GAAWA,EAAOd,IAAIF,GAAIG,MAAgBO,EAAKkC,UAAUjC,MAC/F,CAEDc,UACE,YAAYiD,OACb,CACDnD,SACE,YAAYsC,QAAQtF,EAAMK,UAC3B,CACDiH,OAAO/E,GACL,YAAY+C,QAAQtF,EAAMC,KAAKsC,GAChC,CAEDvB,yBACE,+BAAQ,WAAUqE,kFACR,gBAAMA,EADR,gFAEL9D,KACJ,CAEDO,SAASL,GACP,OAAOqF,EAAavF,KAAOd,GAClBA,EAAMqB,SAAS,CACpB7B,KAAOwC,GACEA,EAAOX,SAAS,CACrBM,MAAOX,EAAG2C,SACV/B,KAAMZ,EAAG4C,WAGbhE,QAASoB,EAAG8C,WAGjB,CAEDxC,SAA+BN,GAC7B,OAAOmF,EAAarF,KAAOd,GAClBA,EAAMsB,SAAmC,CAC9C9B,KAAOwC,GACEA,EAAOV,SAAS,CACrBK,MAAOX,EAAG2C,SACV/B,KAAMZ,EAAG4C,WAGbhE,QAAS,IAAM6B,EAAOE,MAAMX,EAAG8C,cAGpC,CAEDnD,WAAiCK,GAC/B,OAAOuE,EAAezE,KAAOd,GACpBA,EAAMsB,SAA6B,CACxC9B,KAAOwC,GACEA,EAAOV,SAAwB,CACpCK,MAAOX,EAAG2C,SACV/B,KAAMZ,EAAG4C,WACRjC,MAEL/B,QAASoB,EAAG8C,WACXtE,KAEN"}

package/dist/t-tasks.js

@@ -1,2 +1,2 @@
-var t;exports.Just=void 0,(exports.Just||(exports.Just={})).just=function(t){return t.just},exports.Maybe=void 0,(t=exports.Maybe||(exports.Maybe={})).just=function(t){return new e(t)},t.nothing=function(){return r},t.fromOptional=function(e){return void 0!==e?t.just(e):t.nothing()},t.fromNullable=function(e){return t.fromOptional(e).chain(e=>null!==e?t.just(e):t.nothing())},t.isJust=function(t){return t.isJust()},t.isNothing=function(t){return t.isNothing()},t.everyJust=function(e){return e.every(t.isJust)},t.someJust=function(e){return e.some(t.isJust)},t.everyNothing=function(e){return e.every(t.isNothing)},t.someNothing=function(e){return e.some(t.isNothing)};class e{constructor(t){this.just=void 0,this.just=t}tap(t){return t(this.just),this}orTap(){return this}map(t){return exports.Maybe.just(t(this.just))}orMap(){return this}chain(t){return t(this.just)}orChain(){return this}isJust(){return!0}isNothing(){return!1}matchTap(t){return this.tap(t.just)}matchMap(t){return this.map(t.just)}matchChain(t){return this.chain(t.just)}}const r=new class{tap(){return this}orTap(t){return t(),this}map(){return this}orMap(t){return exports.Maybe.just(t())}chain(){return this}orChain(t){return t()}isJust(){return!1}isNothing(){return!0}matchTap(t){return this.orTap(t.nothing)}matchMap(t){return this.orMap(t.nothing)}matchChain(t){return this.orChain(t.nothing)}};var n;exports.Right=void 0,(exports.Right||(exports.Right={})).right=function(t){return t.right},exports.Left=void 0,(exports.Left||(exports.Left={})).left=function(t){return t.left},exports.Either=void 0,(n=exports.Either||(exports.Either={})).right=function(t){return new i(t)},n.left=function(t){return new s(t)},n.fromOptional=function(t,e){return void 0!==t?n.right(t):n.left(e)},n.fromNullable=function(t,e){return n.fromOptional(t,e).chain(r=>null!==r?n.right(t):n.left(e))},n.isRight=function(t){return t.isRight()},n.isLeft=function(t){return t.isLeft()},n.everyRight=function(t){return t.every(n.isRight)},n.someRight=function(t){return t.some(n.isRight)},n.everyLeft=function(t){return t.every(n.isLeft)},n.someLeft=function(t){return t.some(n.isLeft)};class i{constructor(t){this.right=void 0,this.right=t}tap(t){return t(this.right),this}orTap(){return this}map(t){return exports.Either.right(t(this.right))}orMap(){return this}chain(t){return t(this.right)}orChain(){return this}isRight(){return!0}isLeft(){return!1}matchTap(t){return this.tap(t.right)}matchMap(t){return this.map(t.right)}matchChain(t){return this.chain(t.right)}}class s{constructor(t){this.left=void 0,this.left=t}tap(){return this}orTap(t){return t(this.left),this}map(){return this}orMap(t){return exports.Either.right(t(this.left))}chain(){return this}orChain(t){return t(this.left)}isRight(){return!1}isLeft(){return!0}matchTap(t){return this.orTap(t.left)}matchMap(t){return this.orMap(t.left)}matchChain(t){return this.orChain(t.left)}}exports.Task=void 0,function(t){function e(e,r){let n;const[i,s]=o();return t.create(new Promise(t=>{s(t),n=e(t=>i(exports.Maybe.just(exports.Either.right(t))),t=>i(exports.Maybe.just(exports.Either.left(t))))}),t=>{i(t.map(exports.Either.left)),r(n)})}t.create=function(t,e){return new l(t,e)},t.resolved=function(e){return t.create(Promise.resolve(exports.Maybe.just(exports.Either.right(e))),()=>{})},t.rejected=function(e){return t.create(Promise.resolve(exports.Maybe.just(exports.Either.left(e))),()=>{})},t.canceled=function(){return t.create(Promise.resolve(exports.Maybe.nothing()),()=>{})},t.fromPromise=function(e){const[r,n]=o();return t.create(new Promise(t=>{n(t),e.then(exports.Either.right,exports.Either.left).then(exports.Maybe.just).then(r)}),t=>r(t.map(exports.Either.left)))},t.fromFunction=function(e,r){const[n,i]=o(),s=t=>n(t.map(exports.Either.left));return r.cancel=s,t.create(new Promise(t=>{i(t);try{n(exports.Maybe.just(exports.Either.right(e())))}catch(t){n(exports.Maybe.just(exports.Either.left(t)))}}),s)},t.promiseGenerator=function(e){return t.fromPromise(e).generator()},t.lift=function(e){return function(){return t.fromPromise(e(...[].slice.call(arguments)))}},t.generate=function(e){const r=e(),n=e=>e.done?t.resolved(e.value):e.value.matchChain({resolved:t=>n(r.next(t)),rejected:t=>n(r.throw(t)),canceled:t.canceled});return t.resolved(void 0).chain(()=>n(r.next()))},t.timeout=function(t){return e(e=>setTimeout(()=>e(),t),clearTimeout)},t.fromCallback=e,t.sequence=function(e){return Array.from(e).reduce((t,e)=>t.chain(t=>e().map(e=>t.concat(e))),t.resolved([]))},t.all=function(e){const[r,n]=o(),i=Array.from(e),s=t=>i.forEach(e=>e._cancel(t)),a=i.map(exports.Maybe.nothing),u=t=>{r(t.map(exports.Either.left)),s(t)};return t.create(new Promise(t=>{if(n(t),i.length<1)return r(exports.Maybe.just(exports.Either.right([])));i.map((t,e)=>t.matchTap({resolved:t=>((t,e)=>{a[e]=exports.Maybe.just(t),exports.Maybe.everyJust(a)&&r(exports.Maybe.just(exports.Either.right(a.map(exports.Just.just))))})(t,e),rejected:t=>u(exports.Maybe.just(t)),canceled:()=>u(exports.Maybe.nothing())}))}),s)},t.any=function(e){const[r,n]=o(),i=Array.from(e),s=t=>i.forEach(e=>e._cancel(t)),a=i.map(exports.Maybe.nothing),u=t=>{r(t.map(exports.Either.right)),s(exports.Maybe.nothing())};return t.create(new Promise(t=>{if(n(t),i.length<1)return r(exports.Maybe.nothing());i.map((t,e)=>t.matchTap({resolved:t=>u(exports.Maybe.just(t)),rejected:t=>((t,e)=>{a[e]=exports.Maybe.just(t),exports.Maybe.everyJust(a)&&r(exports.Maybe.just(exports.Either.left(a.map(exports.Just.just))))})(t,e),canceled:()=>u(exports.Maybe.nothing())}))}),s)},t.limit=function(e,r){return t.any([e,r.chain(t.canceled)]).chainRejected(e=>t.rejected(e[0]))},t.repeat=function(t){const e=()=>t().chainRejected(e);return e()}}(exports.Task||(exports.Task={}));const o=()=>{const t=()=>{};let e=t;return[r=>{const n=e;e=t,n(r)},t=>{e=t}]};function a(t,e){const r={cancel:t._cancel};return exports.Task.create(t._invoke.then(function(t){try{return Promise.resolve(function(t,e){try{var r=t()}catch(t){return e(t)}return r&&r.then?r.then(void 0,e):r}(function(){const{_invoke:n,_cancel:i}=exports.Task.fromFunction(()=>e(t),r);return r.cancel=i,Promise.resolve(n).then(function(t){if(t.isNothing())return exports.Maybe.nothing();if(t.just.isLeft())return exports.Maybe.just(exports.Either.left(t.just.left));const{_invoke:e,_cancel:n}=t.just.right;return r.cancel=n,e})},function(t){return exports.Maybe.just(exports.Either.left(t))}))}catch(t){return Promise.reject(t)}}),t=>r.cancel(t))}function u(t,e){return a(t,t=>t.map(e).orMap(exports.Task.canceled).just)}function h(t,e){return a(t,t=>e(t).matchMap({just:t=>t.matchMap({right:exports.Task.resolved,left:exports.Task.rejected}).right,nothing:exports.Task.canceled}).just)}function c(t,e){return h(t,t=>t.map(e))}function p(t,e){return h(t,t=>(e(t),t))}function f(t,e){return p(t,t=>t.tap(e))}class l{constructor(t,e){this._invoke=void 0,this._cancel=void 0,this._invoke=t,this._cancel=e}tapCanceled(t){return p(this,e=>e.orTap(t))}tapRejected(t){return f(this,e=>e.orTap(t))}tap(t){return f(this,e=>e.tap(t))}mapCanceled(t){return h(this,e=>e.orMap(()=>exports.Either.right(t())))}mapRejected(t){return c(this,e=>e.orMap(t))}map(t){return c(this,e=>e.map(t))}chainCanceled(t){const e=t=>t.map(exports.Task.resolved).orMap(exports.Task.rejected).right;return a(this,r=>r.map(e).orMap(t).just)}chainRejected(t){return u(this,e=>e.map(exports.Task.resolved).orMap(t).right)}chain(t){return u(this,e=>e.map(t).orMap(exports.Task.rejected).right)}resolve(){return this._invoke}cancel(){return this._cancel(exports.Maybe.nothing())}reject(t){return this._cancel(exports.Maybe.just(t))}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}matchTap(t){return p(this,e=>e.matchTap({just:e=>e.matchTap({right:t.resolved,left:t.rejected}),nothing:t.canceled}))}matchMap(t){return h(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}),nothing:()=>exports.Either.right(t.canceled())}))}matchChain(t){return a(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}).right,nothing:t.canceled}).just)}}
+var t;exports.Just=void 0,(exports.Just||(exports.Just={})).just=function(t){return t.just},exports.Maybe=void 0,(t=exports.Maybe||(exports.Maybe={})).just=function(t){return new e(t)},t.nothing=function(){return r},t.fromOptional=function(e){return void 0!==e?t.just(e):t.nothing()},t.fromNullable=function(e){return t.fromOptional(e).chain(e=>null!==e?t.just(e):t.nothing())},t.isJust=function(t){return t.isJust()},t.isNothing=function(t){return t.isNothing()},t.everyJust=function(e){return e.every(t.isJust)},t.someJust=function(e){return e.some(t.isJust)},t.everyNothing=function(e){return e.every(t.isNothing)},t.someNothing=function(e){return e.some(t.isNothing)},t.generate=function(e){const r=e(),n=e=>e.done?t.just(e.value):e.value.matchChain({just:t=>n(r.next(t)),nothing:t.nothing});return t.just(void 0).chain(()=>n(r.next()))};class e{constructor(t){this.just=void 0,this.just=t}tap(t){return t(this.just),this}orTap(){return this}map(t){return exports.Maybe.just(t(this.just))}orMap(){return this}chain(t){return t(this.just)}orChain(){return this}isJust(){return!0}isNothing(){return!1}matchTap(t){return this.tap(t.just)}matchMap(t){return this.map(t.just)}matchChain(t){return this.chain(t.just)}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}}const r=new class{tap(){return this}orTap(t){return t(),this}map(){return this}orMap(t){return exports.Maybe.just(t())}chain(){return this}orChain(t){return t()}isJust(){return!1}isNothing(){return!0}matchTap(t){return this.orTap(t.nothing)}matchMap(t){return this.orMap(t.nothing)}matchChain(t){return this.orChain(t.nothing)}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}};var n;exports.Right=void 0,(exports.Right||(exports.Right={})).right=function(t){return t.right},exports.Left=void 0,(exports.Left||(exports.Left={})).left=function(t){return t.left},exports.Either=void 0,(n=exports.Either||(exports.Either={})).right=function(t){return new i(t)},n.left=function(t){return new s(t)},n.fromOptional=function(t,e){return void 0!==t?n.right(t):n.left(e)},n.fromNullable=function(t,e){return n.fromOptional(t,e).chain(r=>null!==r?n.right(t):n.left(e))},n.isRight=function(t){return t.isRight()},n.isLeft=function(t){return t.isLeft()},n.everyRight=function(t){return t.every(n.isRight)},n.someRight=function(t){return t.some(n.isRight)},n.everyLeft=function(t){return t.every(n.isLeft)},n.someLeft=function(t){return t.some(n.isLeft)},n.generate=function(t){const e=t(),r=t=>t.done?n.right(t.value):t.value.matchChain({right:t=>r(e.next(t)),left:n.left});return n.right(void 0).chain(()=>r(e.next()))};class i{constructor(t){this.right=void 0,this.right=t}tap(t){return t(this.right),this}orTap(){return this}map(t){return exports.Either.right(t(this.right))}orMap(){return this}chain(t){return t(this.right)}orChain(){return this}isRight(){return!0}isLeft(){return!1}matchTap(t){return this.tap(t.right)}matchMap(t){return this.map(t.right)}matchChain(t){return this.chain(t.right)}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}}class s{constructor(t){this.left=void 0,this.left=t}tap(){return this}orTap(t){return t(this.left),this}map(){return this}orMap(t){return exports.Either.right(t(this.left))}chain(){return this}orChain(t){return t(this.left)}isRight(){return!1}isLeft(){return!0}matchTap(t){return this.orTap(t.left)}matchMap(t){return this.orMap(t.left)}matchChain(t){return this.orChain(t.left)}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}}exports.Task=void 0,function(t){function e(e,r){let n;const[i,s]=o();return t.create(new Promise(t=>{s(t),n=e(t=>i(exports.Maybe.just(exports.Either.right(t))),t=>i(exports.Maybe.just(exports.Either.left(t))))}),t=>{i(t.map(exports.Either.left)),r(n)})}t.create=function(t,e){return new l(t,e)},t.resolved=function(e){return t.create(Promise.resolve(exports.Maybe.just(exports.Either.right(e))),()=>{})},t.rejected=function(e){return t.create(Promise.resolve(exports.Maybe.just(exports.Either.left(e))),()=>{})},t.canceled=function(){return t.create(Promise.resolve(exports.Maybe.nothing()),()=>{})},t.fromPromise=function(e){const[r,n]=o();return t.create(new Promise(t=>{n(t),e.then(exports.Either.right,exports.Either.left).then(exports.Maybe.just).then(r)}),t=>r(t.map(exports.Either.left)))},t.fromFunction=function(e,r){const[n,i]=o(),s=t=>n(t.map(exports.Either.left));return r.cancel=s,t.create(new Promise(t=>{i(t);try{n(exports.Maybe.just(exports.Either.right(e())))}catch(t){n(exports.Maybe.just(exports.Either.left(t)))}}),s)},t.promiseGenerator=function(e){return t.fromPromise(e).generator()},t.timeoutGenerator=function(e){return t.timeout(e).generator()},t.lift=function(e){return function(){return t.fromPromise(e(...[].slice.call(arguments)))}},t.generate=function(e){const r=e(),n=e=>e.done?t.resolved(e.value):e.value.matchChain({resolved:t=>n(r.next(t)),rejected:t=>n(r.throw(t)),canceled:t.canceled});return t.resolved(void 0).chain(()=>n(r.next()))},t.timeout=function(t){return e(e=>setTimeout(()=>e(),t),clearTimeout)},t.fromCallback=e,t.sequence=function(e){return Array.from(e).reduce((t,e)=>t.chain(t=>e().map(e=>t.concat(e))),t.resolved([]))},t.all=function(e){const[r,n]=o(),i=Array.from(e),s=t=>i.forEach(e=>e._cancel(t)),a=i.map(exports.Maybe.nothing),u=t=>{r(t.map(exports.Either.left)),s(t)};return t.create(new Promise(t=>{if(n(t),i.length<1)return r(exports.Maybe.just(exports.Either.right([])));i.map((t,e)=>t.matchTap({resolved:t=>((t,e)=>{a[e]=exports.Maybe.just(t),exports.Maybe.everyJust(a)&&r(exports.Maybe.just(exports.Either.right(a.map(exports.Just.just))))})(t,e),rejected:t=>u(exports.Maybe.just(t)),canceled:()=>u(exports.Maybe.nothing())}))}),s)},t.any=function(e){const[r,n]=o(),i=Array.from(e),s=t=>i.forEach(e=>e._cancel(t)),a=i.map(exports.Maybe.nothing),u=t=>{r(t.map(exports.Either.right)),s(exports.Maybe.nothing())};return t.create(new Promise(t=>{if(n(t),i.length<1)return r(exports.Maybe.nothing());i.map((t,e)=>t.matchTap({resolved:t=>u(exports.Maybe.just(t)),rejected:t=>((t,e)=>{a[e]=exports.Maybe.just(t),exports.Maybe.everyJust(a)&&r(exports.Maybe.just(exports.Either.left(a.map(exports.Just.just))))})(t,e),canceled:()=>u(exports.Maybe.nothing())}))}),s)},t.limit=function(e,r){return t.any([e,r.chain(t.canceled)]).chainRejected(e=>t.rejected(e[0]))},t.repeat=function(t){const e=()=>t().chainRejected(e);return e()}}(exports.Task||(exports.Task={}));const o=()=>{const t=()=>{};let e=t;return[r=>{const n=e;e=t,n(r)},t=>{e=t}]};function a(t,e){const r={cancel:t._cancel};return exports.Task.create(t._invoke.then(function(t){try{return Promise.resolve(function(t,e){try{var r=t()}catch(t){return e(t)}return r&&r.then?r.then(void 0,e):r}(function(){const{_invoke:n,_cancel:i}=exports.Task.fromFunction(()=>e(t),r);return r.cancel=i,Promise.resolve(n).then(function(t){if(t.isNothing())return exports.Maybe.nothing();if(t.just.isLeft())return exports.Maybe.just(exports.Either.left(t.just.left));const{_invoke:e,_cancel:n}=t.just.right;return r.cancel=n,e})},function(t){return exports.Maybe.just(exports.Either.left(t))}))}catch(t){return Promise.reject(t)}}),t=>r.cancel(t))}function u(t,e){return a(t,t=>t.map(e).orMap(exports.Task.canceled).just)}function c(t,e){return a(t,t=>e(t).matchMap({just:t=>t.matchMap({right:exports.Task.resolved,left:exports.Task.rejected}).right,nothing:exports.Task.canceled}).just)}function h(t,e){return c(t,t=>t.map(e))}function p(t,e){return c(t,t=>(e(t),t))}function f(t,e){return p(t,t=>t.tap(e))}class l{constructor(t,e){this._invoke=void 0,this._cancel=void 0,this._invoke=t,this._cancel=e}tapCanceled(t){return p(this,e=>e.orTap(t))}tapRejected(t){return f(this,e=>e.orTap(t))}tap(t){return f(this,e=>e.tap(t))}mapCanceled(t){return c(this,e=>e.orMap(()=>exports.Either.right(t())))}mapRejected(t){return h(this,e=>e.orMap(t))}map(t){return h(this,e=>e.map(t))}chainCanceled(t){const e=t=>t.map(exports.Task.resolved).orMap(exports.Task.rejected).right;return a(this,r=>r.map(e).orMap(t).just)}chainRejected(t){return u(this,e=>e.map(exports.Task.resolved).orMap(t).right)}chain(t){return u(this,e=>e.map(t).orMap(exports.Task.rejected).right)}resolve(){return this._invoke}cancel(){return this._cancel(exports.Maybe.nothing())}reject(t){return this._cancel(exports.Maybe.just(t))}generator(){/*#__PURE__*/return regeneratorRuntime.mark(function t(e){return regeneratorRuntime.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,e;case 2:return t.abrupt("return",t.sent);case 3:case"end":return t.stop()}},t)})(this)}matchTap(t){return p(this,e=>e.matchTap({just:e=>e.matchTap({right:t.resolved,left:t.rejected}),nothing:t.canceled}))}matchMap(t){return c(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}),nothing:()=>exports.Either.right(t.canceled())}))}matchChain(t){return a(this,e=>e.matchMap({just:e=>e.matchMap({right:t.resolved,left:t.rejected}).right,nothing:t.canceled}).just)}}
 //# sourceMappingURL=t-tasks.js.map