diff --git a/docs/modules/Align/Array.ts.md b/docs/modules/Align/Array.ts.md
index 9b584e5..e88b5d5 100644
--- a/docs/modules/Align/Array.ts.md
+++ b/docs/modules/Align/Array.ts.md
@@ -51,8 +51,8 @@ export declare const lpadZip: <A, B>(xs: A[], ys: B[]) => [Option<A>, B][]
 **Example**
 
 ```ts
-import { some, none } from 'fp-ts/lib/Option'
-import { lpadZip } from 'fp-ts-contrib/lib/Align/Array'
+import { some, none } from 'fp-ts/Option'
+import { lpadZip } from 'fp-ts-contrib/Align/Array'
 
 assert.deepStrictEqual(lpadZip([1, 2], ['a', 'b', 'c']), [
   [some(1), 'a'],
@@ -83,9 +83,9 @@ export declare const lpadZipWith: <A, B, C>(xs: A[], ys: B[], f: (a: Option<A>,
 **Example**
 
 ```ts
-import * as O from 'fp-ts/lib/Option'
-import { lpadZipWith } from 'fp-ts-contrib/lib/Align/Array'
-import { pipe } from 'fp-ts/lib/pipeable'
+import * as O from 'fp-ts/Option'
+import { lpadZipWith } from 'fp-ts-contrib/Align/Array'
+import { pipe } from 'fp-ts/function'
 
 const f = (ma: O.Option<number>, b: string) =>
   pipe(
@@ -117,8 +117,8 @@ export declare const rpadZip: <A, B>(xs: A[], ys: B[]) => [A, Option<B>][]
 **Example**
 
 ```ts
-import { some, none } from 'fp-ts/lib/Option'
-import { rpadZip } from 'fp-ts-contrib/lib/Align/Array'
+import { some, none } from 'fp-ts/Option'
+import { rpadZip } from 'fp-ts-contrib/Align/Array'
 
 assert.deepStrictEqual(rpadZip([1, 2, 3], ['a', 'b']), [
   [1, some('a')],
@@ -149,8 +149,8 @@ export declare const rpadZipWith: <A, B, C>(xs: A[], ys: B[], f: (a: A, b: Optio
 **Example**
 
 ```ts
-import { Option, getOrElse } from 'fp-ts/lib/Option'
-import { rpadZipWith } from 'fp-ts-contrib/lib/Align/Array'
+import { Option, getOrElse } from 'fp-ts/Option'
+import { rpadZipWith } from 'fp-ts-contrib/Align/Array'
 
 const f = (a: number, mb: Option<string>) => a.toString() + getOrElse(() => '*')(mb)
 assert.deepStrictEqual(rpadZipWith([1, 2, 3, 4], ['a', 'b', 'c'], f), ['1a', '2b', '3c', '4*'])
diff --git a/docs/modules/Align/index.ts.md b/docs/modules/Align/index.ts.md
index bfacdb6..63e5204 100644
--- a/docs/modules/Align/index.ts.md
+++ b/docs/modules/Align/index.ts.md
@@ -123,9 +123,9 @@ export declare function padZip<F>(F: Align<F>): <A, B>(fa: HKT<F, A>, fb: HKT<F,
 **Example**
 
 ```ts
-import { some, none } from 'fp-ts/lib/Option'
-import { padZip } from 'fp-ts-contrib/lib/Align'
-import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+import { some, none } from 'fp-ts/Option'
+import { padZip } from 'fp-ts-contrib/Align'
+import { alignArray } from 'fp-ts-contrib/Align/Array'
 
 assert.deepStrictEqual(padZip(alignArray)([1, 2, 3], [4, 5]), [
   [some(1), some(4)],
@@ -169,10 +169,10 @@ export declare function padZipWith<F>(
 **Example**
 
 ```ts
-import { Option, fold, getOrElse } from 'fp-ts/lib/Option'
-import { padZipWith } from 'fp-ts-contrib/lib/Align'
-import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
-import { pipe } from 'fp-ts/lib/pipeable'
+import { Option, fold, getOrElse } from 'fp-ts/Option'
+import { padZipWith } from 'fp-ts-contrib/Align'
+import { alignArray } from 'fp-ts-contrib/Align/Array'
+import { pipe } from 'fp-ts/function'
 
 const f = (ma: Option<number>, mb: Option<string>) =>
   pipe(
@@ -222,9 +222,9 @@ export declare function salign<F, A>(F: Align<F>, S: Semigroup<A>): (fx: HKT<F,
 **Example**
 
 ```ts
-import { semigroupSum } from 'fp-ts/lib/Semigroup'
-import { salign } from 'fp-ts-contrib/lib/Align'
-import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+import { semigroupSum } from 'fp-ts/Semigroup'
+import { salign } from 'fp-ts-contrib/Align'
+import { alignArray } from 'fp-ts-contrib/Align/Array'
 
 assert.deepStrictEqual(salign(alignArray, semigroupSum)([1, 2, 3], [4, 5]), [5, 7, 3])
 ```
diff --git a/docs/modules/Do.ts.md b/docs/modules/Do.ts.md
index 748414b..8d8ed1f 100644
--- a/docs/modules/Do.ts.md
+++ b/docs/modules/Do.ts.md
@@ -47,8 +47,8 @@ export declare function Do<M>(M: Monad<M>): Do0<M, {}>
 **Example**
 
 ```ts
-import { option, some } from 'fp-ts/lib/Option'
-import { Do } from 'fp-ts-contrib/lib/Do'
+import { option, some } from 'fp-ts/Option'
+import { Do } from 'fp-ts-contrib/Do'
 
 // x: Option<number>
 const x = Do(option) // <- a monad instance
diff --git a/docs/modules/List.ts.md b/docs/modules/List.ts.md
index 18bec5f..c39254a 100644
--- a/docs/modules/List.ts.md
+++ b/docs/modules/List.ts.md
@@ -72,7 +72,7 @@ export declare const of: <A>(head: A) => List<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.of('a'), L.cons('a', L.nil))
 ```
@@ -150,7 +150,7 @@ export declare const dropLeft: (n: number) => <A>(fa: List<A>) => List<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.dropLeft(1)(L.nil), L.nil)
 assert.deepStrictEqual(L.dropLeft(1)(L.cons(1, L.of(2))), L.of(2))
@@ -172,7 +172,7 @@ export declare const reverse: <A>(fa: List<A>) => List<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.reverse(L.cons(1, L.cons(2, L.of(3)))), L.cons(3, L.cons(2, L.of(1))))
 ```
@@ -194,7 +194,7 @@ export declare const cons: <A>(head: A, tail: List<A>) => List<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.cons('a', L.nil), { type: 'Cons', head: 'a', tail: L.nil, length: 1 })
 ```
@@ -214,7 +214,7 @@ export declare const fromArray: <A>(as: A[]) => List<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.fromArray([]), L.nil)
 assert.deepStrictEqual(L.fromArray(['a', 'b']), L.cons('a', L.of('b')))
@@ -247,7 +247,7 @@ export declare const foldLeft: <A, B>(onNil: () => B, onCons: (head: A, tail: Li
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 const len: <A>(as: L.List<A>) => number = L.foldLeft(
   () => 0,
@@ -271,8 +271,8 @@ export declare const head: <A>(fa: List<A>) => O.Option<A>
 **Example**
 
 ```ts
-import * as O from 'fp-ts/lib/Option'
-import * as L from 'fp-ts-contrib/lib/List'
+import * as O from 'fp-ts/Option'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.head(L.nil), O.none)
 assert.deepStrictEqual(L.head(L.cons('x', L.of('a'))), O.some('x'))
@@ -293,8 +293,8 @@ export declare const tail: <A>(fa: List<A>) => O.Option<List<A>>
 **Example**
 
 ```ts
-import * as O from 'fp-ts/lib/Option'
-import * as L from 'fp-ts-contrib/lib/List'
+import * as O from 'fp-ts/Option'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.tail(L.nil), O.none)
 assert.deepStrictEqual(L.tail(L.of('a')), O.some(L.nil))
@@ -316,7 +316,7 @@ export declare const toArray: <A>(fa: List<A>) => A[]
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.toArray(L.cons('a', L.of('b'))), ['a', 'b'])
 ```
@@ -336,7 +336,7 @@ export declare const toReversedArray: <A>(fa: List<A>) => A[]
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.deepStrictEqual(L.toReversedArray(L.cons('a', L.of('b'))), ['b', 'a'])
 ```
@@ -411,8 +411,8 @@ export declare const getEq: <A>(E: Eq.Eq<A>) => Eq.Eq<List<A>>
 **Example**
 
 ```ts
-import { eqString } from 'fp-ts/lib/Eq'
-import * as L from 'fp-ts-contrib/lib/List'
+import { eqString } from 'fp-ts/Eq'
+import * as L from 'fp-ts-contrib/List'
 
 const E = L.getEq(eqString)
 assert.strictEqual(E.equals(L.cons('a', L.of('b')), L.cons('a', L.of('b'))), true)
@@ -487,7 +487,7 @@ export declare function dropLeftWhile<A>(predicate: Predicate<A>): (fa: List<A>)
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 const isLTThree = (n: number) => n < 3
 assert.deepStrictEqual(L.dropLeftWhile(isLTThree)(L.nil), L.nil)
@@ -510,8 +510,8 @@ export declare const findIndex: <A>(predicate: Predicate<A>) => (fa: List<A>) =>
 **Example**
 
 ```ts
-import * as O from 'fp-ts/lib/Option'
-import * as L from 'fp-ts-contrib/lib/List'
+import * as O from 'fp-ts/Option'
+import * as L from 'fp-ts-contrib/List'
 
 const f = (a: number): boolean => a % 2 === 0
 const findIndexEven = L.findIndex(f)
@@ -535,7 +535,7 @@ export declare const isCons: <A>(a: List<A>) => a is Cons<A>
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.strictEqual(L.isCons(L.nil), false)
 assert.strictEqual(L.isCons(L.of(1)), true)
@@ -556,7 +556,7 @@ export declare const isNil: <A>(a: List<A>) => a is Nil
 **Example**
 
 ```ts
-import * as L from 'fp-ts-contrib/lib/List'
+import * as L from 'fp-ts-contrib/List'
 
 assert.strictEqual(L.isNil(L.nil), true)
 assert.strictEqual(L.isNil(L.of(6)), false)
diff --git a/docs/modules/RegExp.ts.md b/docs/modules/RegExp.ts.md
index d942045..60faea9 100644
--- a/docs/modules/RegExp.ts.md
+++ b/docs/modules/RegExp.ts.md
@@ -39,9 +39,9 @@ export declare const match: (r: RegExp) => (s: string) => O.Option<RegExpMatchAr
 **Example**
 
 ```ts
-import * as O from 'fp-ts/lib/Option'
-import { match } from 'fp-ts-contrib/lib/RegExp'
-import { pipe } from 'fp-ts/lib/pipeable'
+import * as O from 'fp-ts/Option'
+import { match } from 'fp-ts-contrib/RegExp'
+import { pipe } from 'fp-ts/function'
 
 const myMatch = match(/^(\d)(\w)$/)
 assert.deepStrictEqual(pipe('2e', myMatch, O.map(Array.from)), O.some(['2e', '2', 'e']))
@@ -64,7 +64,7 @@ export declare const split: (r: RegExp) => (s: string) => NonEmptyArray<string>
 **Example**
 
 ```ts
-import { split } from 'fp-ts-contrib/lib/RegExp'
+import { split } from 'fp-ts-contrib/RegExp'
 
 const splitByHash = split(/#/)
 assert.deepStrictEqual(splitByHash('foo#bar#beer'), ['foo', 'bar', 'beer'])
@@ -87,7 +87,7 @@ export declare const sub: (r: RegExp, replacement: string) => (s: string) => str
 **Example**
 
 ```ts
-import { sub } from 'fp-ts-contrib/lib/RegExp'
+import { sub } from 'fp-ts-contrib/RegExp'
 
 const sanitiseSpaces = sub(/\s/g, '_')
 assert.strictEqual(sanitiseSpaces('foo bar owl'), 'foo_bar_owl')
@@ -109,7 +109,7 @@ export declare const test: (r: RegExp) => Predicate<string>
 **Example**
 
 ```ts
-import { test } from 'fp-ts-contrib/lib/RegExp'
+import { test } from 'fp-ts-contrib/RegExp'
 
 const myTest = test(/^(\d)(\w)$/)
 assert.strictEqual(myTest('6s'), true)
diff --git a/docs/modules/Task/withTimeout.ts.md b/docs/modules/Task/withTimeout.ts.md
index a54ebb5..7568035 100644
--- a/docs/modules/Task/withTimeout.ts.md
+++ b/docs/modules/Task/withTimeout.ts.md
@@ -32,8 +32,8 @@ export declare const withTimeout: <A>(onTimeout: A, millis: number) => (ma: Task
 **Example**
 
 ```ts
-import { withTimeout } from 'fp-ts-contrib/lib/Task/withTimeout'
-import { delay, of } from 'fp-ts/lib/Task'
+import { withTimeout } from 'fp-ts-contrib/Task/withTimeout'
+import { delay, of } from 'fp-ts/Task'
 
 const completeAfter2s = delay(2000)(of('result'))
 
diff --git a/docs/modules/collectUntil.ts.md b/docs/modules/collectUntil.ts.md
index a3dade3..5fc79c3 100644
--- a/docs/modules/collectUntil.ts.md
+++ b/docs/modules/collectUntil.ts.md
@@ -48,12 +48,12 @@ export declare function collectUntil<M, F>(
 **Example**
 
 ```ts
-import { array } from 'fp-ts/lib/Array'
-import * as E from 'fp-ts/lib/Either'
-import { flow } from 'fp-ts/lib/function'
-import * as O from 'fp-ts/lib/Option'
-import * as TE from 'fp-ts/lib/TaskEither'
-import { collectUntil } from 'fp-ts-contrib/lib/collectUntil'
+import { array } from 'fp-ts/Array'
+import * as E from 'fp-ts/Either'
+import { flow } from 'fp-ts/function'
+import * as O from 'fp-ts/Option'
+import * as TE from 'fp-ts/TaskEither'
+import { collectUntil } from 'fp-ts-contrib/collectUntil'
 
 interface Page {
   rows: Array<string>
diff --git a/docs/modules/filterA.ts.md b/docs/modules/filterA.ts.md
index 32dea47..13fb5e9 100644
--- a/docs/modules/filterA.ts.md
+++ b/docs/modules/filterA.ts.md
@@ -49,8 +49,8 @@ export declare function filterA<F>(
 **Example**
 
 ```ts
-import { io, IO } from 'fp-ts/lib/IO'
-import { filterA } from 'fp-ts-contrib/lib/filterA'
+import { io, IO } from 'fp-ts/IO'
+import { filterA } from 'fp-ts-contrib/filterA'
 
 const filterAIO = filterA(io)
 
diff --git a/docs/modules/time.ts.md b/docs/modules/time.ts.md
index 1bd3cfd..dd09408 100644
--- a/docs/modules/time.ts.md
+++ b/docs/modules/time.ts.md
@@ -41,9 +41,9 @@ export declare function time<M>(M: MonadIO<M>): <A>(ma: HKT<M, A>) => HKT<M, [A,
 **Example**
 
 ```ts
-import { io } from 'fp-ts/lib/IO'
-import { randomInt } from 'fp-ts/lib/Random'
-import { time } from 'fp-ts-contrib/lib/time'
+import { io } from 'fp-ts/IO'
+import { randomInt } from 'fp-ts/Random'
+import { time } from 'fp-ts-contrib/time'
 
 const timeIO = time(io)
 
diff --git a/src/Align/Array.ts b/src/Align/Array.ts
index dc31aa5..f8f30b5 100644
--- a/src/Align/Array.ts
+++ b/src/Align/Array.ts
@@ -25,9 +25,9 @@ export const alignArray: Align1<URI> = {
    * Uses the `These` data type to handle arrays of different lengths.
    *
    * @example
-   * import { These } from 'fp-ts/lib/These'
-   * import { identity } from 'fp-ts/lib/function'
-   * import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+   * import { These } from 'fp-ts/These'
+   * import { identity } from 'fp-ts/function'
+   * import { alignArray } from 'fp-ts-contrib/Align/Array'
    *
    * const f = (x: These<number, string>) => x.fold(a => a.toString(), identity, (a, b) => a + b)
    *
@@ -60,9 +60,9 @@ export const alignArray: Align1<URI> = {
    * Takes two arrays and returns an array of corresponding pairs combined using the `These` data type.
    *
    * @example
-   * import { These } from 'fp-ts/lib/These'
-   * import { identity } from 'fp-ts/lib/function'
-   * import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+   * import { These } from 'fp-ts/These'
+   * import { identity } from 'fp-ts/function'
+   * import { alignArray } from 'fp-ts-contrib/Align/Array'
    *
    * assert.deepStrictEqual(alignArray.align([1, 2], ['a', 'b']), [both(1, 'a'), both(2, 'b')])
    * assert.deepStrictEqual(alignArray.align([1, 2], ['a']), [both(1, 'a'), left(2)])
@@ -82,9 +82,9 @@ export const alignArray: Align1<URI> = {
  * It is similar to `zipWith`, but it doesn't discard elements when the left input array is shorter than the right.
  *
  * @example
- * import * as O from 'fp-ts/lib/Option'
- * import { lpadZipWith } from 'fp-ts-contrib/lib/Align/Array'
- * import { pipe } from 'fp-ts/lib/pipeable'
+ * import * as O from 'fp-ts/Option'
+ * import { lpadZipWith } from 'fp-ts-contrib/Align/Array'
+ * import { pipe } from 'fp-ts/function'
  *
  * const f = (ma: O.Option<number>, b: string) =>
  *   pipe(
@@ -109,8 +109,8 @@ export const lpadZipWith: <A, B, C>(xs: Array<A>, ys: Array<B>, f: (a: Option<A>
  * It is similar to `zip`, but it doesn't discard elements when the left input array is shorter than the right.
  *
  * @example
- * import { some, none } from 'fp-ts/lib/Option'
- * import { lpadZip } from 'fp-ts-contrib/lib/Align/Array'
+ * import { some, none } from 'fp-ts/Option'
+ * import { lpadZip } from 'fp-ts-contrib/Align/Array'
  *
  * assert.deepStrictEqual(lpadZip([1, 2], ['a', 'b', 'c']), [[some(1), 'a'], [some(2), 'b'], [none, 'c']])
  * assert.deepStrictEqual(lpadZip([1, 2, 3], ['a', 'b']), [[some(1), 'a'], [some(2), 'b']])
@@ -127,8 +127,8 @@ export const lpadZip: <A, B>(xs: Array<A>, ys: Array<B>) => Array<[Option<A>, B]
  * It is similar to `zipWith`, but it doesn't discard elements when the right input array is shorter than the left.
  *
  * @example
- * import { Option, getOrElse } from 'fp-ts/lib/Option'
- * import { rpadZipWith } from 'fp-ts-contrib/lib/Align/Array'
+ * import { Option, getOrElse } from 'fp-ts/Option'
+ * import { rpadZipWith } from 'fp-ts-contrib/Align/Array'
  *
  * const f = (a: number, mb: Option<string>) => a.toString() + getOrElse(() => '*')(mb)
  * assert.deepStrictEqual(rpadZipWith([1, 2, 3, 4], ['a', 'b', 'c'], f), ['1a', '2b', '3c', '4*'])
@@ -149,8 +149,8 @@ export const rpadZipWith: <A, B, C>(xs: Array<A>, ys: Array<B>, f: (a: A, b: Opt
  * It is similar to `zip`, but it doesn't discard elements when the right input array is shorter than the left.
  *
  * @example
- * import { some, none } from 'fp-ts/lib/Option'
- * import { rpadZip } from 'fp-ts-contrib/lib/Align/Array'
+ * import { some, none } from 'fp-ts/Option'
+ * import { rpadZip } from 'fp-ts-contrib/Align/Array'
  *
  * assert.deepStrictEqual(rpadZip([1, 2, 3], ['a', 'b']), [[1, some('a')], [2, some('b')], [3, none]])
  * assert.deepStrictEqual(rpadZip([1, 2], ['a', 'b', 'c']), [[1, some('a')], [2, some('b')]])
diff --git a/src/Align/Option.ts b/src/Align/Option.ts
index aa5a2d8..4bb0b96 100644
--- a/src/Align/Option.ts
+++ b/src/Align/Option.ts
@@ -26,10 +26,10 @@ export const alignOption: Align1<URI> = {
    * to handle the possibility of non existing values.
    *
    * @example
-   * import { some, none } from 'fp-ts/lib/Option'
-   * import { These } from 'fp-ts/lib/These'
-   * import { identity } from 'fp-ts/lib/function'
-   * import { alignOption } from 'fp-ts-contrib/lib/Align/Option'
+   * import { some, none } from 'fp-ts/Option'
+   * import { These } from 'fp-ts/These'
+   * import { identity } from 'fp-ts/function'
+   * import { alignOption } from 'fp-ts-contrib/Align/Option'
    *
    * const f = (x: These<number, string>) => x.fold(a => a.toString(), identity, (a, b) => a + b)
    *
@@ -55,9 +55,9 @@ export const alignOption: Align1<URI> = {
    * Takes two Option's and returns an Option with a value corresponding to the inputs combined using the `These` data type.
    *
    * @example
-   * import { some, none } from 'fp-ts/lib/Option'
-   * import { both, left, right } from 'fp-ts/lib/These'
-   * import { alignOption } from 'fp-ts-contrib/lib/Align/Option'
+   * import { some, none } from 'fp-ts/Option'
+   * import { both, left, right } from 'fp-ts/These'
+   * import { alignOption } from 'fp-ts-contrib/Align/Option'
    *
    * assert.deepStrictEqual(alignOption.align(some(1), some('a')), some(both(1, 'a')))
    * assert.deepStrictEqual(alignOption.align(some(1, none), some(left(1)))
diff --git a/src/Align/index.ts b/src/Align/index.ts
index b1f407a..f5cbd93 100644
--- a/src/Align/index.ts
+++ b/src/Align/index.ts
@@ -58,9 +58,9 @@ export interface Align3<F extends URIS3> extends Semialign3<F> {
  * Align two structures, using a semigroup for combining values.
  *
  * @example
- * import { semigroupSum } from 'fp-ts/lib/Semigroup'
- * import { salign } from 'fp-ts-contrib/lib/Align'
- * import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+ * import { semigroupSum } from 'fp-ts/Semigroup'
+ * import { salign } from 'fp-ts-contrib/Align'
+ * import { alignArray } from 'fp-ts-contrib/Align/Array'
  *
  * assert.deepStrictEqual(salign(alignArray, semigroupSum)([1, 2, 3], [4, 5]), [5, 7, 3])
  *
@@ -90,9 +90,9 @@ export function salign<F, A>(F: Align<F>, S: Semigroup<A>): (fx: HKT<F, A>, fy:
  * It is similar to `zip`, but it doesn't discard elements.
  *
  * @example
- * import { some, none } from 'fp-ts/lib/Option'
- * import { padZip } from 'fp-ts-contrib/lib/Align'
- * import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
+ * import { some, none } from 'fp-ts/Option'
+ * import { padZip } from 'fp-ts-contrib/Align'
+ * import { alignArray } from 'fp-ts-contrib/Align/Array'
  *
  * assert.deepStrictEqual(padZip(alignArray)([1, 2, 3], [4, 5]), [[some(1), some(4)], [some(2), some(5)], [some(3), none]])
  *
@@ -121,10 +121,10 @@ export function padZip<F>(F: Align<F>): <A, B>(fa: HKT<F, A>, fb: HKT<F, B>) =>
  * It is similar to `zipWith`, but it doesn't discard elements.
  *
  * @example
- * import { Option, fold, getOrElse } from 'fp-ts/lib/Option'
- * import { padZipWith } from 'fp-ts-contrib/lib/Align'
- * import { alignArray } from 'fp-ts-contrib/lib/Align/Array'
- * import { pipe } from 'fp-ts/lib/pipeable'
+ * import { Option, fold, getOrElse } from 'fp-ts/Option'
+ * import { padZipWith } from 'fp-ts-contrib/Align'
+ * import { alignArray } from 'fp-ts-contrib/Align/Array'
+ * import { pipe } from 'fp-ts/function'
  *
  * const f = (ma: Option<number>, mb: Option<string>) =>
  *   pipe(
diff --git a/src/Do.ts b/src/Do.ts
index 1ae7279..01a87a1 100644
--- a/src/Do.ts
+++ b/src/Do.ts
@@ -211,8 +211,8 @@ const init = {}
  * function returns the scope.
  *
  * @example
- * import { option, some } from 'fp-ts/lib/Option'
- * import { Do } from 'fp-ts-contrib/lib/Do'
+ * import { option, some } from 'fp-ts/Option'
+ * import { Do } from 'fp-ts-contrib/Do'
  *
  * // x: Option<number>
  * const x = Do(option) // <- a monad instance
diff --git a/src/List.ts b/src/List.ts
index 2c099b5..ca529d6 100644
--- a/src/List.ts
+++ b/src/List.ts
@@ -58,7 +58,7 @@ export const nil: List<never> = { type: 'Nil', length: 0 }
  * Attaches an element to the front of a list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.cons('a', L.nil), { type: 'Cons', head: 'a', tail: L.nil, length: 1 })
  *
@@ -76,7 +76,7 @@ export const cons: <A>(head: A, tail: List<A>) => List<A> = (head, tail) => ({
  * Creates a list from an array
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.fromArray([]), L.nil)
  * assert.deepStrictEqual(L.fromArray(['a', 'b']), L.cons('a', L.of('b')))
@@ -94,8 +94,8 @@ export const fromArray = <A>(as: Array<A>): List<A> => A.array.reduceRight<A, Li
  * Gets the first element in a list, or `None` if the list is empty.
  *
  * @example
- * import * as O from 'fp-ts/lib/Option'
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as O from 'fp-ts/Option'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.head(L.nil), O.none)
  * assert.deepStrictEqual(L.head(L.cons('x', L.of('a'))), O.some('x'))
@@ -109,8 +109,8 @@ export const head: <A>(fa: List<A>) => O.Option<A> = (fa) => (isCons(fa) ? O.som
  * Gets all but the first element of a list, or `None` if the list is empty.
  *
  * @example
- * import * as O from 'fp-ts/lib/Option'
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as O from 'fp-ts/Option'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.tail(L.nil), O.none)
  * assert.deepStrictEqual(L.tail(L.of('a')), O.some(L.nil))
@@ -125,7 +125,7 @@ export const tail: <A>(fa: List<A>) => O.Option<List<A>> = (fa) => (isCons(fa) ?
  * Breaks a list into its first element and the remaining elements.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * const len: <A>(as: L.List<A>) => number = L.foldLeft(
  *   () => 0,
@@ -145,7 +145,7 @@ export const foldLeft: <A, B>(onNil: () => B, onCons: (head: A, tail: List<A>) =
  * Gets an array from a list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.toArray(L.cons('a', L.of('b'))), ['a', 'b'])
  *
@@ -167,7 +167,7 @@ export const toArray = <A>(fa: List<A>): Array<A> => {
  * Gets an array from a list in a reversed order.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.toReversedArray(L.cons('a', L.of('b'))), ['b', 'a'])
  *
@@ -193,7 +193,7 @@ export const toReversedArray = <A>(fa: List<A>): Array<A> => {
  * Reverse a list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.reverse(L.cons(1, L.cons(2, L.of(3)))), L.cons(3, L.cons(2, L.of(1))))
  *
@@ -214,7 +214,7 @@ export const reverse = <A>(fa: List<A>): List<A> => {
  * Drops the specified number of elements from the front of a list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.dropLeft(1)(L.nil), L.nil)
  * assert.deepStrictEqual(L.dropLeft(1)(L.cons(1, L.of(2))), L.of(2))
@@ -238,7 +238,7 @@ export const dropLeft = (n: number) => <A>(fa: List<A>): List<A> => {
  * Drops those elements from the front of a list which match a predicate.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * const isLTThree = (n: number) => n < 3
  * assert.deepStrictEqual(L.dropLeftWhile(isLTThree)(L.nil), L.nil)
@@ -358,7 +358,7 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(
  * Creates a list with a single element.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.deepStrictEqual(L.of('a'), L.cons('a', L.nil))
  *
@@ -375,8 +375,8 @@ export const of: <A>(head: A) => List<A> = (head) => cons(head, nil)
  * Finds the first index for which a predicate holds.
  *
  * @example
- * import * as O from 'fp-ts/lib/Option'
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as O from 'fp-ts/Option'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * const f = (a: number): boolean => a % 2 === 0
  * const findIndexEven = L.findIndex(f)
@@ -426,8 +426,8 @@ declare module 'fp-ts/lib/HKT' {
  * lengths, the result is non equality.
  *
  * @example
- * import { eqString } from 'fp-ts/lib/Eq'
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import { eqString } from 'fp-ts/Eq'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * const E = L.getEq(eqString)
  * assert.strictEqual(E.equals(L.cons('a', L.of('b')), L.cons('a', L.of('b'))), true)
@@ -506,7 +506,7 @@ export const list: Functor1<URI> & Foldable1<URI> & Traversable1<URI> = {
  * Tests whether a list is an empty list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.strictEqual(L.isNil(L.nil), true)
  * assert.strictEqual(L.isNil(L.of(6)), false)
@@ -519,7 +519,7 @@ export const isNil = <A>(a: List<A>): a is Nil => a.type === 'Nil'
  * Tests whether a list is a non empty list.
  *
  * @example
- * import * as L from 'fp-ts-contrib/lib/List'
+ * import * as L from 'fp-ts-contrib/List'
  *
  * assert.strictEqual(L.isCons(L.nil), false)
  * assert.strictEqual(L.isCons(L.of(1)), true)
diff --git a/src/RegExp.ts b/src/RegExp.ts
index cf4b542..3c7c597 100644
--- a/src/RegExp.ts
+++ b/src/RegExp.ts
@@ -14,9 +14,9 @@ import * as O from 'fp-ts/lib/Option'
  * Returns the list of subexpression matches, or `None` if the match fails.
  *
  * @example
- * import * as O from 'fp-ts/lib/Option'
- * import { match } from 'fp-ts-contrib/lib/RegExp'
- * import { pipe } from 'fp-ts/lib/pipeable'
+ * import * as O from 'fp-ts/Option'
+ * import { match } from 'fp-ts-contrib/RegExp'
+ * import { pipe } from 'fp-ts/function'
  *
  * const myMatch = match(/^(\d)(\w)$/)
  * assert.deepStrictEqual(pipe('2e', myMatch, O.map(Array.from)), O.some(['2e', '2', 'e']))
@@ -31,7 +31,7 @@ export const match: (r: RegExp) => (s: string) => O.Option<RegExpMatchArray> = (
  * otherwise `false`.
  *
  * @example
- * import { test } from 'fp-ts-contrib/lib/RegExp'
+ * import { test } from 'fp-ts-contrib/RegExp'
  *
  * const myTest = test(/^(\d)(\w)$/)
  * assert.strictEqual(myTest('6s'), true)
@@ -46,7 +46,7 @@ export const test: (r: RegExp) => Predicate<string> = (r) => (s) => r.test(s)
  * with the replacement string.
  *
  * @example
- * import { sub } from 'fp-ts-contrib/lib/RegExp'
+ * import { sub } from 'fp-ts-contrib/RegExp'
  *
  * const sanitiseSpaces = sub(/\s/g, '_')
  * assert.strictEqual(sanitiseSpaces('foo bar owl'), 'foo_bar_owl')
@@ -61,7 +61,7 @@ export const sub: (r: RegExp, replacement: string) => (s: string) => string = (r
  * should identify one delimiter.
  *
  * @example
- * import { split } from 'fp-ts-contrib/lib/RegExp'
+ * import { split } from 'fp-ts-contrib/RegExp'
  *
  * const splitByHash = split(/#/)
  * assert.deepStrictEqual(splitByHash('foo#bar#beer'), ['foo', 'bar', 'beer'])
diff --git a/src/Semialign/NonEmptyArray.ts b/src/Semialign/NonEmptyArray.ts
index 95e7f12..081b97b 100644
--- a/src/Semialign/NonEmptyArray.ts
+++ b/src/Semialign/NonEmptyArray.ts
@@ -19,9 +19,9 @@ export const semialignNonEmptyArray: Semialign1<URI> = {
    * Uses the `These` data type to handle arrays of different lengths.
    *
    * @example
-   * import { These } from 'fp-ts/lib/These'
-   * import { identity } from 'fp-ts/lib/function'
-   * import { alignNonEmptyArray } from 'fp-ts-contrib/lib/Semialign/NonEmptyArray'
+   * import { These } from 'fp-ts/These'
+   * import { identity } from 'fp-ts/function'
+   * import { alignNonEmptyArray } from 'fp-ts-contrib/Semialign/NonEmptyArray'
    *
    * const f = (x: These<number, string>) => x.fold(a => a.toString(), identity, (a, b) => a + b)
    *
@@ -38,9 +38,9 @@ export const semialignNonEmptyArray: Semialign1<URI> = {
    * Takes two arrays and returns an array of corresponding pairs combined using the `These` data type.
    *
    * @example
-   * import { These } from 'fp-ts/lib/These'
-   * import { identity } from 'fp-ts/lib/function'
-   * import { alignNonEmptyArray } from 'fp-ts-contrib/lib/Semialign/NonEmptyArray'
+   * import { These } from 'fp-ts/These'
+   * import { identity } from 'fp-ts/function'
+   * import { alignNonEmptyArray } from 'fp-ts-contrib/Semialign/NonEmptyArray'
    *
    * assert.deepStrictEqual(semialignNonEmptyArray.align(new NonEmptyArray(1, [2, 3]), new NonEmptyArray('a', ['b', 'c']), new NonEmptyArray(both(1, 'a'), [both(2, 'b'), both(3, 'c')]))
    * assert.deepStrictEqual(semialignNonEmptyArray.align(new NonEmptyArray(1, [2, 3]), new NonEmptyArray('a', ['b']), new NonEmptyArray(both(1, 'a'), [both(2, 'b'), this_(3)])
diff --git a/src/Task/withTimeout.ts b/src/Task/withTimeout.ts
index 364411b..c531b0e 100644
--- a/src/Task/withTimeout.ts
+++ b/src/Task/withTimeout.ts
@@ -7,8 +7,8 @@ import { getRaceMonoid, Task, delay, of } from 'fp-ts/lib/Task'
  * Returns the task result if it completes within a timeout, or a fallback value instead.
  *
  * @example
- * import { withTimeout } from 'fp-ts-contrib/lib/Task/withTimeout'
- * import { delay, of } from 'fp-ts/lib/Task'
+ * import { withTimeout } from 'fp-ts-contrib/Task/withTimeout'
+ * import { delay, of } from 'fp-ts/Task'
  *
  * const completeAfter2s = delay(2000)(of('result'))
  *
diff --git a/src/collectUntil.ts b/src/collectUntil.ts
index aed440e..28b98d1 100644
--- a/src/collectUntil.ts
+++ b/src/collectUntil.ts
@@ -13,12 +13,12 @@ import { pipe } from 'fp-ts/lib/pipeable'
  * value, such as a `Array` or `NonEmptyArray`.
  *
  * @example
- * import { array } from 'fp-ts/lib/Array'
- * import * as E from 'fp-ts/lib/Either'
- * import { flow } from 'fp-ts/lib/function'
- * import * as O from 'fp-ts/lib/Option'
- * import * as TE from 'fp-ts/lib/TaskEither'
- * import { collectUntil } from 'fp-ts-contrib/lib/collectUntil'
+ * import { array } from 'fp-ts/Array'
+ * import * as E from 'fp-ts/Either'
+ * import { flow } from 'fp-ts/function'
+ * import * as O from 'fp-ts/Option'
+ * import * as TE from 'fp-ts/TaskEither'
+ * import { collectUntil } from 'fp-ts-contrib/collectUntil'
  *
  * interface Page {
  *   rows: Array<string>
diff --git a/src/filterA.ts b/src/filterA.ts
index cc3a3c6..e2652a4 100644
--- a/src/filterA.ts
+++ b/src/filterA.ts
@@ -17,8 +17,8 @@ import * as O from 'fp-ts/lib/Option'
  * This generalizes the array-based `filter` function.
  *
  * @example
- * import { io, IO } from 'fp-ts/lib/IO'
- * import { filterA } from 'fp-ts-contrib/lib/filterA'
+ * import { io, IO } from 'fp-ts/IO'
+ * import { filterA } from 'fp-ts-contrib/filterA'
  *
  * const filterAIO = filterA(io)
  *
diff --git a/src/time.ts b/src/time.ts
index 38741de..81fabfb 100644
--- a/src/time.ts
+++ b/src/time.ts
@@ -10,9 +10,9 @@ import { MonadIO, MonadIO1, MonadIO2, MonadIO2C, MonadIO3 } from 'fp-ts/lib/Mona
  * returns the elapsed time along with the computed value
  *
  * @example
- * import { io } from 'fp-ts/lib/IO'
- * import { randomInt } from 'fp-ts/lib/Random'
- * import { time } from 'fp-ts-contrib/lib/time'
+ * import { io } from 'fp-ts/IO'
+ * import { randomInt } from 'fp-ts/Random'
+ * import { time } from 'fp-ts-contrib/time'
  *
  * const timeIO = time(io)
  *