ESM-compatible dep imports

Can't use subpath imports as tsc won't respect them for CJS consumers.
In any case this is really the responsibility of these upstream
packages.

docs/modules/Array.ts.md

@@ -237,8 +237,8 @@ filterA :: ((Applicative f) -> (a -> HKT f boolean) -> Array a -> HKT f (Array a
 **Example**
 
 ```ts
-import * as T from 'fp-ts/Task'
-import { Task } from 'fp-ts/Task'
+import * as T from 'fp-ts/lib/Task'
+import { Task } from 'fp-ts/lib/Task'
 import { filterA } from 'fp-ts-std/Array'
 
 const asyncIsEven = (n: number): Task<boolean> => T.of(n % 2 === 0)

docs/modules/Reader.ts.md

@@ -39,7 +39,7 @@ runReader :: r -> Reader r a -> a
 
 ```ts
 import { runReader } from 'fp-ts-std/Reader'
-import { pipe } from 'fp-ts/function'
+import { pipe } from 'fp-ts/lib/function'
 import * as R from 'fp-ts/Reader'
 
 type Env = { dependency: string }

docs/modules/ReaderEither.ts.md

@@ -67,9 +67,9 @@ runReaderEither :: r -> ReaderEither r e a -> Either e a
 
 ```ts
 import { runReaderEither } from 'fp-ts-std/ReaderEither'
-import { pipe } from 'fp-ts/function'
-import * as RE from 'fp-ts/ReaderEither'
-import * as E from 'fp-ts/Either'
+import { pipe } from 'fp-ts/lib/function'
+import * as RE from 'fp-ts/lib/ReaderEither'
+import * as E from 'fp-ts/lib/Either'
 
 type Env = { dependency: string }
 const env: Env = { dependency: 'dependency' }

docs/modules/ReaderIO.ts.md

@@ -66,8 +66,8 @@ runReaderIO :: r -> ReaderIO r a -> IO a
 
 ```ts
 import { runReaderIO } from 'fp-ts-std/ReaderIO'
-import { pipe } from 'fp-ts/function'
-import * as RIO from 'fp-ts/ReaderIO'
+import { pipe } from 'fp-ts/lib/function'
+import * as RIO from 'fp-ts/lib/ReaderIO'
 
 assert.strictEqual(pipe(RIO.of<string, number>(123), runReaderIO('env'))(), 123)
 ```

docs/modules/ReaderTask.ts.md

@@ -66,8 +66,8 @@ runReaderTask :: r -> ReaderTask r a -> Task a
 
 ```ts
 import { runReaderTask } from 'fp-ts-std/ReaderTask'
-import { pipe } from 'fp-ts/function'
-import * as RT from 'fp-ts/ReaderTask'
+import { pipe } from 'fp-ts/lib/function'
+import * as RT from 'fp-ts/lib/ReaderTask'
 
 type Env = { dependency: string }
 const env: Env = { dependency: 'dependency ' }

docs/modules/ReaderTaskEither.ts.md

@@ -113,9 +113,9 @@ export declare const runReaderTaskEither: <R, E, A>(
 
 ```ts
 import { runReaderTaskEither } from 'fp-ts-std/ReaderTaskEither'
-import { pipe } from 'fp-ts/function'
-import * as RTE from 'fp-ts/ReaderTaskEither'
-import * as E from 'fp-ts/Either'
+import { pipe } from 'fp-ts/lib/function'
+import * as RTE from 'fp-ts/lib/ReaderTaskEither'
+import * as E from 'fp-ts/lib/Either'
 
 type Env = { dependency: string }
 const env: Env = { dependency: 'dependency' }

docs/modules/ReadonlyArray.ts.md

@@ -237,8 +237,8 @@ filterA :: ((Applicative f) -> (a -> HKT f boolean) -> ReadonlyArray a -> HKT f
 **Example**
 
 ```ts
-import * as T from 'fp-ts/Task'
-import { Task } from 'fp-ts/Task'
+import * as T from 'fp-ts/lib/Task'
+import { Task } from 'fp-ts/lib/Task'
 import { filterA } from 'fp-ts-std/ReadonlyArray'
 
 const asyncIsEven = (n: number): Task<boolean> => T.of(n % 2 === 0)

src/Alternative.ts

@@ -23,10 +23,10 @@ import {
   Alternative3,
   Alternative3C,
   Alternative4,
-} from "fp-ts/Alternative"
+} from "fp-ts/lib/Alternative.js"
 import { Lazy } from "./Lazy.js"
-import { pipe } from "fp-ts/function"
-import * as A from "fp-ts/Array"
+import { pipe } from "fp-ts/lib/function.js"
+import * as A from "fp-ts/lib/Array.js"
 
 /**
  * Conditionally lifts a value to an `Alternative` context or returns

src/Applicative.ts

@@ -23,7 +23,7 @@ import {
   Applicative3,
   Applicative3C,
   Applicative4,
-} from "fp-ts/Applicative"
+} from "fp-ts/lib/Applicative.js"
 
 /**
  * Conditional execution of an applicative. Helpful for conditional side effects

src/Array.ts

@@ -4,27 +4,27 @@
  * @since 0.1.0
  */
 
-import { constant, pipe, flow, flip } from "fp-ts/function"
-import { Predicate, not } from "fp-ts/Predicate"
-import { Endomorphism } from "fp-ts/Endomorphism"
-import { Eq } from "fp-ts/Eq"
-import { Ord } from "fp-ts/Ord"
-import { match as orderingMatch } from "fp-ts/Ordering"
-import { Ord as ordNumber, MonoidProduct, MonoidSum } from "fp-ts/number"
-import { NonEmptyArray } from "fp-ts/NonEmptyArray"
-import * as NEA from "fp-ts/NonEmptyArray"
-import * as RA from "fp-ts/ReadonlyArray"
-import * as A from "fp-ts/Array"
-import * as R from "fp-ts/Record"
-import { Option } from "fp-ts/Option"
-import * as O from "fp-ts/Option"
-import * as B from "fp-ts/boolean"
-import { reduceM } from "fp-ts/Foldable"
-import { concatAll } from "fp-ts/Monoid"
-import { max, min } from "fp-ts/Semigroup"
+import { constant, pipe, flow, flip } from "fp-ts/lib/function.js"
+import { Predicate, not } from "fp-ts/lib/Predicate.js"
+import { Endomorphism } from "fp-ts/lib/Endomorphism.js"
+import { Eq } from "fp-ts/lib/Eq.js"
+import { Ord } from "fp-ts/lib/Ord.js"
+import { match as orderingMatch } from "fp-ts/lib/Ordering.js"
+import { Ord as ordNumber, MonoidProduct, MonoidSum } from "fp-ts/lib/number.js"
+import { NonEmptyArray } from "fp-ts/lib/NonEmptyArray.js"
+import * as NEA from "fp-ts/lib/NonEmptyArray.js"
+import * as RA from "fp-ts/lib/ReadonlyArray.js"
+import * as A from "fp-ts/lib/Array.js"
+import * as R from "fp-ts/lib/Record.js"
+import { Option } from "fp-ts/lib/Option.js"
+import * as O from "fp-ts/lib/Option.js"
+import * as B from "fp-ts/lib/boolean.js"
+import { reduceM } from "fp-ts/lib/Foldable.js"
+import { concatAll } from "fp-ts/lib/Monoid.js"
+import { max, min } from "fp-ts/lib/Semigroup.js"
 import { invoke } from "./Function.js"
-import { These } from "fp-ts/These"
-import * as T from "fp-ts/These"
+import { These } from "fp-ts/lib/These.js"
+import * as T from "fp-ts/lib/These.js"
 import {
   HKT,
   Kind,
@@ -43,7 +43,7 @@ import {
   Applicative3,
   Applicative4,
   Applicative2C,
-} from "fp-ts/Applicative"
+} from "fp-ts/lib/Applicative.js"
 import {
   Monad,
   Monad1,
@@ -52,8 +52,8 @@ import {
   Monad3,
   Monad3C,
   Monad4,
-} from "fp-ts/Monad"
-import { Either } from "fp-ts/Either"
+} from "fp-ts/lib/Monad.js"
+import { Either } from "fp-ts/lib/Either.js"
 
 /**
  * Like `fp-ts/Array::elem` but flipped, which the "V" suffix denotes.
@@ -852,8 +852,8 @@ export const zipAll =
  * and therefore `Task`-based, for example.
  *
  * @example
- * import * as T from "fp-ts/Task"
- * import { Task } from "fp-ts/Task"
+ * import * as T from "fp-ts/lib/Task.js"
+ * import { Task } from "fp-ts/lib/Task.js"
  * import { filterA } from "fp-ts-std/Array"
  *
  * const asyncIsEven = (n: number): Task<boolean> => T.of(n % 2 === 0)

src/Bifunctor.ts

@@ -12,7 +12,7 @@ import {
   Bifunctor3,
   Bifunctor3C,
   Bifunctor4,
-} from "fp-ts/Bifunctor"
+} from "fp-ts/lib/Bifunctor.js"
 
 /**
  * Apply a function to both elements of a bifunctor.

src/Boolean.ts

@@ -5,11 +5,11 @@
  * @since 0.1.0
  */
 
-import { Endomorphism } from "fp-ts/Endomorphism"
-import { SemigroupAll, SemigroupAny, Ord } from "fp-ts/boolean"
+import { Endomorphism } from "fp-ts/lib/Endomorphism.js"
+import { SemigroupAll, SemigroupAny, Ord } from "fp-ts/lib/boolean.js"
 import { curry2 } from "./Function.js"
-import * as O from "fp-ts/Option"
-import * as Bounded_ from "fp-ts/Bounded"
+import * as O from "fp-ts/lib/Option.js"
+import * as Bounded_ from "fp-ts/lib/Bounded.js"
 type Bounded<A> = Bounded_.Bounded<A>
 import * as Enum_ from "./Enum.js"
 import Enum = Enum_.Enum

src/DOM.ts

@@ -7,13 +7,13 @@
  * @since 0.12.0
  */
 
-import * as IO from "fp-ts/IO"
+import * as IO from "fp-ts/lib/IO.js"
 type IO<A> = IO.IO<A>
-import * as O from "fp-ts/Option"
-import { IOOption } from "fp-ts/IOOption"
-import { NonEmptyArray } from "fp-ts/NonEmptyArray"
-import * as NEA from "fp-ts/NonEmptyArray"
-import { constVoid, flow, pipe } from "fp-ts/function"
+import * as O from "fp-ts/lib/Option.js"
+import { IOOption } from "fp-ts/lib/IOOption.js"
+import { NonEmptyArray } from "fp-ts/lib/NonEmptyArray.js"
+import * as NEA from "fp-ts/lib/NonEmptyArray.js"
+import { constVoid, flow, pipe } from "fp-ts/lib/function.js"
 import { invoke } from "./Function.js"
 /**
  * Convert a `NodeList` into an `Array`.

src/Date.ts

@@ -4,17 +4,17 @@
  * @since 0.1.0
  */
 
-import { Newtype, iso, getField, getOrd } from "newtype-ts"
-import { flow, pipe } from "fp-ts/function"
-import { Refinement } from "fp-ts/Refinement"
-import { Predicate } from "fp-ts/Predicate"
+import { Newtype, iso, getField, getOrd } from "newtype-ts/lib/index.js"
+import { flow, pipe } from "fp-ts/lib/function.js"
+import { Refinement } from "fp-ts/lib/Refinement.js"
+import { Predicate } from "fp-ts/lib/Predicate.js"
 import { isValid as isValidNum } from "./Number.js"
-import { Field as fieldNumber, Ord as ordNumber } from "fp-ts/number"
-import { now as nownum } from "fp-ts/Date"
-import * as IO from "fp-ts/IO"
+import { Field as fieldNumber, Ord as ordNumber } from "fp-ts/lib/number.js"
+import { now as nownum } from "fp-ts/lib/Date.js"
+import * as IO from "fp-ts/lib/IO.js"
 type IO<A> = IO.IO<A>
-import { Option } from "fp-ts/Option"
-import * as O from "fp-ts/Option"
+import { Option } from "fp-ts/lib/Option.js"
+import * as O from "fp-ts/lib/Option.js"
 import { construct, invokeOn, isInstanceOf } from "./Function.js"
 import { pack, unpack } from "./Newtype.js"
 

src/Debug.ts

@@ -5,7 +5,7 @@
  * @since 0.2.0
  */
 
-import { Show } from "fp-ts/Show"
+import { Show } from "fp-ts/lib/Show.js"
 
 /* eslint-disable functional/no-expression-statements */
 

src/Either.ts

@@ -4,19 +4,19 @@
  * @since 0.1.0
  */
 
-import { Either } from "fp-ts/Either"
-import * as E from "fp-ts/Either"
-import * as O from "fp-ts/Option"
+import { Either } from "fp-ts/lib/Either.js"
+import * as E from "fp-ts/lib/Either.js"
+import * as O from "fp-ts/lib/Option.js"
 import { mapBoth as _mapBoth } from "./Bifunctor.js"
-import { Show } from "fp-ts/Show"
-import { constant, flow, pipe } from "fp-ts/function"
+import { Show } from "fp-ts/lib/Show.js"
+import { constant, flow, pipe } from "fp-ts/lib/function.js"
 import * as L from "./Lazy.js"
-import { Ord } from "fp-ts/Ord"
-import { Bounded } from "fp-ts/Bounded"
+import { Ord } from "fp-ts/lib/Ord.js"
+import { Bounded } from "fp-ts/lib/Bounded.js"
 import { Enum } from "./Enum.js"
 import { add } from "./Number.js"
 import { curry2 } from "./Function.js"
-import { Ordering } from "fp-ts/Ordering"
+import { Ordering } from "fp-ts/lib/Ordering.js"
 import { LT, GT } from "./Ordering.js"
 
 /**

src/Enum.ts

@@ -10,19 +10,19 @@
  * @since 0.17.0
  */
 
-import { constant, flow, pipe } from "fp-ts/function"
-import { Ord } from "fp-ts/Ord"
-import { Bounded } from "fp-ts/Bounded"
-import * as O from "fp-ts/Option"
+import { constant, flow, pipe } from "fp-ts/lib/function.js"
+import { Ord } from "fp-ts/lib/Ord.js"
+import { Bounded } from "fp-ts/lib/Bounded.js"
+import * as O from "fp-ts/lib/Option.js"
 import Option = O.Option
 import { unsafeExpect as unsafeExpectO } from "./Option.js"
-import * as NEA from "fp-ts/NonEmptyArray"
+import * as NEA from "fp-ts/lib/NonEmptyArray.js"
 import NonEmptyArray = NEA.NonEmptyArray
-import * as A from "fp-ts/Array"
+import * as A from "fp-ts/lib/Array.js"
 import { dup, toFst, toSnd } from "./Tuple.js"
-import * as Map from "fp-ts/Map"
-import { Eq } from "fp-ts/Eq"
-import * as Semigroup from "fp-ts/Semigroup"
+import * as Map from "fp-ts/lib/Map.js"
+import { Eq } from "fp-ts/lib/Eq.js"
+import * as Semigroup from "fp-ts/lib/Semigroup.js"
 import { increment, decrement, add } from "./Number.js"
 import * as L from "./Lazy.js"
 import Lazy = L.Lazy

src/Env.ts

@@ -5,9 +5,9 @@
  * @since 0.9.0
  */
 
-import { pipe, flow } from "fp-ts/function"
-import * as O from "fp-ts/Option"
-import * as IOO from "fp-ts/IOOption"
+import { pipe, flow } from "fp-ts/lib/function.js"
+import * as O from "fp-ts/lib/Option.js"
+import * as IOO from "fp-ts/lib/IOOption.js"
 import IOOption = IOO.IOOption
 import * as NES from "./NonEmptyString.js"
 import NonEmptyString = NES.NonEmptyString

src/Function.ts

@@ -7,9 +7,9 @@
  * @since 0.1.0
  */
 
-import * as O from "fp-ts/Option"
-import * as M from "fp-ts/Map"
-import * as A from "fp-ts/Array"
+import * as O from "fp-ts/lib/Option.js"
+import * as M from "fp-ts/lib/Map.js"
+import * as A from "fp-ts/lib/Array.js"
 import {
   flow,
   pipe,
@@ -18,22 +18,25 @@ import {
   constant,
   flip,
   tupled,
-} from "fp-ts/function"
-import { Predicate, not } from "fp-ts/Predicate"
-import { Endomorphism, getMonoid as getEndoMonoid } from "fp-ts/Endomorphism"
-import { concatAll } from "fp-ts/Monoid"
-import { first } from "fp-ts/Semigroup"
-import { Eq } from "fp-ts/Eq"
-import { Refinement } from "fp-ts/Refinement"
-import { Functor2, bindTo as bindTo_, let as let__ } from "fp-ts/Functor"
+} from "fp-ts/lib/function.js"
+import { Predicate, not } from "fp-ts/lib/Predicate.js"
+import {
+  Endomorphism,
+  getMonoid as getEndoMonoid,
+} from "fp-ts/lib/Endomorphism.js"
+import { concatAll } from "fp-ts/lib/Monoid.js"
+import { first } from "fp-ts/lib/Semigroup.js"
+import { Eq } from "fp-ts/lib/Eq.js"
+import { Refinement } from "fp-ts/lib/Refinement.js"
+import { Functor2, bindTo as bindTo_, let as let__ } from "fp-ts/lib/Functor.js"
 import {
   apFirst as apFirst_,
   apSecond as apSecond_,
   apS as apS_,
-} from "fp-ts/Apply"
-import { Applicative2 } from "fp-ts/Applicative"
-import { bind as bind_ } from "fp-ts/Chain"
-import { Monad2 } from "fp-ts/Monad"
+} from "fp-ts/lib/Apply.js"
+import { Applicative2 } from "fp-ts/lib/Applicative.js"
+import { bind as bind_ } from "fp-ts/lib/Chain.js"
+import { Monad2 } from "fp-ts/lib/Monad.js"
 
 /**
  * Typeclass machinery.