Repository: remeda/remeda
Pull request #983 (2025-01-01 14:03:14)

chore(deps-dev): bump the patches group with 4 updates
Bumps the patches group with 4 updates: [@arethetypeswrong/cli](https://github.com/arethetypeswrong/arethetypeswrong.github.io/tree/HEAD/packages/cli), [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node), [@vitest/eslint-plugin](https://github.com/vitest-dev/eslint-plugin-vitest) and [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc).

Updates `@arethetypeswrong/cli` from 0.17.1 to 0.17.2
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/packages/cli/CHANGELOG.md"><code>@​arethetypeswrong/cli</code>'s changelog</a>.</em></p>
<blockquote>
<h2>0.17.2</h2>
<h3>Patch Changes</h3>
<ul>
<li>Updated dependencies [59940cd]
<ul>
<li><code>@​arethetypeswrong/core</code><a href="https://github.com/0"><code>@​0</code></a>.17.2</li>
</ul>
</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/arethetypeswrong/arethetypeswrong.github.io/commits/HEAD/packages/cli">compare view</a></li>
</ul>
</details>
<br />

Updates `@types/node` from 22.10.1 to 22.10.3
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node">compare view</a></li>
</ul>
</details>
<br />

Updates `@vitest/eslint-plugin` from 1.1.14 to 1.1.22
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/vitest-dev/eslint-plugin-vitest/releases"><code>@​vitest/eslint-plugin</code>'s releases</a>.</em></p>
<blockquote>
<h2>v1.1.22</h2>
<h3>Bug Fixes</h3>
<ul>
<li><code>valid-title</code> false positives when <code>test.extend</code> is used (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/584">#584</a>) (<a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/9c2670a">9c2670a</a>)</li>
</ul>
<h2>v1.1.21</h2>
<h3>Bug Fixes</h3>
<ul>
<li>fix types (<a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/1476da0">1476da0</a>)</li>
</ul>
<h3>Performance Improvements</h3>
<ul>
<li>only build regexp ones for detecting expectations (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/608">#608</a>) (<a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/448650c">448650c</a>)</li>
</ul>
<h2>What's Changed</h2>
<ul>
<li>perf: only build regexp once for detecting expectations by <a href="https://github.com/ghusse"><code>@​ghusse</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/608">vitest-dev/eslint-plugin-vitest#608</a></li>
<li>Refactor tsconfig for Stricter Type-Safe Settings by <a href="https://github.com/y-hsgw"><code>@​y-hsgw</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/605">vitest-dev/eslint-plugin-vitest#605</a></li>
<li>chore(deps-dev): bump unbuild from 2.0.0 to 3.0.1 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/609">vitest-dev/eslint-plugin-vitest#609</a></li>
<li>chore(deps-dev): bump <code>@​types/node</code> from 20.17.10 to 22.10.2 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/610">vitest-dev/eslint-plugin-vitest#610</a></li>
<li>chore(deps-dev): bump bumpp from 9.9.1 to 9.9.2 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/611">vitest-dev/eslint-plugin-vitest#611</a></li>
<li>chore(deps-dev): bump <code>@​typescript-eslint/parser</code> from 8.0.0 to 8.18.2 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/612">vitest-dev/eslint-plugin-vitest#612</a></li>
<li>chore(deps-dev): bump vitest from 1.6.0 to 2.1.8 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/613">vitest-dev/eslint-plugin-vitest#613</a></li>
<li>chore(deps-dev): bump eslint-doc-generator from 1.7.1 to 2.0.2 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/614">vitest-dev/eslint-plugin-vitest#614</a></li>
<li>fix false postive issues by <a href="https://github.com/veritem"><code>@​veritem</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/617">vitest-dev/eslint-plugin-vitest#617</a></li>
<li>make build work by <a href="https://github.com/veritem"><code>@​veritem</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/618">vitest-dev/eslint-plugin-vitest#618</a></li>
<li>chore: improve ci by <a href="https://github.com/veritem"><code>@​veritem</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/619">vitest-dev/eslint-plugin-vitest#619</a></li>
<li>Chore/ci by <a href="https://github.com/veritem"><code>@​veritem</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/620">vitest-dev/eslint-plugin-vitest#620</a></li>
<li>Feat/test extend by <a href="https://github.com/veritem"><code>@​veritem</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/621">vitest-dev/eslint-plugin-vitest#621</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/vitest-dev/eslint-plugin-vitest/compare/v1.1.20...v1.1.21">https://github.com/vitest-dev/eslint-plugin-vitest/compare/v1.1.20...v1.1.21</a></p>
<h2>v1.1.20</h2>
<h3>Bug Fixes</h3>
<ul>
<li>detect expectations in chains with underscores (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/607">#607</a>) (<a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/d31fdb7">d31fdb7</a>)</li>
</ul>
<h2>What's Changed</h2>
<ul>
<li>fix: detect expectations in chains with underscores by <a href="https://github.com/ghusse"><code>@​ghusse</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/607">vitest-dev/eslint-plugin-vitest#607</a></li>
<li>docs: fix no-standalone-expect.md options example by <a href="https://github.com/andykenward"><code>@​andykenward</code></a> in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/606">vitest-dev/eslint-plugin-vitest#606</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/ghusse"><code>@​ghusse</code></a> made their first contribution in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/607">vitest-dev/eslint-plugin-vitest#607</a></li>
<li><a href="https://github.com/andykenward"><code>@​andykenward</code></a> made their first contribution in <a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/pull/606">vitest-dev/eslint-plugin-vitest#606</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/vitest-dev/eslint-plugin-vitest/compare/v1.1.19...v1.1.20">https://github.com/vitest-dev/eslint-plugin-vitest/compare/v1.1.19...v1.1.20</a></p>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/003846c7ba0bb10dc0a9b72a5877479feae8831d"><code>003846c</code></a> chore: release v1.1.22</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/7f69731c9edd9297e477aaed82fdfdea44cc28d5"><code>7f69731</code></a> lint</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/5ea6ec0ee6b54b7c5d11e638d7b818285d853b64"><code>5ea6ec0</code></a> chore(deps-dev): bump unbuild from 3.0.1 to 3.2.0 (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/624">#624</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/9c2670a13358d925499570422e44f0a43b6623ab"><code>9c2670a</code></a> fix: <code>valid-title</code> false positives when <code>test.extend</code> is used (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/584">#584</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/d832860ac33fd1746d34440955da9a39b1a174a6"><code>d832860</code></a> chore(deps-dev): bump <code>@​typescript-eslint/rule-tester</code> (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/625">#625</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/5dc45483209b748b2c0cfc1ae9dbbe7cfeb7cae0"><code>5dc4548</code></a> docs: add documentation for padding-around-related rules (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/623">#623</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/f99d6e222cc6a2efc55997cb590b0e4edb5d970a"><code>f99d6e2</code></a> docs: Add documentation for padding-around-after-all-blocks rule (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/622">#622</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/3023345d88d4479753c638ee2b237fec78231c98"><code>3023345</code></a> chore: release v1.1.21</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/0f8630652a2c91ac2063793d85eac5e939fe53ca"><code>0f86306</code></a> Feat/test extend (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/621">#621</a>)</li>
<li><a href="https://github.com/vitest-dev/eslint-plugin-vitest/commit/9bb8502e53c1a47018cc2069fd6c6b316bffe27b"><code>9bb8502</code></a> Chore/ci (<a href="https://redirect.github.com/vitest-dev/eslint-plugin-vitest/issues/620">#620</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/vitest-dev/eslint-plugin-vitest/compare/v1.1.14...v1.1.22">compare view</a></li>
</ul>
</details>
<br />

Updates `eslint-plugin-jsdoc` from 50.6.0 to 50.6.1
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/gajus/eslint-plugin-jsdoc/releases">eslint-plugin-jsdoc's releases</a>.</em></p>
<blockquote>
<h2>v50.6.1</h2>
<h2><a href="https://github.com/gajus/eslint-plugin-jsdoc/compare/v50.6.0...v50.6.1">50.6.1</a> (2024-12-11)</h2>
<h3>Bug Fixes</h3>
<ul>
<li><strong>types:</strong> update configs types (<a href="https://redirect.github.com/gajus/eslint-plugin-jsdoc/issues/1344">#1344</a>) (<a href="https://github.com/gajus/eslint-plugin-jsdoc/commit/d2c60403bb55a14eadbf49fc9937caad14a29cde">d2c6040</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/gajus/eslint-plugin-jsdoc/commit/d2c60403bb55a14eadbf49fc9937caad14a29cde"><code>d2c6040</code></a> fix(types): update configs types (<a href="https://redirect.github.com/gajus/eslint-plugin-jsdoc/issues/1344">#1344</a>)</li>
<li>See full diff in <a href="https://github.com/gajus/eslint-plugin-jsdoc/compare/v50.6.0...v50.6.1">compare view</a></li>
</ul>
</details>
<br />


Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@dependabot ignore <dependency name> major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself)
- `@dependabot ignore <dependency name> minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself)
- `@dependabot ignore <dependency name>` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself)
- `@dependabot unignore <dependency name>` will remove all of the ignore conditions of the specified dependency
- `@dependabot unignore <dependency name> <ignore condition>` will remove the ignore condition of the specified dependency and ignore conditions


</details>

codesandbox-ci[bot]: This pull request is automatically built and testable in [CodeSandbox](https://codesandbox.io).

  To see build info of the built libraries, click [here](https://ci.codesandbox.io/status/remeda/remeda/pr/983/builds/574797) or the icon next to each commit SHA.

Latest deployment of this branch, based on commit 4ba06f00867a294bd45729421defa87c145a9c91:

|Sandbox| Source |
|--|--|
|[remeda-example-vanilla](https://codesandbox.io/s/remeda-example-vanilla-55ynzr)| Configuration |


Patch:
diff --git a/eslint.config.js b/eslint.config.js
index b8f1aa4..b67ed09 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -427,10 +427,15 @@ export default tseslint.config(
     plugins: {
       vitest,
     },
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- vitest typing issues are causing this. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
     rules: {
+      // @ts-expect-error [ts18048] -- Looks like something broke in the types for the vitest plugin. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       ...vitest.configs.all.rules,
       // The `all` config doesn't actually contain all the rules, its missing
       // all the recommended ones...
+      // @ts-expect-error [ts18048] -- Looks like something broke in the types for the vitest plugin. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       ...vitest.configs.recommended.rules,
 
       "vitest/prefer-lowercase-title": [
@@ -486,7 +491,10 @@ export default tseslint.config(
       },
     },
     languageOptions: {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- vitest typing issues are causing this. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
       globals: {
+        // @ts-expect-error [ts18048] -- Looks like something broke in the types for the vitest plugin. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- vitest typing issues are causing this. TODO: If this isn't fixed by the next update we should check if we are doing something wrong...
         ...vitest.environments.env.globals,
       },
     },
diff --git a/package-lock.json b/package-lock.json
index 94e1597..08049b8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -55,13 +55,12 @@
       "dev": true
     },
     "node_modules/@arethetypeswrong/cli": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/@arethetypeswrong/cli/-/cli-0.17.1.tgz",
-      "integrity": "sha512-WNKTcC7lqWmbRWWku3Xz0hl7zj9szoGzx7gcGaZPxszKcMPiRnKsiLbxMpf1FzA6myIjE1yalqxNCJ0UkCWTXQ==",
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/cli/-/cli-0.17.2.tgz",
+      "integrity": "sha512-/u2VcQJ8PKc4hcao/vXnHrYLEI/sQqKarbHi+NEIfvdymaW5o62XOCXy2yvalQa/vR+AAD/QNEgAUzHo5f7hrw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
-        "@arethetypeswrong/core": "0.17.1",
+        "@arethetypeswrong/core": "0.17.2",
         "chalk": "^4.1.2",
         "cli-table3": "^0.6.3",
         "commander": "^10.0.1",
@@ -77,11 +76,10 @@
       }
     },
     "node_modules/@arethetypeswrong/core": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/@arethetypeswrong/core/-/core-0.17.1.tgz",
-      "integrity": "sha512-NgEuyO/D79q2K6lVoSLmRX2YzKNlh2LHU+no3AVkpY4gA20zEhp129KUV1W6jMnbmpRm3xAxF+v3myZ/eFixnA==",
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/core/-/core-0.17.2.tgz",
+      "integrity": "sha512-JYeLgS4rQ2l3gHCabaka3atsEyskfpx+WqUbo+6l8LApILJgr0/XDb7KNC9Ovevp4iPVF2Q73oshpgOKJ3uDRQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@andrewbranch/untar.js": "^1.0.3",
         "cjs-module-lexer": "^1.2.3",
@@ -100,7 +98,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.1-rc.tgz",
       "integrity": "sha512-E3b2+1zEFu84jB0YQi9BORDjz9+jGbwwy1Zi3G0LUNw7a7cePUrHMRNy8aPh53nXpkFGVHSxIZo5vKTfYaFiBQ==",
       "dev": true,
-      "license": "Apache-2.0",
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -1874,11 +1871,10 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "22.10.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.1.tgz",
-      "integrity": "sha512-qKgsUwfHZV2WCWLAnVP1JqnpE6Im6h3Y0+fYgMTasNQ7V++CBX5OT1as0g0f+OyubbFqhf6XVNIsmN4IIhEgGQ==",
+      "version": "22.10.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.3.tgz",
+      "integrity": "sha512-DifAyw4BkrufCILvD3ucnuN8eydUfc/C1GlyrnI+LK6543w5/L3VeVgf05o3B4fqSXP1dKYLOZsKfutpxPzZrw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "undici-types": "~6.20.0"
       }
@@ -2168,11 +2164,10 @@
       }
     },
     "node_modules/@vitest/eslint-plugin": {
-      "version": "1.1.14",
-      "resolved": "https://registry.npmjs.org/@vitest/eslint-plugin/-/eslint-plugin-1.1.14.tgz",
-      "integrity": "sha512-ej0cT5rUt7uvwxuu7Qxkm7fI+eaOq8vD34qGpuRoXCdvOybOlE5GDqtgvVCYbxLANkcRJfm5VDU1TnJmQRHi9g==",
+      "version": "1.1.22",
+      "resolved": "https://registry.npmjs.org/@vitest/eslint-plugin/-/eslint-plugin-1.1.22.tgz",
+      "integrity": "sha512-ztvy2+thiCMmKnywvKGhH3AcKgEMGd4BsFK2QC9/EXqlyjXDp7Pg96PonbLx8bDvNCAjq4hfCw5YuZSAz1EDIg==",
       "dev": true,
-      "license": "MIT",
       "peerDependencies": {
         "@typescript-eslint/utils": ">= 8.0",
         "eslint": ">= 8.57.0",
@@ -2704,8 +2699,7 @@
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.1.tgz",
       "integrity": "sha512-cuSVIHi9/9E/+821Qjdvngor+xpnlwnuwIyZOaLmHBVdXL+gP+I6QQB9VkO7RI77YIcTV+S1W9AreJ5eN63JBA==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/clean-regexp": {
       "version": "1.0.0",
@@ -3519,11 +3513,10 @@
       }
     },
     "node_modules/eslint-plugin-jsdoc": {
-      "version": "50.6.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.6.0.tgz",
-      "integrity": "sha512-tCNp4fR79Le3dYTPB0dKEv7yFyvGkUCa+Z3yuTrrNGGOxBlXo9Pn0PEgroOZikUQOGjxoGMVKNjrOHcYEdfszg==",
+      "version": "50.6.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.6.1.tgz",
+      "integrity": "sha512-UWyaYi6iURdSfdVVqvfOs2vdCVz0J40O/z/HTsv2sFjdjmdlUI/qlKLOTmwbPQ2tAfQnE5F9vqx+B+poF71DBQ==",
       "dev": true,
-      "license": "BSD-3-Clause",
       "dependencies": {
         "@es-joy/jsdoccomment": "~0.49.0",
         "are-docs-informative": "^0.0.2",
@@ -3833,8 +3826,7 @@
       "version": "0.8.2",
       "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz",
       "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/figures": {
       "version": "6.1.0",
@@ -10756,7 +10748,6 @@
       "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.1.tgz",
       "integrity": "sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==",
       "dev": true,
-      "license": "ISC",
       "engines": {
         "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
       }


Test patch:
diff --git a/src/addProp.test-d.ts b/src/addProp.test-d.ts
index 4e6775e..030a13a 100644
--- a/src/addProp.test-d.ts
+++ b/src/addProp.test-d.ts
@@ -2,21 +2,25 @@ import { addProp } from "./addProp";
 
 it("allows redefining prop types", () => {
   const result = addProp({} as { a: string }, "a", 1);
+
   expectTypeOf(result).toEqualTypeOf<{ a: number }>();
 });
 
 it("makes optional fields required", () => {
   const result = addProp({} as { a?: string }, "a", "hello");
+
   expectTypeOf(result).toEqualTypeOf<{ a: string }>();
 });
 
 it("allows setting an unknown prop", () => {
   const result = addProp({ a: "foo" }, "b", "bar");
+
   expectTypeOf(result).toEqualTypeOf<{ a: string; b: string }>();
 });
 
 it("sets literal unions as optional", () => {
   const result = addProp({} as { a: string }, "b" as "b" | "c", 123);
+
   expectTypeOf(result).toEqualTypeOf<{ a: string; b?: number; c?: number }>();
 });
 
@@ -26,10 +30,12 @@ it("keeps the prop optional when the key isn't literal", () => {
     "a" as "a" | "b",
     "foo" as const,
   );
+
   expectTypeOf(result).toEqualTypeOf<{ a?: string; b?: number | "foo" }>();
 });
 
 it("works on simple objects", () => {
   const result = addProp({} as Record<string, string>, "a", "foo" as const);
+
   expectTypeOf(result).toEqualTypeOf<{ [x: string]: string; a: "foo" }>();
 });
diff --git a/src/capitalize.test-d.ts b/src/capitalize.test-d.ts
index a98b07f..9f4a9a9 100644
--- a/src/capitalize.test-d.ts
+++ b/src/capitalize.test-d.ts
@@ -4,31 +4,37 @@ import { capitalize } from "./capitalize";
 describe("data-first", () => {
   test("on lower case", () => {
     const result = capitalize("hello world");
+
     expectTypeOf(result).toEqualTypeOf<"Hello world">();
   });
 
   test("on upper case", () => {
     const result = capitalize("HELLO WORLD");
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = capitalize("heLlO WoRlD");
+
     expectTypeOf(result).toEqualTypeOf<"HeLlO WoRlD">();
   });
 
   test("on empty string", () => {
     const result = capitalize("");
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = capitalize("hello world" as string);
+
     expectTypeOf(result).toEqualTypeOf<Capitalize<string>>();
   });
 
   test("on template literal type", () => {
     const result = capitalize("prefix_123" as `prefix_${number}`);
+
     expectTypeOf(result).toEqualTypeOf<`Prefix_${number}`>();
   });
 });
@@ -36,31 +42,37 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("on lower case", () => {
     const result = pipe("hello world" as const, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<"Hello world">();
   });
 
   test("on upper case", () => {
     const result = pipe("HELLO WORLD" as const, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = pipe("heLlO WoRlD" as const, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<"HeLlO WoRlD">();
   });
 
   test("on empty string", () => {
     const result = pipe("" as const, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = pipe("hello world" as string, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<Capitalize<string>>();
   });
 
   test("on template literal type", () => {
     const result = pipe("prefix_123" as `prefix_${number}`, capitalize());
+
     expectTypeOf(result).toEqualTypeOf<`Prefix_${number}`>();
   });
 });
diff --git a/src/chunk.test-d.ts b/src/chunk.test-d.ts
index b9ba74e..21d91fd 100644
--- a/src/chunk.test-d.ts
+++ b/src/chunk.test-d.ts
@@ -4,11 +4,13 @@ import type { NonEmptyArray } from "./internal/types/NonEmptyArray";
 describe("edge-cases", () => {
   test("0 chunk size", () => {
     const result = chunk([1, 2, 3], 0);
+
     expectTypeOf(result).toEqualTypeOf<never>();
   });
 
   test("negative chunk size", () => {
     const result = chunk([1, 2, 3], -10);
+
     expectTypeOf(result).toEqualTypeOf<never>();
   });
 });
@@ -17,11 +19,13 @@ describe("regular (non-literal) size", () => {
   describe("mutable", () => {
     test("empty tuple", () => {
       const result = chunk([] as [], 2 as number);
+
       expectTypeOf(result).toEqualTypeOf<[]>();
     });
 
     test("array", () => {
       const result = chunk([] as Array<number>, 2 as number);
+
       expectTypeOf(result).toEqualTypeOf<Array<NonEmptyArray<number>>>();
     });
 
@@ -30,6 +34,7 @@ describe("regular (non-literal) size", () => {
         [123, 456, 789] as [number, number, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -40,6 +45,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as [number, ...Array<number>],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -50,6 +56,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as [number, ...Array<number>, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -60,6 +67,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as [...Array<number>, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -69,11 +77,13 @@ describe("regular (non-literal) size", () => {
   describe("readonly", () => {
     test("empty tuple", () => {
       const result = chunk([] as const, 2 as number);
+
       expectTypeOf(result).toEqualTypeOf<[]>();
     });
 
     test("array", () => {
       const result = chunk([] as ReadonlyArray<number>, 2 as number);
+
       expectTypeOf(result).toEqualTypeOf<Array<NonEmptyArray<number>>>();
     });
 
@@ -82,6 +92,7 @@ describe("regular (non-literal) size", () => {
         [123, 456, 789] as readonly [number, number, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -92,6 +103,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as readonly [number, ...Array<number>],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -102,6 +114,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as readonly [number, ...Array<number>, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -112,6 +125,7 @@ describe("regular (non-literal) size", () => {
         [123, 456] as readonly [...Array<number>, number],
         2 as number,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         NonEmptyArray<NonEmptyArray<number>>
       >();
@@ -123,11 +137,13 @@ describe("literal size", () => {
   describe("mutable", () => {
     test("empty tuple", () => {
       const result = chunk([] as [], 2);
+
       expectTypeOf(result).toEqualTypeOf<[]>();
     });
 
     test("array", () => {
       const result = chunk([] as Array<number>, 2);
+
       expectTypeOf(result).toEqualTypeOf<
         [...Array<[number, number]>, [number, number] | [number]] | []
       >();
@@ -135,6 +151,7 @@ describe("literal size", () => {
 
     test("tuple", () => {
       const result = chunk([123, 456, 789] as [number, number, number], 2);
+
       expectTypeOf(result).toEqualTypeOf<[[number, number], [number]]>();
     });
 
@@ -142,6 +159,7 @@ describe("literal size", () => {
       describe("prefix arrays", () => {
         test("prefix is shorter than chunk size", () => {
           const result = chunk([1] as [number, ...Array<boolean>], 2);
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, boolean],
@@ -159,6 +177,7 @@ describe("literal size", () => {
             [1, 2] as [number, number, ...Array<boolean>],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, number],
@@ -174,6 +193,7 @@ describe("literal size", () => {
             [1, 2, 3] as [number, number, number, ...Array<boolean>],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, number],
@@ -191,6 +211,7 @@ describe("literal size", () => {
       describe("suffix arrays", () => {
         test("suffix is shorter than chunk size", () => {
           const result = chunk([1] as [...Array<boolean>, number], 2);
+
           expectTypeOf(result).toEqualTypeOf<
             | [...Array<[boolean, boolean]>, [boolean, number]]
             | [...Array<[boolean, boolean]>, [number]]
@@ -202,6 +223,7 @@ describe("literal size", () => {
             [1, 2] as [...Array<boolean>, number, number],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [...Array<[boolean, boolean]>, [boolean, number], [number]]
             | [...Array<[boolean, boolean]>, [number, number]]
@@ -213,6 +235,7 @@ describe("literal size", () => {
             [1, 2, 3] as [...Array<boolean>, number, number, number],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 ...Array<[boolean, boolean]>,
@@ -229,6 +252,7 @@ describe("literal size", () => {
           [123, "abc"] as [number, ...Array<boolean>, string],
           2,
         );
+
         expectTypeOf(result).toEqualTypeOf<
           | [[number, boolean], ...Array<[boolean, boolean]>, [boolean, string]]
           | [[number, boolean], ...Array<[boolean, boolean]>, [string]]
@@ -243,11 +267,13 @@ describe("literal size", () => {
   describe("readonly", () => {
     test("empty tuple", () => {
       const result = chunk([] as const, 2);
+
       expectTypeOf(result).toEqualTypeOf<[]>();
     });
 
     test("array", () => {
       const result = chunk([] as ReadonlyArray<number>, 2);
+
       expectTypeOf(result).toEqualTypeOf<
         [...Array<[number, number]>, [number, number] | [number]] | []
       >();
@@ -258,11 +284,13 @@ describe("literal size", () => {
         [123, 456, 789] as readonly [number, number, number],
         2,
       );
+
       expectTypeOf(result).toEqualTypeOf<[[number, number], [number]]>();
     });
 
     test("const", () => {
       const result = chunk([123, 456, 789] as const, 2);
+
       expectTypeOf(result).toEqualTypeOf<[[123, 456], [789]]>();
     });
 
@@ -270,6 +298,7 @@ describe("literal size", () => {
       describe("prefix arrays", () => {
         test("prefix is shorter than chunk size", () => {
           const result = chunk([1] as readonly [number, ...Array<boolean>], 2);
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, boolean],
@@ -287,6 +316,7 @@ describe("literal size", () => {
             [1, 2] as readonly [number, number, ...Array<boolean>],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, number],
@@ -302,6 +332,7 @@ describe("literal size", () => {
             [1, 2, 3] as readonly [number, number, number, ...Array<boolean>],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 [number, number],
@@ -319,6 +350,7 @@ describe("literal size", () => {
       describe("suffix arrays", () => {
         test("suffix is shorter than chunk size", () => {
           const result = chunk([1] as readonly [...Array<boolean>, number], 2);
+
           expectTypeOf(result).toEqualTypeOf<
             | [...Array<[boolean, boolean]>, [boolean, number]]
             | [...Array<[boolean, boolean]>, [number]]
@@ -330,6 +362,7 @@ describe("literal size", () => {
             [1, 2] as readonly [...Array<boolean>, number, number],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [...Array<[boolean, boolean]>, [boolean, number], [number]]
             | [...Array<[boolean, boolean]>, [number, number]]
@@ -341,6 +374,7 @@ describe("literal size", () => {
             [1, 2, 3] as readonly [...Array<boolean>, number, number, number],
             2,
           );
+
           expectTypeOf(result).toEqualTypeOf<
             | [
                 ...Array<[boolean, boolean]>,
@@ -357,6 +391,7 @@ describe("literal size", () => {
           [123, "abc"] as readonly [number, ...Array<boolean>, string],
           2,
         );
+
         expectTypeOf(result).toEqualTypeOf<
           | [[number, boolean], ...Array<[boolean, boolean]>, [boolean, string]]
           | [[number, boolean], ...Array<[boolean, boolean]>, [string]]
@@ -374,6 +409,7 @@ describe("literal size", () => {
         ["abc", true] as [string, ...Array<number>, boolean],
         200,
       );
+
       expectTypeOf(firstItem).toEqualTypeOf<string>();
       expectTypeOf(secondItem).toEqualTypeOf<boolean | number>();
       expectTypeOf(otherItems[197]).toEqualTypeOf<
@@ -389,6 +425,7 @@ describe("literal size", () => {
       ["abc", true] as [string, ...Array<number>, boolean],
       1000,
     );
+
     expectTypeOf(result).toEqualTypeOf<
       // These are simple non-empty arrays
       [
diff --git a/src/conditional.test-d.ts b/src/conditional.test-d.ts
index 3c8336f..1b243d4 100644
--- a/src/conditional.test-d.ts
+++ b/src/conditional.test-d.ts
@@ -78,6 +78,7 @@ describe("data-first", () => {
       [isString, () => "hello" as const],
       conditional.defaultCase(),
     );
+
     expectTypeOf(result).toEqualTypeOf<"hello" | undefined>();
   });
 
@@ -87,6 +88,7 @@ describe("data-first", () => {
       [isString, () => "hello" as const],
       conditional.defaultCase(() => 123 as const),
     );
+
     expectTypeOf(result).toEqualTypeOf<"hello" | 123>();
   });
 });
diff --git a/src/countBy.test-d.ts b/src/countBy.test-d.ts
index 3fb070d..467262f 100644
--- a/src/countBy.test-d.ts
+++ b/src/countBy.test-d.ts
@@ -26,6 +26,7 @@ test("callback function type", () => {
   const data = [1, 2, 3];
   countBy(data, (x) => {
     expectTypeOf(x).toEqualTypeOf<number>();
+
     return x;
   });
 });
diff --git a/src/debounce.test-d.ts b/src/debounce.test-d.ts
index 43652d5..f5bc407 100644
--- a/src/debounce.test-d.ts
+++ b/src/debounce.test-d.ts
@@ -9,6 +9,7 @@ it("returns undefined on 'trailing' timing", () => {
     timing: "trailing",
   });
   const result = debouncer.call();
+
   expectTypeOf(result).toEqualTypeOf<string | undefined>();
 });
 
@@ -18,6 +19,7 @@ it("doesn't return undefined on 'leading' timing", () => {
     timing: "leading",
   });
   const result = debouncer.call();
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
@@ -27,6 +29,7 @@ it("doesn't return undefined on 'both' timing", () => {
     timing: "both",
   });
   const result = debouncer.call();
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
diff --git a/src/drop.test-d.ts b/src/drop.test-d.ts
index d2403d5..a491ff8 100644
--- a/src/drop.test-d.ts
+++ b/src/drop.test-d.ts
@@ -4,26 +4,31 @@ import { pipe } from "./pipe";
 describe("data-first", () => {
   test("empty array", () => {
     const result = drop([] as [], 2);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("regular array", () => {
     const result = drop([] as Array<number>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = drop([] as Array<number | string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefixed array", () => {
     const result = drop([1] as [number, ...Array<boolean>], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean>>();
   });
 
   test("suffixed array", () => {
     const result = drop([1] as [...Array<boolean>, number], 2);
+
     expectTypeOf(result).toEqualTypeOf<
       [...Array<boolean>, number] | [] | [number]
     >();
@@ -35,6 +40,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         0,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         [number, number, ...Array<boolean>, string, string]
       >();
@@ -45,6 +51,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         1,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         [number, ...Array<boolean>, string, string]
       >();
@@ -55,6 +62,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         2,
       );
+
       expectTypeOf(result).toEqualTypeOf<[...Array<boolean>, string, string]>();
     });
 
@@ -63,6 +71,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         3,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         [...Array<boolean>, string, string] | [string, string] | [string]
       >();
@@ -73,6 +82,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         4,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         [...Array<boolean>, string, string] | [] | [string, string] | [string]
       >();
@@ -83,6 +93,7 @@ describe("data-first", () => {
         [1, 2, "a", "b"] as [number, number, ...Array<boolean>, string, string],
         5,
       );
+
       expectTypeOf(result).toEqualTypeOf<
         [...Array<boolean>, string, string] | [] | [string, string] | [string]
       >();
@@ -91,21 +102,25 @@ describe("data-first", () => {
 
   test("tuple", () => {
     const result = drop([1, "a", true] as const, 2);
+
     expectTypeOf(result).toEqualTypeOf<[true]>();
   });
 
   test("union of arrays", () => {
     const result = drop([] as Array<boolean> | Array<string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
   test("negative count", () => {
     const result = drop([] as Array<number>, -1);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("generalized typed count", () => {
     const result = drop(["a", 1, true] as const, 1 as number);
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 });
@@ -113,26 +128,31 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], drop(2));
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, drop(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = pipe([] as Array<number | string>, drop(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = pipe([1] as [number, ...Array<boolean>], drop(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean>>();
   });
 
   test("suffix array", () => {
     const result = pipe([1] as [...Array<boolean>, number], drop(2));
+
     expectTypeOf(result).toEqualTypeOf<
       [...Array<boolean>, number] | [] | [number]
     >();
@@ -143,6 +163,7 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       drop(2),
     );
+
     expectTypeOf(result).toEqualTypeOf<
       [...Array<boolean>, string] | [] | [string]
     >();
@@ -150,21 +171,25 @@ describe("data-last", () => {
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, drop(2));
+
     expectTypeOf(result).toEqualTypeOf<[true]>();
   });
 
   test("union of arrays", () => {
     const result = pipe([] as Array<boolean> | Array<string>, drop(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
   test("negative count", () => {
     const result = pipe([] as Array<number>, drop(-1));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("generalized typed count", () => {
     const result = pipe([] as Array<number>, drop(1 as number));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 });
diff --git a/src/dropLast.test-d.ts b/src/dropLast.test-d.ts
index cfddf55..c3d4ebe 100644
--- a/src/dropLast.test-d.ts
+++ b/src/dropLast.test-d.ts
@@ -4,41 +4,49 @@ import { dropLast } from "./dropLast";
 describe("data-first", () => {
   test("empty array", () => {
     const result = dropLast([] as [], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = dropLast([] as Array<number>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = dropLast([] as Array<number | string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = dropLast([1] as [number, ...Array<boolean>], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = dropLast([1] as [...Array<boolean>, number], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("array with suffix and prefix", () => {
     const result = dropLast([1, "a"] as [number, ...Array<boolean>, string], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = dropLast([1, "a", true] as const, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = dropLast([] as Array<boolean> | Array<string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -46,26 +54,31 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = pipe([] as Array<number | string>, dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = pipe([1] as [number, ...Array<boolean>], dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = pipe([1] as [...Array<boolean>, number], dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -74,16 +87,19 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       dropLast(2),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = pipe([] as Array<boolean> | Array<string>, dropLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
diff --git a/src/dropLastWhile.test-d.ts b/src/dropLastWhile.test-d.ts
index 42c0ab5..99b7c3d 100644
--- a/src/dropLastWhile.test-d.ts
+++ b/src/dropLastWhile.test-d.ts
@@ -5,16 +5,19 @@ import { pipe } from "./pipe";
 describe("data-first", () => {
   test("empty array", () => {
     const result = dropLastWhile([] as [], constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = dropLastWhile([] as Array<number>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = dropLastWhile([] as Array<number | string>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -23,6 +26,7 @@ describe("data-first", () => {
       [1] as [number, ...Array<boolean>],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -31,6 +35,7 @@ describe("data-first", () => {
       [1] as [...Array<boolean>, number],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -39,11 +44,13 @@ describe("data-first", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = dropLastWhile([1, "a", true] as const, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -52,6 +59,7 @@ describe("data-first", () => {
       [] as Array<boolean> | Array<string>,
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -59,11 +67,13 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], dropLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, dropLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -72,6 +82,7 @@ describe("data-last", () => {
       [] as Array<number | string>,
       dropLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -80,6 +91,7 @@ describe("data-last", () => {
       [1] as [number, ...Array<boolean>],
       dropLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -88,6 +100,7 @@ describe("data-last", () => {
       [1] as [...Array<boolean>, number],
       dropLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -96,11 +109,13 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       dropLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, dropLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -109,6 +124,7 @@ describe("data-last", () => {
       [] as Array<boolean> | Array<string>,
       dropLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
@@ -120,6 +136,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<never>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[]>();
+
           return true;
         }),
       );
@@ -132,6 +149,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number>>();
+
           return true;
         }),
       );
@@ -144,6 +162,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number | string>>();
+
           return true;
         }),
       );
@@ -156,6 +175,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[number, ...Array<boolean>]>();
+
           return true;
         }),
       );
@@ -168,6 +188,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[...Array<boolean>, number]>();
+
           return true;
         }),
       );
@@ -182,6 +203,7 @@ describe("data-last", () => {
           expectTypeOf(array).toEqualTypeOf<
             [number, ...Array<boolean>, string]
           >();
+
           return true;
         }),
       );
@@ -194,6 +216,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<"a" | 1 | true>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<readonly [1, "a", true]>();
+
           return true;
         }),
       );
@@ -206,6 +229,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<boolean> | Array<string>>();
+
           return true;
         }),
       );
diff --git a/src/dropWhile.test-d.ts b/src/dropWhile.test-d.ts
index 82cb8f9..ba8a9d1 100644
--- a/src/dropWhile.test-d.ts
+++ b/src/dropWhile.test-d.ts
@@ -5,16 +5,19 @@ import { constant } from "./constant";
 describe("data-first", () => {
   test("empty array", () => {
     const result = dropWhile([] as [], constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = dropWhile([] as Array<number>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = dropWhile([] as Array<number | string>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -23,6 +26,7 @@ describe("data-first", () => {
       [1] as [number, ...Array<boolean>],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -31,6 +35,7 @@ describe("data-first", () => {
       [1] as [...Array<boolean>, number],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -39,11 +44,13 @@ describe("data-first", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = dropWhile([1, "a", true] as const, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -52,6 +59,7 @@ describe("data-first", () => {
       [] as Array<boolean> | Array<string>,
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -59,11 +67,13 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], dropWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, dropWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -72,6 +82,7 @@ describe("data-last", () => {
       [] as Array<number | string>,
       dropWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -80,6 +91,7 @@ describe("data-last", () => {
       [1] as [number, ...Array<boolean>],
       dropWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -88,6 +100,7 @@ describe("data-last", () => {
       [1] as [...Array<boolean>, number],
       dropWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -96,11 +109,13 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       dropWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, dropWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -109,6 +124,7 @@ describe("data-last", () => {
       [] as Array<boolean> | Array<string>,
       dropWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
@@ -120,6 +136,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<never>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[]>();
+
           return true;
         }),
       );
@@ -132,6 +149,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number>>();
+
           return true;
         }),
       );
@@ -144,6 +162,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number | string>>();
+
           return true;
         }),
       );
@@ -156,6 +175,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[number, ...Array<boolean>]>();
+
           return true;
         }),
       );
@@ -168,6 +188,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[...Array<boolean>, number]>();
+
           return true;
         }),
       );
@@ -182,6 +203,7 @@ describe("data-last", () => {
           expectTypeOf(array).toEqualTypeOf<
             [number, ...Array<boolean>, string]
           >();
+
           return true;
         }),
       );
@@ -194,6 +216,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<"a" | 1 | true>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<readonly [1, "a", true]>();
+
           return true;
         }),
       );
@@ -206,6 +229,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<boolean> | Array<string>>();
+
           return true;
         }),
       );
diff --git a/src/endsWith.test-d.ts b/src/endsWith.test-d.ts
index 2f1f206..8468417 100644
--- a/src/endsWith.test-d.ts
+++ b/src/endsWith.test-d.ts
@@ -85,30 +85,35 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("doesn't narrow on 'string' prefix", () => {
     const [yes, no] = partition([] as Array<string>, endsWith("bar" as string));
+
     expectTypeOf(yes).toEqualTypeOf<Array<string>>();
     expectTypeOf(no).toEqualTypeOf<Array<string>>();
   });
 
   test("const data that matches", () => {
     const [yes, no] = partition([] as Array<"foobar">, endsWith("bar"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<"foobar">>();
     expectTypeOf(no).toEqualTypeOf<Array<never>>();
   });
 
   test("const data that doesn't match", () => {
     const [yes, no] = partition([] as Array<"helloworld">, endsWith("bar"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<never>>();
     expectTypeOf(no).toEqualTypeOf<Array<"helloworld">>();
   });
 
   test("primitive string data", () => {
     const [yes, no] = partition([] as Array<string>, endsWith("bar"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<`${string}bar`>>();
     expectTypeOf(no).toEqualTypeOf<Array<string>>();
   });
 
   test("template literal data that matches", () => {
     const [yes, no] = partition([] as Array<`${number}_bar`>, endsWith("bar"));
+
     expectTypeOf(yes).branded.toEqualTypeOf<Array<`${number}_bar`>>();
     expectTypeOf(no).toEqualTypeOf<Array<never>>();
   });
@@ -118,6 +123,7 @@ describe("data-last", () => {
       [] as Array<`${number}_bar`>,
       endsWith("world"),
     );
+
     expectTypeOf(yes).toEqualTypeOf<
       // These should be equivalent to `never` but TypeScript doesn't infer
       // that...
@@ -128,6 +134,7 @@ describe("data-last", () => {
 
   test("literal union", () => {
     const [yes, no] = partition([] as Array<"cat" | "dog">, endsWith("t"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<"cat">>();
     expectTypeOf(no).toEqualTypeOf<Array<"dog">>();
   });
@@ -137,6 +144,7 @@ describe("data-last", () => {
       [] as Array<`${boolean}_dog` | `${number}_cat`>,
       endsWith("t"),
     );
+
     expectTypeOf(yes).branded.toEqualTypeOf<Array<`${number}_cat`>>();
     expectTypeOf(no).toEqualTypeOf<Array<`${boolean}_dog`>>();
   });
diff --git a/src/entries.test-d.ts b/src/entries.test-d.ts
index 14ecc90..5626af2 100644
--- a/src/entries.test-d.ts
+++ b/src/entries.test-d.ts
@@ -2,6 +2,7 @@ import { entries } from "./entries";
 
 test("with known properties", () => {
   const actual = entries({ a: 1, b: 2, c: 3 });
+
   expectTypeOf(actual).toEqualTypeOf<
     Array<["a", number] | ["b", number] | ["c", number]>
   >();
@@ -9,6 +10,7 @@ test("with known properties", () => {
 
 test("with different value types", () => {
   const actual = entries({ a: 1, b: "2", c: true });
+
   expectTypeOf(actual).toEqualTypeOf<
     Array<["a", number] | ["b", string] | ["c", boolean]>
   >();
@@ -16,11 +18,13 @@ test("with different value types", () => {
 
 test("with const object", () => {
   const actual = entries({ a: 1, b: 2, c: 3 } as const);
+
   expectTypeOf(actual).toEqualTypeOf<Array<["a", 1] | ["b", 2] | ["c", 3]>>();
 });
 
 test("with optional properties", () => {
   const actual = entries({} as { a?: string });
+
   expectTypeOf(actual).toEqualTypeOf<Array<["a", string]>>();
 });
 
@@ -28,25 +32,30 @@ test("with undefined properties", () => {
   const actual = entries({ a: undefined } as {
     a: string | undefined;
   });
+
   expectTypeOf(actual).toEqualTypeOf<Array<["a", string | undefined]>>();
 });
 
 test("with unknown properties", () => {
   const actual = entries({} as Record<string, unknown>);
+
   expectTypeOf(actual).toEqualTypeOf<Array<[string, unknown]>>();
 });
 
 test("object with just symbol keys", () => {
   const actual = entries({ [Symbol("a")]: 1, [Symbol("b")]: "world" });
+
   expectTypeOf(actual).toEqualTypeOf<Array<never>>();
 });
 
 test("object with number keys", () => {
   const actual = entries({ 123: "HELLO" });
+
   expectTypeOf(actual).toEqualTypeOf<Array<["123", string]>>();
 });
 
 test("object with combined symbols and keys", () => {
   const actual = entries({ a: 1, [Symbol("b")]: "world", 123: true });
+
   expectTypeOf(actual).toEqualTypeOf<Array<["123", boolean] | ["a", number]>>();
 });
diff --git a/src/evolve.test-d.ts b/src/evolve.test-d.ts
index 8624682..81e8d02 100644
--- a/src/evolve.test-d.ts
+++ b/src/evolve.test-d.ts
@@ -22,6 +22,7 @@ describe("data first", () => {
         time: { elapsed: add(1), remaining: add(-1) },
       },
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
       quartile: number;
@@ -31,6 +32,7 @@ describe("data first", () => {
 
   it("is not destructive and is immutable", () => {
     const result = evolve({ n: 100 }, { n: add(1) });
+
     expectTypeOf(result).toEqualTypeOf<{ n: number }>();
   });
 
@@ -39,6 +41,7 @@ describe("data first", () => {
       { first: 1, nested: { second: 2, third: 3 } },
       { nested: { second: add(-1), third: add(1) } },
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       first: number;
       nested: { second: number; third: number };
@@ -61,6 +64,7 @@ describe("data first", () => {
         objAry: (x) => map(x, omit(["b"])),
       },
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       array: number;
       nestedObj: { a: { b: string } };
@@ -88,6 +92,7 @@ describe("data first", () => {
           time: (x) => x,
         },
       );
+
       expectTypeOf(result).toEqualTypeOf<{
         id: number;
         quartile: Array<number>;
@@ -114,6 +119,7 @@ describe("data first", () => {
           time: { elapsed: (x) => x, remaining: (x) => x },
         },
       );
+
       expectTypeOf(result).toEqualTypeOf<{
         id: number;
         quartile: Array<number>;
@@ -168,6 +174,7 @@ describe("data first", () => {
           arg2 === undefined && arg3 === undefined,
       },
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       arg2Optional: boolean;
       arg2arg3Optional: boolean;
@@ -210,6 +217,7 @@ describe("data last", () => {
         time: { elapsed: add(1), remaining: add(-1) },
       }),
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
       quartile: number;
@@ -219,6 +227,7 @@ describe("data last", () => {
 
   it("is not destructive and is immutable", () => {
     const result = pipe({ n: 100 }, evolve({ n: add(1) }));
+
     expectTypeOf(result).toEqualTypeOf<{ n: number }>();
   });
 
@@ -227,6 +236,7 @@ describe("data last", () => {
       { first: 1, nested: { second: 2, third: 3 } },
       evolve({ nested: { second: add(-1), third: add(1) } }),
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       first: number;
       nested: { second: number; third: number };
@@ -235,6 +245,7 @@ describe("data last", () => {
 
   it("ignores undefined transformations", () => {
     const result = pipe({ n: 0 }, evolve({}));
+
     expectTypeOf(result).toEqualTypeOf<{ n: number }>();
   });
 
@@ -254,6 +265,7 @@ describe("data last", () => {
         objAry: (x) => map(x, omit(["b"])),
       }),
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       array: number;
       nestedObj: { a: { b: string } };
@@ -307,6 +319,7 @@ describe("data last", () => {
           arg2 === undefined && arg3 === undefined,
       }),
     );
+
     expectTypeOf(result).toEqualTypeOf<{
       arg2Optional: boolean;
       arg2arg3Optional: boolean;
diff --git a/src/filter.test-d.ts b/src/filter.test-d.ts
index 7d873d0..b906067 100644
--- a/src/filter.test-d.ts
+++ b/src/filter.test-d.ts
@@ -4,16 +4,19 @@ import { pipe } from "./pipe";
 describe("data_first", () => {
   it("filter", () => {
     const result = filter([1, 2, 3] as const, (x) => x % 2 === 1);
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 
   it("data_first with typescript guard", () => {
     const result = filter([1, 2, 3, "abc", true] as const, isNumber);
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 
   it("filter indexed", () => {
     const result = filter([1, 2, 3] as const, (x, i) => x % 2 === 1 && i !== 1);
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 });
@@ -24,11 +27,13 @@ describe("data_last", () => {
       [1, 2, 3] as const,
       filter((x) => x % 2 === 1),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 
   it("filter with typescript guard", () => {
     const result = pipe([1, 2, 3, false, "text"] as const, filter(isNumber));
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 
@@ -37,6 +42,7 @@ describe("data_last", () => {
       [1, 2, 3] as const,
       filter((x, i) => x % 2 === 1 && i !== 1),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<1 | 2 | 3>>();
   });
 });
diff --git a/src/find.test-d.ts b/src/find.test-d.ts
index 8470c20..8f2e9c9 100644
--- a/src/find.test-d.ts
+++ b/src/find.test-d.ts
@@ -3,5 +3,6 @@ import { isString } from "./isString";
 
 test("can narrow types", () => {
   const result = find([1, "a"], isString);
+
   expectTypeOf(result).toEqualTypeOf<string | undefined>();
 });
diff --git a/src/first.test-d.ts b/src/first.test-d.ts
index d7f4c01..4883967 100644
--- a/src/first.test-d.ts
+++ b/src/first.test-d.ts
@@ -3,95 +3,111 @@ import { first } from "./first";
 test("simple empty array", () => {
   const arr: Array<number> = [];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple array", () => {
   const arr: Array<number> = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple non-empty array", () => {
   const arr: [number, ...Array<number>] = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("simple tuple", () => {
   const arr: [number, string] = [1, "a"];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("array with more than one item", () => {
   const arr: [number, number, ...Array<number>] = [1, 2];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("trivial empty array", () => {
   const arr: [] = [];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf(undefined);
 });
 
 test("array with last", () => {
   const arr: [...Array<number>, number] = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("tuple with last", () => {
   const arr: [...Array<string>, number] = ["a", 1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | string>();
 });
 
 test("simple empty readonly array", () => {
   const arr: ReadonlyArray<number> = [];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple readonly array", () => {
   const arr: ReadonlyArray<number> = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple non-empty readonly array", () => {
   const arr: readonly [number, ...Array<number>] = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("simple readonly tuple", () => {
   const arr: readonly [number, string] = [1, "a"];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("readonly array with more than one item", () => {
   const arr: readonly [number, number, ...Array<number>] = [1, 2];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("readonly trivial empty array", () => {
   const arr: readonly [] = [];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf(undefined);
 });
 
 test("readonly array with last", () => {
   const arr: readonly [...Array<number>, number] = [1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("readonly tuple with last", () => {
   const arr: readonly [...Array<string>, number] = ["a", 1];
   const result = first(arr);
+
   expectTypeOf(result).toEqualTypeOf<number | string>();
 });
diff --git a/src/firstBy.test-d.ts b/src/firstBy.test-d.ts
index 0a96a71..f966f5b 100644
--- a/src/firstBy.test-d.ts
+++ b/src/firstBy.test-d.ts
@@ -5,17 +5,20 @@ import type { NonEmptyArray } from "./internal/types/NonEmptyArray";
 it("can return undefined on arrays", () => {
   const data: ReadonlyArray<number> = [1, 2, 3];
   const result = firstBy(data, identity());
+
   expectTypeOf(result).toBeNullable();
 });
 
 it("can't return undefined on non-empty array", () => {
   const data: NonEmptyArray<number> = [1, 2, 3];
   const result = firstBy(data, identity());
+
   expectTypeOf(result).not.toBeNullable();
 });
 
 it("only returns null on the empty array", () => {
   const data = [] as const;
   const result = firstBy(data, identity());
+
   expectTypeOf(result).toBeUndefined();
 });
diff --git a/src/flat.test-d.ts b/src/flat.test-d.ts
index 3d5e319..321307d 100644
--- a/src/flat.test-d.ts
+++ b/src/flat.test-d.ts
@@ -3,49 +3,59 @@ import type { NonEmptyArray } from "./internal/types/NonEmptyArray";
 
 it("works on empty arrays", () => {
   const result = flat([], 1);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("works on already-flat arrays", () => {
   const result = flat([] as Array<string>, 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("works on a single level of nesting", () => {
   const result = flat([] as Array<Array<string>>, 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("stops after the first level of nesting (depth === 1)", () => {
   const threeDeepResult = flat([] as Array<Array<Array<string>>>, 1);
+
   expectTypeOf(threeDeepResult).toEqualTypeOf<Array<Array<string>>>();
 
   const fourDeepResult = flat([] as Array<Array<Array<Array<string>>>>, 1);
+
   expectTypeOf(fourDeepResult).toEqualTypeOf<Array<Array<Array<string>>>>();
 });
 
 it("works with mixed types", () => {
   const result = flat([] as Array<Array<number> | Array<string>>, 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
 });
 
 it("works with mixed levels of nesting", () => {
   const result = flat([] as Array<Array<number> | string>, 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
 });
 
 it("works when depth is deeper than the array", () => {
   const result = flat([] as Array<string>, 10);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("works when depth is really really really really big", () => {
   const result = flat([] as Array<string>, 9_999_999);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("keeps the typing of trivial tuples", () => {
   const result = flat([1, 2] as const, 1);
+
   expectTypeOf(result).toEqualTypeOf<[1, 2]>();
 });
 
@@ -57,56 +67,67 @@ it("works on simple tuples", () => {
     ] as const,
     1,
   );
+
   expectTypeOf(result).toEqualTypeOf<[1, 2, 3, 4]>();
 });
 
 it("works on tuples with different levels of nesting", () => {
   const result = flat([1, [2, 3], [4, [5, 6]]] as const, 1);
+
   expectTypeOf(result).toEqualTypeOf<[1, 2, 3, 4, readonly [5, 6]]>();
 });
 
 it("works on tuples with depth>1", () => {
   const result = flat([1, [2, 3], [4, [5, 6]]] as const, 2);
+
   expectTypeOf(result).toEqualTypeOf<[1, 2, 3, 4, 5, 6]>();
 });
 
 it("works with tuples with a lot of nesting", () => {
   const result = flat([[[[1]], [[[[2]]]]], [[[[3, 4], 5]]]] as const, 10);
+
   expectTypeOf(result).toEqualTypeOf<[1, 2, 3, 4, 5]>();
 });
 
 it("works with a mix of simple arrays and tuples", () => {
   const result = flat([[]] as [Array<string>], 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("works with multiple types nested in a tuple", () => {
   const result = flat([[], []] as [Array<string>, Array<number>], 1);
+
   expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
 });
 
 it("works with a tuple with mixed array and non array items", () => {
   const result = flat([1, []] as [number, Array<string>], 1);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<string>]>();
 });
 
 it("works with a tuple with mixed array and non array items, deeply", () => {
   const result = flat([[1], []] as [[number], Array<Array<string>>], 2);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<string>]>();
 });
 
 it("works on non-empty arrays", () => {
   const result = flat([[1]] as NonEmptyArray<NonEmptyArray<number>>, 1);
+
   expectTypeOf(result).toEqualTypeOf<NonEmptyArray<number>>();
 });
 
 it("works on tuples inside arrays", () => {
   const result = flat([] as Array<[Array<string>, Array<number>]>, 2);
+
   expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
 });
 
 it("works on arrays inside tuples", () => {
   const result = flat([1, [], 4] as [1, Array<[2, 3]>, 4], 2);
+
   expectTypeOf(result).toEqualTypeOf<[1, ...Array<2 | 3>, 4]>();
 });
 
@@ -117,6 +138,7 @@ it("works with depths beyond 20", () => {
     [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] as const,
     99,
   );
+
   expectTypeOf(result).toEqualTypeOf<[1]>();
 });
 
diff --git a/src/forEach.test-d.ts b/src/forEach.test-d.ts
index 4f3bdaa..0c6db1d 100644
--- a/src/forEach.test-d.ts
+++ b/src/forEach.test-d.ts
@@ -4,6 +4,7 @@ import { pipe } from "./pipe";
 
 it("doesn't return anything on dataFirst invocations", () => {
   const result = forEach([1, 2, 3], doNothing());
+
   // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- Intentionally
   expectTypeOf(result).toEqualTypeOf<void>();
 });
diff --git a/src/fromEntries.test-d.ts b/src/fromEntries.test-d.ts
index adad7b4..9bffcbf 100644
--- a/src/fromEntries.test-d.ts
+++ b/src/fromEntries.test-d.ts
@@ -3,11 +3,13 @@ import { fromEntries } from "./fromEntries";
 describe("readonly inputs", () => {
   test("trivial empty case", () => {
     const result = fromEntries([] as const);
+
     expectTypeOf(result).toEqualTypeOf({} as const);
   });
 
   test("trivial single entry const case", () => {
     const result = fromEntries([["a", 1]] as const);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1 }>();
   });
 
@@ -17,6 +19,7 @@ describe("readonly inputs", () => {
       ["b", 2],
       ["c", 3],
     ] as const);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1; b: 2; c: 3 }>();
   });
 
@@ -24,6 +27,7 @@ describe("readonly inputs", () => {
     const result = fromEntries(
       [] as ReadonlyArray<["a", 1] | ["b", 2] | ["c", 3]>,
     );
+
     expectTypeOf(result).toEqualTypeOf<{ a?: 1; b?: 2; c?: 3 }>();
   });
 
@@ -32,6 +36,7 @@ describe("readonly inputs", () => {
       ["a", 1],
       ...ReadonlyArray<["b", 2] | ["c", 3]>,
     ]);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1; b?: 2; c?: 3 }>();
   });
 
@@ -40,11 +45,13 @@ describe("readonly inputs", () => {
       ...ReadonlyArray<["b", 2] | ["c", 3]>,
       ["a", 1],
     ]);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1; b?: 2; c?: 3 }>();
   });
 
   test("empty generic type", () => {
     const result = fromEntries([] as ReadonlyArray<readonly [string, boolean]>);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, boolean>>();
   });
 
@@ -63,6 +70,7 @@ describe("readonly inputs", () => {
     const result = fromEntries([["a", "d"]] as ReadonlyArray<
       readonly ["a" | "b" | "c", "d"]
     >);
+
     expectTypeOf(result).toEqualTypeOf<Partial<Record<"a" | "b" | "c", "d">>>();
   });
 
@@ -70,6 +78,7 @@ describe("readonly inputs", () => {
     const result = fromEntries([[1, 123]] as ReadonlyArray<
       readonly [number, 123]
     >);
+
     expectTypeOf(result).toEqualTypeOf<Record<number, 123>>();
   });
 
@@ -77,6 +86,7 @@ describe("readonly inputs", () => {
     const result = fromEntries([["a", 123]] as ReadonlyArray<
       readonly [string, 123]
     >);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, 123>>();
   });
 });
@@ -84,11 +94,13 @@ describe("readonly inputs", () => {
 describe("non-readonly inputs", () => {
   test("trivial empty case", () => {
     const result = fromEntries([]);
+
     expectTypeOf(result).toEqualTypeOf({} as const);
   });
 
   test("trivial single entry const case", () => {
     const result = fromEntries([["a", 1]]);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, number>>();
   });
 
@@ -98,11 +110,13 @@ describe("non-readonly inputs", () => {
       ["b", 2],
       ["c", 3],
     ]);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, number>>();
   });
 
   test("empty well defined array", () => {
     const result = fromEntries([] as Array<["a", 1] | ["b", 2] | ["c", 3]>);
+
     expectTypeOf(result).toEqualTypeOf<{ a?: 1; b?: 2; c?: 3 }>();
   });
 
@@ -111,6 +125,7 @@ describe("non-readonly inputs", () => {
       ["a", 1],
       ...Array<["b", 2] | ["c", 3]>,
     ]);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1; b?: 2; c?: 3 }>();
   });
 
@@ -119,11 +134,13 @@ describe("non-readonly inputs", () => {
       ...Array<["b", 2] | ["c", 3]>,
       ["a", 1],
     ]);
+
     expectTypeOf(result).toEqualTypeOf<{ a: 1; b?: 2; c?: 3 }>();
   });
 
   test("empty generic type", () => {
     const result = fromEntries([] as Array<[string, boolean]>);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, boolean>>();
   });
 
@@ -131,6 +148,7 @@ describe("non-readonly inputs", () => {
     const result = fromEntries([["a", 1]] as Array<
       ["a", 1] | [`testing_${string}`, boolean]
     >);
+
     expectTypeOf(result).toEqualTypeOf<{
       [x: `testing_${string}`]: boolean | undefined;
       a?: 1;
@@ -141,16 +159,19 @@ describe("non-readonly inputs", () => {
     const result = fromEntries([["a", "d"]] as Array<
       readonly ["a" | "b" | "c", "d"]
     >);
+
     expectTypeOf(result).toEqualTypeOf<Partial<Record<"a" | "b" | "c", "d">>>();
   });
 
   test("backwards compatibility (number)", () => {
     const result = fromEntries([[1, 123]] as Array<[number, 123]>);
+
     expectTypeOf(result).toEqualTypeOf<Record<number, 123>>();
   });
 
   test("backwards compatibility (string)", () => {
     const result = fromEntries([["a", 123]] as Array<[string, 123]>);
+
     expectTypeOf(result).toEqualTypeOf<Record<string, 123>>();
   });
 });
diff --git a/src/fromKeys.test-d.ts b/src/fromKeys.test-d.ts
index f5b84b7..285e8b3 100644
--- a/src/fromKeys.test-d.ts
+++ b/src/fromKeys.test-d.ts
@@ -35,10 +35,12 @@ test("empty array", () => {
   const data = [] as const;
 
   const dataFirst = fromKeys(data, constant(1));
+
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- That's just what we return
   expectTypeOf(dataFirst).toEqualTypeOf<{}>();
 
   const dataLast = pipe(data, fromKeys(constant(1)));
+
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- That's just what we return
   expectTypeOf(dataLast).toEqualTypeOf<{}>();
 });
@@ -47,9 +49,11 @@ test("fixed tuple", () => {
   const data = ["cat", "dog"] as const;
 
   const dataFirst = fromKeys(data, constant(1));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<"cat" | "dog", number>>();
 
   const dataLast = pipe(data, fromKeys(constant(1)));
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<"cat" | "dog", number>>();
 });
 
@@ -58,9 +62,11 @@ describe("with simple keys", () => {
     const data = [] as Array<string>;
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<Record<string, number>>();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<Record<string, number>>();
   });
 
@@ -68,9 +74,11 @@ describe("with simple keys", () => {
     const data = ["cat"] as [string, ...Array<string>];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<Record<string, number>>();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<Record<string, number>>();
   });
 
@@ -78,9 +86,11 @@ describe("with simple keys", () => {
     const data = ["cat", "dog"] as [string, string];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<Record<string, number>>();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<Record<string, number>>();
   });
 });
@@ -90,11 +100,13 @@ describe("with literal union keys", () => {
     const data = [] as Array<"cat" | "dog">;
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Partial<Record<"cat" | "dog", number>>
     >();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Partial<Record<"cat" | "dog", number>>
     >();
@@ -104,6 +116,7 @@ describe("with literal union keys", () => {
     const data = ["cat"] as ["cat" | "dog", ...Array<"mouse" | "pig">];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Simplify<
         Partial<Record<"mouse" | "pig", number>> &
@@ -112,6 +125,7 @@ describe("with literal union keys", () => {
     >();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Simplify<
         Partial<Record<"mouse" | "pig", number>> &
@@ -124,6 +138,7 @@ describe("with literal union keys", () => {
     const data = ["cat", "mouse"] as ["cat" | "dog", "mouse" | "pig"];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Simplify<
         ({ cat: number } | { dog: number }) &
@@ -132,6 +147,7 @@ describe("with literal union keys", () => {
     >();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Simplify<
         ({ cat: number } | { dog: number }) &
@@ -146,9 +162,11 @@ describe("with string template keys", () => {
     const data = [] as Array<`prefix_${number}`>;
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<Record<`prefix_${number}`, number>>();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<Record<`prefix_${number}`, number>>();
   });
 
@@ -159,9 +177,11 @@ describe("with string template keys", () => {
     ];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<Record<`prefix_${number}`, number>>();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<Record<`prefix_${number}`, number>>();
   });
 
@@ -172,11 +192,13 @@ describe("with string template keys", () => {
     ];
 
     const dataFirst = fromKeys(data, constant(1));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Record<`${number}_suffix` | `prefix_${number}`, number>
     >();
 
     const dataLast = pipe(data, fromKeys(constant(1)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Record<`${number}_suffix` | `prefix_${number}`, number>
     >();
@@ -187,9 +209,11 @@ describe("with string template keys", () => {
       const data = [] as Array<number>;
 
       const dataFirst = fromKeys(data, constant(1));
+
       expectTypeOf(dataFirst).toEqualTypeOf<Record<number, number>>();
 
       const dataLast = pipe(data, fromKeys(constant(1)));
+
       expectTypeOf(dataLast).toEqualTypeOf<Record<number, number>>();
     });
 
@@ -197,9 +221,11 @@ describe("with string template keys", () => {
       const data = [1] as [number, ...Array<number>];
 
       const dataFirst = fromKeys(data, constant(1));
+
       expectTypeOf(dataFirst).toEqualTypeOf<Record<number, number>>();
 
       const dataLast = pipe(data, fromKeys(constant(1)));
+
       expectTypeOf(dataLast).toEqualTypeOf<Record<number, number>>();
     });
 
@@ -207,9 +233,11 @@ describe("with string template keys", () => {
       const data = [1, 2] as [number, number];
 
       const dataFirst = fromKeys(data, constant(1));
+
       expectTypeOf(dataFirst).toEqualTypeOf<Record<number, number>>();
 
       const dataLast = pipe(data, fromKeys(constant(1)));
+
       expectTypeOf(dataLast).toEqualTypeOf<Record<number, number>>();
     });
 
@@ -217,9 +245,11 @@ describe("with string template keys", () => {
       const data = [1, 2, 3] as const;
 
       const dataFirst = fromKeys(data, constant(1));
+
       expectTypeOf(dataFirst).toEqualTypeOf<Record<1 | 2 | 3, number>>();
 
       const dataLast = pipe(data, fromKeys(constant(1)));
+
       expectTypeOf(dataLast).toEqualTypeOf<Record<1 | 2 | 3, number>>();
     });
   });
@@ -229,11 +259,13 @@ test("typescript doesn't choke on huge literal unions", () => {
   const data = [] as Array<`${Letter}${Letter}`>;
 
   const dataFirst = fromKeys(data, constant(1));
+
   expectTypeOf(dataFirst).toEqualTypeOf<
     Partial<Record<`${Letter}${Letter}`, number>>
   >();
 
   const dataLast = pipe(data, fromKeys(constant(1)));
+
   expectTypeOf(dataLast).toEqualTypeOf<
     Partial<Record<`${Letter}${Letter}`, number>>
   >();
diff --git a/src/funnel.test-d.ts b/src/funnel.test-d.ts
index e876297..7cf412b 100644
--- a/src/funnel.test-d.ts
+++ b/src/funnel.test-d.ts
@@ -9,6 +9,7 @@ describe("'call' method args", () => {
       reducer: (_: "test" | undefined) => "test" as const,
       triggerAt: "start",
     });
+
     expectTypeOf(foo.call).parameters.toEqualTypeOf<[]>();
   });
 
@@ -20,6 +21,7 @@ describe("'call' method args", () => {
 
       triggerAt: "start",
     });
+
     expectTypeOf(foo.call).parameters.toEqualTypeOf<
       [a: string, b: number, c: boolean]
     >();
@@ -31,6 +33,7 @@ describe("'call' method args", () => {
       reducer: (_: "test" | undefined, a?: string) => "test" as const,
       triggerAt: "start",
     });
+
     expectTypeOf(foo.call).parameters.toEqualTypeOf<[a?: string | undefined]>();
   });
 
@@ -43,6 +46,7 @@ describe("'call' method args", () => {
 
       triggerAt: "start",
     });
+
     expectTypeOf(foo.call).parameters.toEqualTypeOf<Array<string>>();
   });
 });
@@ -56,6 +60,7 @@ describe("derive the reducer accumulator type from the executor param", () => {
       {
         reducer: (reduced) => {
           expectTypeOf(reduced).toEqualTypeOf<number | undefined>();
+
           return reduced!;
         },
         triggerAt: "start",
@@ -73,6 +78,7 @@ describe("derive the reducer accumulator type from the executor param", () => {
           expectTypeOf(reduced).toEqualTypeOf<
             ReadonlyArray<number> | undefined
           >();
+
           return reduced!;
         },
         triggerAt: "start",
@@ -90,6 +96,7 @@ describe("derive the reducer accumulator type from the executor param", () => {
           expectTypeOf(reduced).toEqualTypeOf<
             { readonly a: number } | undefined
           >();
+
           return reduced!;
         },
         triggerAt: "start",
diff --git a/src/groupBy.test-d.ts b/src/groupBy.test-d.ts
index 1ee710b..dae4ef2 100644
--- a/src/groupBy.test-d.ts
+++ b/src/groupBy.test-d.ts
@@ -32,6 +32,7 @@ test("union of number literals", () => {
     ] as const,
     prop("b"),
   );
+
   expectTypeOf(data).toEqualTypeOf<
     Partial<
       Record<
@@ -53,6 +54,7 @@ test("string", () => {
     ] as const,
     (x): string => x.a,
   );
+
   expectTypeOf(data).toEqualTypeOf<
     Record<
       string,
@@ -72,6 +74,7 @@ test("number", () => {
     ] as const,
     (x): number => x.b,
   );
+
   expectTypeOf(data).toEqualTypeOf<
     Record<
       number,
@@ -91,6 +94,7 @@ test("string | number", () => {
     ] as const,
     (x): number | string => x.b,
   );
+
   expectTypeOf(data).toEqualTypeOf<
     Record<
       number | string,
@@ -107,6 +111,7 @@ describe("filtering on undefined grouper result", () => {
     const { even, ...rest } = groupBy([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], (x) =>
       x % 2 === 0 ? "even" : undefined,
     );
+
     expectTypeOf(rest).toEqualTypeOf({} as const);
   });
 
@@ -115,6 +120,7 @@ describe("filtering on undefined grouper result", () => {
       ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
       (_, index) => (index % 2 === 0 ? "even" : undefined),
     );
+
     expectTypeOf(rest).toEqualTypeOf({} as const);
   });
 });
diff --git a/src/identity.test-d.ts b/src/identity.test-d.ts
index 647c048..3ab5bb3 100644
--- a/src/identity.test-d.ts
+++ b/src/identity.test-d.ts
@@ -2,6 +2,7 @@ import { identity } from "./identity";
 
 test("normal values", () => {
   const id = identity();
+
   expectTypeOf(id("hello")).toEqualTypeOf<string>();
   expectTypeOf(id(123)).toEqualTypeOf<number>();
   expectTypeOf(id(true)).toEqualTypeOf<boolean>();
@@ -13,6 +14,7 @@ test("normal values", () => {
 
 test("literal values", () => {
   const id = identity();
+
   expectTypeOf(id("hello" as const)).toEqualTypeOf<"hello">();
   expectTypeOf(id(123 as const)).toEqualTypeOf<123>();
   expectTypeOf(id(true as const)).toEqualTypeOf<true>();
@@ -25,6 +27,7 @@ test("literal values", () => {
 test("complex variadic invocations", () => {
   const data = ["a", true, 123] as const;
   const id = identity();
+
   expectTypeOf(id(...data)).toEqualTypeOf<"a">();
 });
 
diff --git a/src/indexBy.test-d.ts b/src/indexBy.test-d.ts
index 150d1bf..ad22631 100644
--- a/src/indexBy.test-d.ts
+++ b/src/indexBy.test-d.ts
@@ -11,6 +11,7 @@ describe("data-first", () => {
       ],
       prop("code"),
     );
+
     expectTypeOf(result).toEqualTypeOf<
       Record<number, { dir: string; code: number }>
     >();
@@ -24,6 +25,7 @@ describe("data-first", () => {
       ] as const,
       prop("code"),
     );
+
     expectTypeOf(result).toEqualTypeOf<
       Partial<
         Record<
@@ -45,6 +47,7 @@ describe("data-last", () => {
       ],
       indexBy(prop("code")),
     );
+
     expectTypeOf(result).toEqualTypeOf<
       Record<number, { dir: string; code: number }>
     >();
@@ -58,6 +61,7 @@ describe("data-last", () => {
       ] as const,
       indexBy(prop("code")),
     );
+
     expectTypeOf(result).toEqualTypeOf<
       Partial<
         Record<
diff --git a/src/internal/types/Deduped.test-d.ts b/src/internal/types/Deduped.test-d.ts
index 1269eb9..0e85948 100644
--- a/src/internal/types/Deduped.test-d.ts
+++ b/src/internal/types/Deduped.test-d.ts
@@ -6,21 +6,25 @@ declare function deduped<T extends IterableContainer>(data: T): Deduped<T>;
 describe("mutable", () => {
   test("empty array", () => {
     const result = deduped([] as []);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("simple array", () => {
     const result = deduped([1, 2, 3] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("array with prefix", () => {
     const result = deduped(["a"] as [string, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<[string, ...Array<number>]>();
   });
 
   test("array with suffix", () => {
     const result = deduped(["a"] as [...Array<number>, string]);
+
     expectTypeOf(result).toEqualTypeOf<
       [number | string, ...Array<number | string>]
     >();
@@ -28,6 +32,7 @@ describe("mutable", () => {
 
   test("array with both prefix and suffix", () => {
     const result = deduped(["a", true] as [string, ...Array<number>, boolean]);
+
     expectTypeOf(result).toEqualTypeOf<[string, ...Array<boolean | number>]>();
   });
 
@@ -35,6 +40,7 @@ describe("mutable", () => {
     const result = deduped(["a"] as
       | [number, ...Array<number>]
       | [string, ...Array<string>]);
+
     expectTypeOf(result).toEqualTypeOf<
       [number, ...Array<number>] | [string, ...Array<string>]
     >();
@@ -44,21 +50,25 @@ describe("mutable", () => {
 describe("readonly", () => {
   test("empty array", () => {
     const result = deduped([] as const);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("simple array", () => {
     const result = deduped([1, 2, 3] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("array with prefix", () => {
     const result = deduped(["a"] as readonly [string, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<[string, ...Array<number>]>();
   });
 
   test("array with suffix", () => {
     const result = deduped(["a"] as readonly [...Array<number>, string]);
+
     expectTypeOf(result).toEqualTypeOf<
       [number | string, ...Array<number | string>]
     >();
@@ -70,6 +80,7 @@ describe("readonly", () => {
       ...Array<number>,
       boolean,
     ]);
+
     expectTypeOf(result).toEqualTypeOf<[string, ...Array<boolean | number>]>();
   });
 
@@ -77,6 +88,7 @@ describe("readonly", () => {
     const result = deduped(["a"] as
       | readonly [number, ...Array<number>]
       | readonly [string, ...Array<string>]);
+
     expectTypeOf(result).toEqualTypeOf<
       [number, ...Array<number>] | [string, ...Array<string>]
     >();
@@ -84,6 +96,7 @@ describe("readonly", () => {
 
   test("constant tuple", () => {
     const result = deduped([1, 2, 3] as const);
+
     expectTypeOf(result).toEqualTypeOf<[1, ...Array<2 | 3>]>();
   });
 });
diff --git a/src/internal/types/NTuple.test-d.ts b/src/internal/types/NTuple.test-d.ts
index 41429fd..d8a79dd 100644
--- a/src/internal/types/NTuple.test-d.ts
+++ b/src/internal/types/NTuple.test-d.ts
@@ -4,10 +4,12 @@ declare function nTuple<T, N extends number>(x: T, n: N): NTuple<T, N>;
 
 test("size 0", () => {
   const result = nTuple("foo", 0);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 test("non-trivial size", () => {
   const result = nTuple("foo", 3);
+
   expectTypeOf(result).toEqualTypeOf<[string, string, string]>();
 });
diff --git a/src/internal/types/TupleParts.test-d.ts b/src/internal/types/TupleParts.test-d.ts
index 5a54a95..16c720c 100644
--- a/src/internal/types/TupleParts.test-d.ts
+++ b/src/internal/types/TupleParts.test-d.ts
@@ -6,6 +6,7 @@ describe("mutable", () => {
   test("empty array", () => {
     const data = [] as [];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -18,6 +19,7 @@ describe("mutable", () => {
   test("regular array", () => {
     const data = [] as Array<number>;
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -30,6 +32,7 @@ describe("mutable", () => {
   test("fixed tuple", () => {
     const data = [1, 2, 3] as [1, 2, 3];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [1, 2, 3];
       required: [1, 2, 3];
@@ -42,6 +45,7 @@ describe("mutable", () => {
   test("array with prefix", () => {
     const data = ["a"] as [string, ...Array<boolean>];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [string];
       required: [string];
@@ -54,6 +58,7 @@ describe("mutable", () => {
   test("array with suffix", () => {
     const data = ["a"] as [...Array<boolean>, string];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -66,6 +71,7 @@ describe("mutable", () => {
   test("array with prefix and suffix", () => {
     const data = [1, "a"] as [number, ...Array<boolean>, string];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [number];
       required: [number];
@@ -78,6 +84,7 @@ describe("mutable", () => {
   test("array with optional prefixes", () => {
     const data = [1, "a"] as [number, string?, number?, ...Array<boolean>];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [number, string?, number?];
       required: [number];
@@ -92,6 +99,7 @@ describe("readonly", () => {
   test("empty array", () => {
     const data = [] as const;
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -104,6 +112,7 @@ describe("readonly", () => {
   test("regular array", () => {
     const data = [] as ReadonlyArray<number>;
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -116,6 +125,7 @@ describe("readonly", () => {
   test("fixed tuple", () => {
     const data = [1, 2, 3] as const;
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [1, 2, 3];
       required: [1, 2, 3];
@@ -128,6 +138,7 @@ describe("readonly", () => {
   test("array with prefix", () => {
     const data = ["a"] as readonly [string, ...Array<boolean>];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [string];
       required: [string];
@@ -140,6 +151,7 @@ describe("readonly", () => {
   test("array with suffix", () => {
     const data = ["a"] as readonly [...Array<boolean>, string];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [];
       required: [];
@@ -152,6 +164,7 @@ describe("readonly", () => {
   test("array with prefix and suffix", () => {
     const data = [1, "a"] as readonly [number, ...Array<boolean>, string];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [number];
       required: [number];
@@ -169,6 +182,7 @@ describe("readonly", () => {
       ...Array<boolean>,
     ];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       prefix: [number, string?, number?];
       required: [number];
@@ -183,6 +197,7 @@ describe("unions", () => {
   test("union of arrays", () => {
     const data = [] as Array<boolean> | Array<number>;
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | { prefix: []; required: []; optional: []; item: boolean; suffix: [] }
       | { prefix: []; required: []; optional: []; item: number; suffix: [] }
@@ -192,6 +207,7 @@ describe("unions", () => {
   test("mixed unions", () => {
     const data = [] as Array<boolean> | [number, string];
     const result = tupleParts(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | { prefix: []; required: []; optional: []; item: boolean; suffix: [] }
       | {
diff --git a/src/internal/types/TupleSplits.test-d.ts b/src/internal/types/TupleSplits.test-d.ts
index 88552fc..acb731d 100644
--- a/src/internal/types/TupleSplits.test-d.ts
+++ b/src/internal/types/TupleSplits.test-d.ts
@@ -7,6 +7,7 @@ describe("mutable", () => {
   test("empty array", () => {
     const data = [] as [];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<{
       left: [];
       right: [];
@@ -16,6 +17,7 @@ describe("mutable", () => {
   test("regular array", () => {
     const data = [] as Array<number>;
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -35,6 +37,7 @@ describe("mutable", () => {
   test("fixed tuple", () => {
     const data = [1, 2, 3] as [1, 2, 3];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [1, 2, 3];
@@ -58,6 +61,7 @@ describe("mutable", () => {
   test("array with prefix", () => {
     const data = ["a"] as [string, ...Array<boolean>];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -81,6 +85,7 @@ describe("mutable", () => {
   test("array with suffix", () => {
     const data = ["a"] as [...Array<boolean>, string];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -104,6 +109,7 @@ describe("mutable", () => {
   test("array with prefix and suffix", () => {
     const data = [1, "a"] as [number, ...Array<boolean>, string];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -131,6 +137,7 @@ describe("mutable", () => {
   test("array with optional prefixes", () => {
     const data = [1, "a"] as [number, string?, number?, ...Array<boolean>];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -164,6 +171,7 @@ describe("unions", () => {
   test("union of arrays", () => {
     const data = [] as Array<boolean> | Array<number>;
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
@@ -195,6 +203,7 @@ describe("unions", () => {
   test("mixed unions", () => {
     const data = [] as Array<boolean> | [number, string];
     const result = tupleSplits(data);
+
     expectTypeOf(result).toEqualTypeOf<
       | {
           left: [];
diff --git a/src/intersection.test-d.ts b/src/intersection.test-d.ts
index 1acc341..c1d7afc 100644
--- a/src/intersection.test-d.ts
+++ b/src/intersection.test-d.ts
@@ -2,5 +2,6 @@ import { intersection } from "./intersection";
 
 it("narrows the result type", () => {
   const result = intersection([1, 2, 3, "a", "b"], ["a", "b", true, false]);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
diff --git a/src/invert.test-d.ts b/src/invert.test-d.ts
index 9d69cc4..bef1eca 100644
--- a/src/invert.test-d.ts
+++ b/src/invert.test-d.ts
@@ -2,16 +2,19 @@ import { invert } from "./invert";
 
 test("simple string records", () => {
   const result = invert({} as Record<string, string>);
+
   expectTypeOf(result).toEqualTypeOf<Record<string, string>>();
 });
 
 test("simple number records", () => {
   const result = invert({} as Record<number, number>);
+
   expectTypeOf(result).toEqualTypeOf<Record<number, `${number}`>>();
 });
 
 test("mixed const objects", () => {
   const result = invert({ a: 123, b: "hello", 3: 456, 4: "world" } as const);
+
   expectTypeOf(result).toEqualTypeOf<{
     123: "a";
     hello: "b";
@@ -22,6 +25,7 @@ test("mixed const objects", () => {
 
 test("optional props", () => {
   const result = invert({} as { a?: "hello"; b?: 123; 3?: "world"; 4?: 456 });
+
   expectTypeOf(result).toEqualTypeOf<{
     hello?: "a";
     123?: "b";
@@ -32,6 +36,7 @@ test("optional props", () => {
 
 test("partial record", () => {
   const result = invert({} as Partial<Record<123 | 456, "cat" | "dog">>);
+
   expectTypeOf(result).toEqualTypeOf<
     Partial<Record<"cat" | "dog", "123" | "456">>
   >();
@@ -39,23 +44,27 @@ test("partial record", () => {
 
 test("symbol keys are filtered out", () => {
   const result = invert({ [Symbol("a")]: 4, a: "hello" } as const);
+
   expectTypeOf(result).toEqualTypeOf<{ hello: "a" }>();
 });
 
 test("number keys are converted to strings", () => {
   const result = invert({ 1: "a", 2: "b" });
+
   expectTypeOf(result).toEqualTypeOf<Record<string, "1" | "2">>();
 });
 
 test("symbol values are fine", () => {
   const mySymbol = Symbol("my");
   const result = invert({ a: mySymbol } as const);
+
   expectTypeOf(result).toEqualTypeOf<{ [mySymbol]: "a" }>();
 });
 
 test("only symbol keys", () => {
   const mySymbol = Symbol("my");
   const result = invert({ [mySymbol]: 4 });
+
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   expectTypeOf(result).toEqualTypeOf<{}>();
 });
diff --git a/src/isArray.test-d.ts b/src/isArray.test-d.ts
index 751b361..99498e8 100644
--- a/src/isArray.test-d.ts
+++ b/src/isArray.test-d.ts
@@ -32,6 +32,7 @@ it("should infer ReadonlyArray<unknown> when given `unknown`", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isArray);
+
   expectTypeOf(data).toEqualTypeOf<
     Array<Array<number> | [number, number, number]>
   >();
diff --git a/src/isBigInt.test-d.ts b/src/isBigInt.test-d.ts
index 36626ac..6897b95 100644
--- a/src/isBigInt.test-d.ts
+++ b/src/isBigInt.test-d.ts
@@ -14,6 +14,7 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isBigInt);
+
   expectTypeOf(data).toEqualTypeOf<Array<1n>>();
 });
 
diff --git a/src/isBoolean.test-d.ts b/src/isBoolean.test-d.ts
index 4b663df..0fc5c27 100644
--- a/src/isBoolean.test-d.ts
+++ b/src/isBoolean.test-d.ts
@@ -29,5 +29,6 @@ it("should narrow `any`", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isBoolean);
+
   expectTypeOf(data).toEqualTypeOf<Array<boolean>>();
 });
diff --git a/src/isDate.test-d.ts b/src/isDate.test-d.ts
index b2c92ac..d102c96 100644
--- a/src/isDate.test-d.ts
+++ b/src/isDate.test-d.ts
@@ -21,5 +21,6 @@ it("should narrow `unknown`", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isDate);
+
   expectTypeOf(data).toEqualTypeOf<Array<Date>>();
 });
diff --git a/src/isDeepEqual.test-d.ts b/src/isDeepEqual.test-d.ts
index e19287b..b92ccf0 100644
--- a/src/isDeepEqual.test-d.ts
+++ b/src/isDeepEqual.test-d.ts
@@ -64,5 +64,6 @@ it("doesn't narrow when comparing objects of the same type", () => {
 it("headless usage can infer types", () => {
   // Tests the issue reported in: https://github.com/remeda/remeda/issues/641
   const result = differenceWith(["a", "b", "c"], ["a", "c", "d"], isDeepEqual);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
diff --git a/src/isDefined.test-d.ts b/src/isDefined.test-d.ts
index 469833e..e431a05 100644
--- a/src/isDefined.test-d.ts
+++ b/src/isDefined.test-d.ts
@@ -35,6 +35,7 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isDefined);
+
   expectTypeOf(data).toEqualTypeOf<
     Array<
       | Array<number>
diff --git a/src/isError.test-d.ts b/src/isError.test-d.ts
index c97a07c..6674c68 100644
--- a/src/isError.test-d.ts
+++ b/src/isError.test-d.ts
@@ -26,5 +26,6 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isError);
+
   expectTypeOf(data).toEqualTypeOf<Array<Error>>();
 });
diff --git a/src/isFunction.test-d.ts b/src/isFunction.test-d.ts
index 80155ef..d9bd087 100644
--- a/src/isFunction.test-d.ts
+++ b/src/isFunction.test-d.ts
@@ -14,11 +14,13 @@ it("should work as type guard", () => {
   let maybeFunction: string | ((a: number) => string) | undefined;
   if (isFunction(maybeFunction)) {
     maybeFunction(1);
+
     expectTypeOf(maybeFunction).toEqualTypeOf<(a: number) => string>();
   }
 });
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isFunction);
+
   expectTypeOf(data).toEqualTypeOf<Array<() => void>>();
 });
diff --git a/src/isNonNull.test-d.ts b/src/isNonNull.test-d.ts
index b93ca32..fbe0447 100644
--- a/src/isNonNull.test-d.ts
+++ b/src/isNonNull.test-d.ts
@@ -35,6 +35,7 @@ test("should work as type guard", () => {
 
 test("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isNonNull);
+
   expectTypeOf(data).toEqualTypeOf<
     Array<
       | Array<number>
diff --git a/src/isNonNullish.test-d.ts b/src/isNonNullish.test-d.ts
index 17e397b..4667e4c 100644
--- a/src/isNonNullish.test-d.ts
+++ b/src/isNonNullish.test-d.ts
@@ -34,6 +34,7 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isNonNullish);
+
   expectTypeOf(data).toEqualTypeOf<
     Array<
       | Array<number>
diff --git a/src/isNot.test-d.ts b/src/isNot.test-d.ts
index 50c576c..f7001eb 100644
--- a/src/isNot.test-d.ts
+++ b/src/isNot.test-d.ts
@@ -37,6 +37,7 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isNot(isPromise));
+
   expectTypeOf(data).toEqualTypeOf<
     Array<
       | Array<number>
diff --git a/src/isNullish.test-d.ts b/src/isNullish.test-d.ts
index 53b6f6c..6e0b16b 100644
--- a/src/isNullish.test-d.ts
+++ b/src/isNullish.test-d.ts
@@ -67,5 +67,6 @@ it("doesn't expand narrow types", () => {
 
 it("should work as type guard in filter", () => {
   const result = ALL_TYPES_DATA_PROVIDER.filter(isNullish);
+
   expectTypeOf(result).toEqualTypeOf<Array<null | undefined>>();
 });
diff --git a/src/isNumber.test-d.ts b/src/isNumber.test-d.ts
index f3dbef5..d55e064 100644
--- a/src/isNumber.test-d.ts
+++ b/src/isNumber.test-d.ts
@@ -14,6 +14,7 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isNumber);
+
   expectTypeOf(data).toEqualTypeOf<Array<number>>();
 });
 
diff --git a/src/isObjectType.test-d.ts b/src/isObjectType.test-d.ts
index 81ff496..bed267b 100644
--- a/src/isObjectType.test-d.ts
+++ b/src/isObjectType.test-d.ts
@@ -43,6 +43,7 @@ test("should work even if data type is unknown", () => {
 
 test("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isObjectType);
+
   expectTypeOf(data).toEqualTypeOf<
     Array<
       | Array<number>
diff --git a/src/isPlainObject.test-d.ts b/src/isPlainObject.test-d.ts
index 2145030..d4fd9df 100644
--- a/src/isPlainObject.test-d.ts
+++ b/src/isPlainObject.test-d.ts
@@ -35,6 +35,7 @@ test("should work even if data type is unknown", () => {
 
 test("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isPlainObject);
+
   expectTypeOf(data).toEqualTypeOf<Array<{ readonly a: "asd" }>>();
 });
 
diff --git a/src/isPromise.test-d.ts b/src/isPromise.test-d.ts
index 0589158..4c15b03 100644
--- a/src/isPromise.test-d.ts
+++ b/src/isPromise.test-d.ts
@@ -14,5 +14,6 @@ it("should work as type guard", () => {
 
 it("should work as type guard in filter", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isPromise);
+
   expectTypeOf(data).toEqualTypeOf<Array<Promise<number>>>();
 });
diff --git a/src/isShallowEqual.test-d.ts b/src/isShallowEqual.test-d.ts
index 404040f..b324825 100644
--- a/src/isShallowEqual.test-d.ts
+++ b/src/isShallowEqual.test-d.ts
@@ -68,5 +68,6 @@ it("headless usage can infer types", () => {
     ["a", "c", "d"],
     isShallowEqual,
   );
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
diff --git a/src/isStrictEqual.test-d.ts b/src/isStrictEqual.test-d.ts
index c0069e9..63979c0 100644
--- a/src/isStrictEqual.test-d.ts
+++ b/src/isStrictEqual.test-d.ts
@@ -68,5 +68,6 @@ it("headless usage can infer types", () => {
     ["a", "c", "d"],
     isStrictEqual,
   );
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
diff --git a/src/isString.test-d.ts b/src/isString.test-d.ts
index 572d797..1491991 100644
--- a/src/isString.test-d.ts
+++ b/src/isString.test-d.ts
@@ -28,6 +28,7 @@ it("should work with literal types", () => {
 
 it("should work as type guard in array", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isString);
+
   expectTypeOf(data).toEqualTypeOf<Array<string>>();
 });
 
diff --git a/src/isSymbol.test-d.ts b/src/isSymbol.test-d.ts
index 6dbe4d3..b0466b7 100644
--- a/src/isSymbol.test-d.ts
+++ b/src/isSymbol.test-d.ts
@@ -29,5 +29,6 @@ it("should work even if data type is `any`", () => {
 
 it("should work as type guard in array", () => {
   const data = ALL_TYPES_DATA_PROVIDER.filter(isSymbol);
+
   expectTypeOf(data).toEqualTypeOf<Array<symbol>>();
 });
diff --git a/src/join.test-d.ts b/src/join.test-d.ts
index d4d8f61..5649d4f 100644
--- a/src/join.test-d.ts
+++ b/src/join.test-d.ts
@@ -3,30 +3,35 @@ import { join } from "./join";
 it("empty tuple", () => {
   const array: [] = [];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<"">();
 });
 
 it("empty readonly tuple", () => {
   const array: readonly [] = [];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<"">();
 });
 
 it("array", () => {
   const array: Array<number> = [];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
 it("readonly array", () => {
   const array: ReadonlyArray<number> = [];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
 it("tuple", () => {
   const array: ["a" | "b", "c" | "d", "e" | "f"] = ["a", "c", "e"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${"a" | "b"},${"c" | "d"},${
     | "e"
     | "f"}`>();
@@ -35,6 +40,7 @@ it("tuple", () => {
 it("readonly tuple", () => {
   const array: readonly ["a" | "b", "c" | "d", "e" | "f"] = ["a", "c", "e"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${"a" | "b"},${"c" | "d"},${
     | "e"
     | "f"}`>();
@@ -43,24 +49,28 @@ it("readonly tuple", () => {
 it("tuple with rest tail", () => {
   const array: ["a" | "b", ...Array<"c" | "d">] = ["a", "c"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${"a" | "b"},${string}`>();
 });
 
 it("readonly tuple with rest tail", () => {
   const array: readonly ["a" | "b", ...Array<"c" | "d">] = ["a", "c"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${"a" | "b"},${string}`>();
 });
 
 it("tuple with rest head", () => {
   const array: [...Array<"a" | "b">, "c" | "d"] = ["a", "c"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${string},${"c" | "d"}`>();
 });
 
 it("readonly tuple with rest head", () => {
   const array: readonly [...Array<"a" | "b">, "c" | "d"] = ["a", "c"];
   const result = join(array, ",");
+
   expectTypeOf(result).toEqualTypeOf<`${string},${"c" | "d"}`>();
 });
 
@@ -68,42 +78,49 @@ describe("tuple item types", () => {
   it("number", () => {
     const array: [number, number] = [1, 2];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${number},${number}`>();
   });
 
   it("string", () => {
     const array: [string, string] = ["a", "b"];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${string},${string}`>();
   });
 
   it("bigint", () => {
     const array: [bigint, bigint] = [1n, 2n];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${bigint},${bigint}`>();
   });
 
   it("boolean", () => {
     const array: [boolean, boolean] = [true, false];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${boolean},${boolean}`>();
   });
 
   it("null", () => {
     const array: [null, null] = [null, null];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<",">();
   });
 
   it("undefined", () => {
     const array: [undefined, undefined] = [undefined, undefined];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<",">();
   });
 
   it("mixed", () => {
     const array: [number, undefined, string] = [1, undefined, "a"];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${number},,${string}`>();
   });
 
@@ -114,6 +131,7 @@ describe("tuple item types", () => {
       "suffix" | undefined,
     ] = ["prefix", undefined, "suffix"];
     const result = join(array, ",");
+
     expectTypeOf(result).toEqualTypeOf<`${"" | "prefix"},${"" | "midfix"},${
       | ""
       | "suffix"}`>();
diff --git a/src/keys.test-d.ts b/src/keys.test-d.ts
index c5b9fdf..101f56c 100644
--- a/src/keys.test-d.ts
+++ b/src/keys.test-d.ts
@@ -4,56 +4,67 @@ import { pipe } from "./pipe";
 describe("arrays", () => {
   test("empty tuple", () => {
     const result = keys([] as []);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("empty readonly tuple", () => {
     const result = keys([] as const);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("array", () => {
     const result = keys([] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<Array<`${number}`>>();
   });
 
   test("readonly array", () => {
     const result = keys([] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<Array<`${number}`>>();
   });
 
   test("tuple", () => {
     const result = keys(["a", 1, true] as ["a", 1, true]);
+
     expectTypeOf(result).toEqualTypeOf<["0", "1", "2"]>();
   });
 
   test("readonly tuple", () => {
     const result = keys(["a", 1, true] as const);
+
     expectTypeOf(result).toEqualTypeOf<["0", "1", "2"]>();
   });
 
   test("tuple with rest tail", () => {
     const result = keys(["a"] as ["a", ...Array<"b">]);
+
     expectTypeOf(result).toEqualTypeOf<["0", ...Array<`${number}`>]>();
   });
 
   test("readonly tuple with rest tail", () => {
     const result = keys(["a"] as readonly ["a", ...Array<"b">]);
+
     expectTypeOf(result).toEqualTypeOf<["0", ...Array<`${number}`>]>();
   });
 
   test("tuple with rest head", () => {
     const result = keys(["b"] as [...Array<"a">, "b"]);
+
     expectTypeOf(result).toEqualTypeOf<[...Array<`${number}`>, `${number}`]>();
   });
 
   test("readonly tuple with rest head", () => {
     const result = keys(["b"] as readonly [...Array<"a">, "b"]);
+
     expectTypeOf(result).toEqualTypeOf<[...Array<`${number}`>, `${number}`]>();
   });
 
   test("tuple with rest middle", () => {
     const result = keys(["a", "c"] as ["a", ...Array<"b">, "c"]);
+
     expectTypeOf(result).toEqualTypeOf<
       ["0", ...Array<`${number}`>, `${number}`]
     >();
@@ -61,6 +72,7 @@ describe("arrays", () => {
 
   test("readonly tuple with rest middle", () => {
     const result = keys(["a", "c"] as readonly ["a", ...Array<"b">, "c"]);
+
     expectTypeOf(result).toEqualTypeOf<
       ["0", ...Array<`${number}`>, `${number}`]
     >();
@@ -70,16 +82,19 @@ describe("arrays", () => {
 describe("object types", () => {
   test("empty record (string)", () => {
     const result = keys({} as Record<string, never>);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("empty record (number)", () => {
     const result = keys({} as Record<number, never>);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("empty record (const)", () => {
     const result = keys({} as const);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
@@ -87,9 +102,11 @@ describe("object types", () => {
     const data = {} as Record<number, unknown> | Record<string, unknown>;
 
     const dataFirst = keys(data);
+
     expectTypeOf(dataFirst).toEqualTypeOf<Array<`${number}`> | Array<string>>();
 
     const dataLast = pipe(data, keys());
+
     expectTypeOf(dataLast).toEqualTypeOf<Array<`${number}`> | Array<string>>();
   });
 
@@ -99,6 +116,7 @@ describe("object types", () => {
       b: number;
       c: boolean;
     });
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | "b" | "c">>();
   });
 
@@ -108,6 +126,7 @@ describe("object types", () => {
       b?: number;
       c?: boolean;
     });
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | "b" | "c">>();
   });
 
@@ -116,11 +135,13 @@ describe("object types", () => {
       [keys: string]: string;
       a: string;
     });
+
     expectTypeOf(result).toEqualTypeOf<Array<string>>();
   });
 
   test("record with literal union", () => {
     const result = keys({ a: 1, b: 2 } as Record<"a" | "b", number>);
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | "b">>();
   });
 
@@ -129,21 +150,25 @@ describe("object types", () => {
       `param_${number}`,
       string
     >);
+
     expectTypeOf(result).toEqualTypeOf<Array<`param_${number}`>>();
   });
 
   test("object with just symbol keys", () => {
     const actual = keys({ [Symbol("a")]: 1, [Symbol("b")]: "world" });
+
     expectTypeOf(actual).toEqualTypeOf<Array<never>>();
   });
 
   test("object with number keys", () => {
     const actual = keys({ 123: "HELLO" });
+
     expectTypeOf(actual).toEqualTypeOf<Array<"123">>();
   });
 
   test("object with combined symbols and keys", () => {
     const actual = keys({ a: 1, [Symbol("b")]: "world", 123: true });
+
     expectTypeOf(actual).toEqualTypeOf<Array<"123" | "a">>();
   });
 });
diff --git a/src/last.test-d.ts b/src/last.test-d.ts
index 25caacf..25bba54 100644
--- a/src/last.test-d.ts
+++ b/src/last.test-d.ts
@@ -3,30 +3,36 @@ import { pipe } from "./pipe";
 
 it("works with empty arrays", () => {
   const result = last([] as const);
+
   expectTypeOf(result).toEqualTypeOf<never>();
 });
 
 it("works with regular arrays", () => {
   const result = last([1, 2, 3] as Array<number>);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("works with non-empty arrays", () => {
   const result = last([1] as [number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("should infer type in pipes", () => {
   const result = pipe("this is a text", (text) => [...text], last());
+
   expectTypeOf(result).toEqualTypeOf<string | undefined>();
 });
 
 test("can infer last type from const arrays", () => {
   const result = last([3, "a", false] as const);
+
   expectTypeOf(result).toEqualTypeOf<false>();
 });
 
 test("a bit more complex example", () => {
   const result = last([["a", 1] as const, true, { foo: "bar" }] as const);
+
   expectTypeOf(result).toEqualTypeOf<{ readonly foo: "bar" }>();
 });
diff --git a/src/map.test-d.ts b/src/map.test-d.ts
index 870e8d8..8b8a68b 100644
--- a/src/map.test-d.ts
+++ b/src/map.test-d.ts
@@ -4,21 +4,25 @@ import { map } from "./map";
 
 it("number array", () => {
   const result = map([1, 2, 3] as Array<number>, add(1));
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("readonly number array", () => {
   const result = map([1, 2, 3] as ReadonlyArray<number>, add(1));
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("number 3-tuple", () => {
   const result = map([1, 2, 3] as [number, number, number], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
 });
 
 it("readonly number 3-tuple", () => {
   const result = map([1, 2, 3] as readonly [number, number, number], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
 });
 
@@ -27,6 +31,7 @@ it("named number 3-tuple", () => {
     [1, 2, 3] as [item1: number, item2: number, item3: number],
     add(1),
   );
+
   // There's no way to test this, but notice that the names are copied to the
   // output here...
   expectTypeOf(result).toEqualTypeOf<
@@ -36,6 +41,7 @@ it("named number 3-tuple", () => {
 
 it("mixed type tuple", () => {
   const result = map([1, "2", true] as [number, string, boolean], constant(1));
+
   expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
 });
 
@@ -44,32 +50,38 @@ it("readonly mixed type tuple", () => {
     [1, "2", true] as readonly [number, string, boolean],
     constant(1),
   );
+
   expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
 });
 
 it("nonempty (tail) number array", () => {
   const result = map([1, 2, 3] as [number, ...Array<number>], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
 it("nonempty (tail) readonly number array", () => {
   const result = map([1, 2, 3] as readonly [number, ...Array<number>], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
 it("nonempty (head) number array", () => {
   const result = map([1, 2, 3] as [...Array<number>, number], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 it("nonempty readonly (head) number array", () => {
   const result = map([1, 2, 3] as readonly [...Array<number>, number], add(1));
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 describe("indexed", () => {
   it("number array", () => {
     const result = map([1, 2, 3] as Array<number>, (x, index) => x + index);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -78,6 +90,7 @@ describe("indexed", () => {
       [1, 2, 3] as ReadonlyArray<number>,
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -86,6 +99,7 @@ describe("indexed", () => {
       [1, 2, 3] as [number, number, number],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
   });
 
@@ -94,6 +108,7 @@ describe("indexed", () => {
       [1, 2, 3] as readonly [number, number, number],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
   });
 
@@ -102,6 +117,7 @@ describe("indexed", () => {
       [1, 2, 3] as [item1: number, item2: number, item3: number],
       (x, index) => x + index,
     );
+
     // There's no way to test this, but notice that the names are copied to the
     // output here...
     expectTypeOf(result).toEqualTypeOf<
@@ -114,6 +130,7 @@ describe("indexed", () => {
       [1, "2", true] as [number, string, boolean],
       (_, index) => index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
   });
 
@@ -122,6 +139,7 @@ describe("indexed", () => {
       [1, "2", true] as readonly [number, string, boolean],
       (_, index) => index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, number, number]>();
   });
 
@@ -130,6 +148,7 @@ describe("indexed", () => {
       [1, 2, 3] as [number, ...Array<number>],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
   });
 
@@ -138,6 +157,7 @@ describe("indexed", () => {
       [1, 2, 3] as readonly [number, ...Array<number>],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
   });
 
@@ -146,6 +166,7 @@ describe("indexed", () => {
       [1, 2, 3] as [...Array<number>, number],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
   });
 
@@ -154,6 +175,7 @@ describe("indexed", () => {
       [1, 2, 3] as readonly [...Array<number>, number],
       (x, index) => x + index,
     );
+
     expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
   });
 });
diff --git a/src/mapKeys.test-d.ts b/src/mapKeys.test-d.ts
index e50def4..1ffd00a 100644
--- a/src/mapKeys.test-d.ts
+++ b/src/mapKeys.test-d.ts
@@ -7,11 +7,13 @@ test("simple string records", () => {
     {} as Record<string, string>,
     constant("hello" as string),
   );
+
   expectTypeOf(result).toEqualTypeOf<Record<string, string>>();
 });
 
 test("simple number records", () => {
   const result = mapKeys({} as Record<number, number>, constant(123 as number));
+
   expectTypeOf(result).toEqualTypeOf<Record<number, number>>();
 });
 
@@ -20,6 +22,7 @@ test("mapping to a string literal", () => {
     {} as Record<number, number>,
     constant("cat" as "cat" | "dog"),
   );
+
   expectTypeOf(result).toEqualTypeOf<Partial<Record<"cat" | "dog", number>>>();
 });
 
@@ -27,6 +30,7 @@ test("symbols are not passed to the mapper", () => {
   mapKeys({ [Symbol("mySymbol")]: 1, b: "hellO", c: true }, (key, value) => {
     expectTypeOf(key).toEqualTypeOf<"b" | "c">();
     expectTypeOf(value).toEqualTypeOf<boolean | string>();
+
     return 3;
   });
 });
@@ -34,6 +38,7 @@ test("symbols are not passed to the mapper", () => {
 test("symbols can be used as the return value", () => {
   const mySymbol = Symbol("mySymbol");
   const result = mapKeys({ a: 1 }, constant(mySymbol));
+
   expectTypeOf(result).toEqualTypeOf<
     Partial<Record<typeof mySymbol, number>>
   >();
@@ -43,12 +48,14 @@ test("number keys are converted to strings", () => {
   mapKeys({ 123: "abc", 456: "def" }, (key, value) => {
     expectTypeOf(key).toEqualTypeOf<"123" | "456">();
     expectTypeOf(value).toEqualTypeOf<string>();
+
     return key;
   });
 });
 
 test("numbers returned from the mapper are used as-is", () => {
   const result = mapKeys({ a: "b" }, constant(123));
+
   expectTypeOf(result).toEqualTypeOf<Partial<Record<123, string>>>();
 });
 
@@ -56,8 +63,10 @@ test("union of records", () => {
   const data = {} as Record<PropertyKey, "cat"> | Record<PropertyKey, "dog">;
 
   const dataFirst = mapKeys(data, constant("hello" as string));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<string, "cat" | "dog">>();
 
   const dataLast = pipe(data, mapKeys(constant("hello" as string)));
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<string, "cat" | "dog">>();
 });
diff --git a/src/mapValues.test-d.ts b/src/mapValues.test-d.ts
index 44a4a5e..e6ca935 100644
--- a/src/mapValues.test-d.ts
+++ b/src/mapValues.test-d.ts
@@ -90,6 +90,7 @@ describe("branded types", () => {
 test("symbols are filtered out", () => {
   const mySymbol = Symbol("mySymbol");
   const result = mapValues({ [mySymbol]: 1, a: "hello" }, constant(true));
+
   expectTypeOf(result).toEqualTypeOf<{ a: boolean }>();
 });
 
@@ -102,6 +103,7 @@ test("symbols are ignored by the mapper", () => {
 
 test("objects with just symbol keys are still well defined", () => {
   const result = mapValues({ [Symbol("a")]: 1 }, constant(true));
+
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   expectTypeOf(result).toEqualTypeOf<{}>();
 });
@@ -110,6 +112,7 @@ test("number keys are converted to string in the mapper", () => {
   mapValues({ 123: 456 }, (value, key) => {
     expectTypeOf(value).toEqualTypeOf<number>();
     expectTypeOf(key).toEqualTypeOf<"123">();
+
     return "world";
   });
 });
@@ -119,6 +122,7 @@ test("maintains partiality", () => {
     {} as { a?: number; b?: string; c: number; d: string },
     constant(true),
   );
+
   expectTypeOf(result).toEqualTypeOf<{
     a?: boolean;
     b?: boolean;
@@ -131,11 +135,13 @@ test("unions of records", () => {
   const data = {} as Record<number, unknown> | Record<string, unknown>;
 
   const dataFirst = mapValues(data, constant("hello" as string));
+
   expectTypeOf(dataFirst).toEqualTypeOf<
     Record<`${number}`, string> | Record<string, string>
   >();
 
   const dataLast = pipe(data, mapValues(constant("hello" as string)));
+
   expectTypeOf(dataLast).toEqualTypeOf<
     Record<`${number}`, string> | Record<string, string>
   >();
diff --git a/src/mapWithFeedback.test-d.ts b/src/mapWithFeedback.test-d.ts
index bca9088..9a4b224 100644
--- a/src/mapWithFeedback.test-d.ts
+++ b/src/mapWithFeedback.test-d.ts
@@ -3,6 +3,7 @@ import { pipe } from "./pipe";
 
 it("should return a mutable tuple type whose length matches input container's length, consisting of the type of the initial value", () => {
   const result = mapWithFeedback([1, 2, 3, 4, 5], (acc, x) => acc + x, 100);
+
   expectTypeOf(result).toEqualTypeOf<
     [number, number, number, number, number]
   >();
@@ -13,6 +14,7 @@ it("should maintain the input shape via a pipe", () => {
     [1, 2, 3, 4, 5] as const,
     mapWithFeedback((acc, x) => acc + x, 100),
   );
+
   expectTypeOf(result).toEqualTypeOf<
     [number, number, number, number, number]
   >();
@@ -24,6 +26,7 @@ it("should return a tuple consisting of the initial value type even if the initi
     (acc, x) => acc + Number.parseInt(x, 10),
     100,
   );
+
   expectTypeOf(result).toEqualTypeOf<
     [number, number, number, number, number]
   >();
@@ -35,6 +38,7 @@ it("should correctly infer type with a non-literal array type", () => {
     (acc, x) => acc + x,
     100,
   );
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
@@ -43,6 +47,7 @@ it("the items array passed to the callback should be an array type containing th
     [1, 2, 3, 4, 5] as const,
     (acc, x, _index, items) => {
       expectTypeOf(items).toEqualTypeOf<readonly [1, 2, 3, 4, 5]>();
+
       return acc + x;
     },
     100,
diff --git a/src/mean.test-d.ts b/src/mean.test-d.ts
index 4744b8f..1783bc1 100644
--- a/src/mean.test-d.ts
+++ b/src/mean.test-d.ts
@@ -3,32 +3,38 @@ import { pipe } from "./pipe";
 
 test("empty arrays", () => {
   const result = mean([] as const);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 describe("dataFirst", () => {
   test("arbitrary arrays", () => {
     const result = mean([] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = mean([] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = mean([1, 2] as [number, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("consts", () => {
     const result = mean([1, 2, 3] as const);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("fixed-size tuples", () => {
     const result = mean([1, 2] as [number, number]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 });
@@ -36,16 +42,19 @@ describe("dataFirst", () => {
 describe("dataLast", () => {
   test("numbers", () => {
     const result = pipe([1, 2, 3] as const, mean());
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary number arrays", () => {
     const result = pipe([] as Array<number>, mean());
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary readonly number arrays", () => {
     const result = pipe([] as ReadonlyArray<number>, mean());
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 });
diff --git a/src/median.test-d.ts b/src/median.test-d.ts
index 2fa86fd..457c6cb 100644
--- a/src/median.test-d.ts
+++ b/src/median.test-d.ts
@@ -3,32 +3,38 @@ import { pipe } from "./pipe";
 
 test("empty arrays", () => {
   const result = median([] as const);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 describe("dataFirst", () => {
   test("arbitrary arrays", () => {
     const result = median([] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = median([] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = median([1, 2] as [number, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("consts", () => {
     const result = median([1, 2, 3] as const);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("fixed-size tuples", () => {
     const result = median([1, 2] as [number, number]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 });
@@ -36,16 +42,19 @@ describe("dataFirst", () => {
 describe("dataLast", () => {
   test("numbers", () => {
     const result = pipe([1, 2, 3] as const, median());
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary number arrays", () => {
     const result = pipe([] as Array<number>, median());
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 
   test("arbitrary readonly number arrays", () => {
     const result = pipe([] as ReadonlyArray<number>, median());
+
     expectTypeOf(result).toEqualTypeOf<number | undefined>();
   });
 });
diff --git a/src/mergeDeep.test-d.ts b/src/mergeDeep.test-d.ts
index 68eeeda..53f20d6 100644
--- a/src/mergeDeep.test-d.ts
+++ b/src/mergeDeep.test-d.ts
@@ -5,6 +5,7 @@ it("trivially merges disjoint objects", () => {
     { foo: "bar" } as { foo: string },
     { bar: "baz" } as { bar: string },
   );
+
   expectTypeOf(result).toEqualTypeOf<{ foo: string; bar: string }>();
 });
 
@@ -13,6 +14,7 @@ it("merges fully overlapping types", () => {
     { foo: "bar" } as { foo: string },
     { foo: "baz" } as { foo: string },
   );
+
   expectTypeOf(result).toEqualTypeOf<{ foo: string }>();
 });
 
@@ -21,6 +23,7 @@ it("merges semi-overlapping types", () => {
     { foo: "bar", x: 1 } as { foo: string; x: number },
     { foo: "baz", y: 2 } as { foo: string; y: number },
   );
+
   expectTypeOf(result).toEqualTypeOf<{ foo: string; x: number; y: number }>();
 });
 
@@ -29,6 +32,7 @@ it("deeply merges", () => {
     { foo: { bar: "bar" } } as { foo: { bar: string } },
     { foo: { qux: "qux" } } as { foo: { qux: string } },
   );
+
   expectTypeOf(result).toEqualTypeOf<{ foo: { bar: string; qux: string } }>();
 });
 
@@ -37,9 +41,11 @@ it("overrides types", () => {
   const b = { foo: "qux" } as { foo: string };
 
   const resultAB = mergeDeep(a, b);
+
   expectTypeOf(resultAB).toEqualTypeOf<{ foo: string }>();
 
   const resultBA = mergeDeep(b, a);
+
   expectTypeOf(resultBA).toEqualTypeOf<{ foo: { bar: string } }>();
 });
 
@@ -48,6 +54,7 @@ it("doesn't spread arrays", () => {
     { foo: ["bar"] } as const,
     { foo: ["baz"] } as const,
   );
+
   expectTypeOf(result).toEqualTypeOf<{ readonly foo: readonly ["baz"] }>();
 });
 
@@ -60,6 +67,7 @@ it("doesn't recurse into arrays", () => {
       foo: Array<{ bar: string; y: number }>;
     },
   );
+
   expectTypeOf(result).toEqualTypeOf<{
     foo: Array<{ bar: string; y: number }>;
   }>();
@@ -82,5 +90,6 @@ it("works with interfaces", () => {
     { a: "foo", b: 123 } as Foo,
     { a: "bar", c: true } as Bar,
   );
+
   expectTypeOf(result).toEqualTypeOf<{ a: string; b: number; c: boolean }>();
 });
diff --git a/src/nthBy.test-d.ts b/src/nthBy.test-d.ts
index a8673a7..2d629b6 100644
--- a/src/nthBy.test-d.ts
+++ b/src/nthBy.test-d.ts
@@ -3,16 +3,19 @@ import { nthBy } from "./nthBy";
 
 it("works with regular arrays", () => {
   const result = nthBy([1, 2, 3], 0, identity());
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 it("works with negative indices", () => {
   const result = nthBy([1, 2, 3], -1, identity());
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 it("works with tuples", () => {
   const data: [string, boolean, number] = ["a", true, 1];
   const result = nthBy(data, 1, identity());
+
   expectTypeOf(result).toEqualTypeOf<boolean | number | string | undefined>();
 });
diff --git a/src/omit.test-d.ts b/src/omit.test-d.ts
index 18c1796..89a149b 100644
--- a/src/omit.test-d.ts
+++ b/src/omit.test-d.ts
@@ -10,6 +10,7 @@ describe("data first", () => {
   test("complex type", () => {
     const obj = { a: 1 } as { a: number } | { a?: number; b: string };
     const result = omit(obj, ["a"]);
+
     expectTypeOf(result).toEqualTypeOf<
       Omit<{ a: number } | { a?: number; b: string }, "a">
     >();
@@ -28,6 +29,7 @@ describe("data last", () => {
   test("complex type", () => {
     const obj = { a: 1 } as { a: number } | { a?: number; b: string };
     const result = pipe(obj, omit(["a"]));
+
     expectTypeOf(result).toEqualTypeOf<
       Omit<{ a: number } | { a?: number; b: string }, "a">
     >();
diff --git a/src/omitBy.test-d.ts b/src/omitBy.test-d.ts
index f288848..f2f12bd 100644
--- a/src/omitBy.test-d.ts
+++ b/src/omitBy.test-d.ts
@@ -8,6 +8,7 @@ import { pipe } from "./pipe";
 describe("data first", () => {
   test("it should omit props", () => {
     const result = omitBy({ a: 1, b: 2, A: 3, B: 4 } as const, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<{ a?: 1; b?: 2; A?: 3; B?: 4 }>();
   });
 
@@ -16,6 +17,7 @@ describe("data first", () => {
       {} as Partial<{ a: string; b: number }>,
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Partial<{ a: string; b: number }>>();
   });
 });
@@ -26,6 +28,7 @@ describe("data last", () => {
       { a: 1, b: 2, A: 3, B: 4 } as const,
       omitBy(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<{ a?: 1; b?: 2; A?: 3; B?: 4 }>();
   });
 
@@ -34,6 +37,7 @@ describe("data last", () => {
       {} as Partial<{ a: string; b: number }>,
       omitBy(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Partial<{ a: string; b: number }>>();
   });
 });
@@ -45,6 +49,7 @@ test("symbols are passed through", () => {
     {} as { [requiredSymbol]: number; [optionalSymbol]?: boolean; a: string },
     constant(true),
   );
+
   expectTypeOf(result).toEqualTypeOf<{
     [requiredSymbol]: number;
     [optionalSymbol]?: boolean;
@@ -56,6 +61,7 @@ test("symbols are not passed to the predicate", () => {
   omitBy({ [Symbol("mySymbol")]: 1, b: "hello", c: true }, (value, key) => {
     expectTypeOf(value).toEqualTypeOf<boolean | string>();
     expectTypeOf(key).toEqualTypeOf<"b" | "c">();
+
     return true;
   });
 });
@@ -63,6 +69,7 @@ test("symbols are not passed to the predicate", () => {
 test("number keys are passed as strings to the predicate", () => {
   omitBy({ 123: "hello" }, (_, key) => {
     expectTypeOf(key).toEqualTypeOf<"123">();
+
     return true;
   });
 });
@@ -79,6 +86,7 @@ test("handles type-predicates", () => {
     },
     isString,
   );
+
   expectTypeOf(result).toEqualTypeOf<{
     b: number;
     optionalB?: number;
@@ -89,9 +97,11 @@ test("handles type-predicates", () => {
 
 test("makes wide types partial", () => {
   const wide = omitBy({ a: 0 } as { a: number }, isDeepEqual(1 as const));
+
   expectTypeOf(wide).toEqualTypeOf<{ a?: number }>();
 
   const narrow = omitBy({ a: 1 } as const, (_x): _x is 1 => true);
+
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   expectTypeOf(narrow).toEqualTypeOf<{}>();
 });
@@ -109,6 +119,7 @@ test("works well with nullish type-guards", () => {
   };
 
   const resultDefined = omitBy(data, isUndefined);
+
   expectTypeOf(resultDefined).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -121,6 +132,7 @@ test("works well with nullish type-guards", () => {
   }>();
 
   const resultNonNull = omitBy(data, isNull);
+
   expectTypeOf(resultNonNull).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -133,6 +145,7 @@ test("works well with nullish type-guards", () => {
   }>();
 
   const resultNonNullish = omitBy(data, isNullish);
+
   expectTypeOf(resultNonNullish).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -150,18 +163,21 @@ describe("records with non-narrowing predicates (Issue #696)", () => {
   test("string keys", () => {
     const data = {} as Record<string, string>;
     const result = omitBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf(data);
   });
 
   test("number keys", () => {
     const data = {} as Record<number, string>;
     const result = omitBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Record<`${number}`, string>>();
   });
 
   test("combined numbers and strings", () => {
     const data = {} as Record<number | string, string>;
     const result = omitBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Record<string, string>>();
   });
 
@@ -169,11 +185,13 @@ describe("records with non-narrowing predicates (Issue #696)", () => {
     const data = {} as Record<number, string> | Record<string, string>;
 
     const dataFirst = omitBy(data, constant(true));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Record<`${number}`, string> | Record<string, string>
     >();
 
     const dataLast = pipe(data, omitBy(constant(true)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Record<`${number}`, string> | Record<string, string>
     >();
diff --git a/src/only.test-d.ts b/src/only.test-d.ts
index c1912a1..9a9b0a3 100644
--- a/src/only.test-d.ts
+++ b/src/only.test-d.ts
@@ -2,100 +2,120 @@ import { only } from "./only";
 
 test("simple array", () => {
   const result = only([] as Array<number>);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple non-empty array", () => {
   const result = only([1] as [number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple tuple", () => {
   const result = only([1, "a"] as [number, string]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("array with more than one item", () => {
   const result = only([1, 2] as [number, number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("trivial empty array", () => {
   const result = only([] as []);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("array with last", () => {
   const result = only([1] as [...Array<number>, number]);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("tuple with last", () => {
   const result = only(["a", 1] as [...Array<string>, number]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
 
 test("tuple with two last", () => {
   const result = only(["a", 1, 2] as [...Array<string>, number, number]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("tuple with first and last", () => {
   const result = only([1, "a", 2] as [number, ...Array<string>, number]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("tuple with optional and array", () => {
   const result = only(["a", 1] as [string?, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
 
 test("tuple with all optional", () => {
   const result = only(["a", 1] as [string?, number?]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
 
 test("simple readonly array", () => {
   const result = only([] as ReadonlyArray<number>);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple non-empty readonly array", () => {
   const result = only([1] as readonly [number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("simple readonly tuple", () => {
   const result = only([1, "a"] as readonly [number, string]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("readonly array with more than one item", () => {
   const result = only([1, 2] as readonly [number, number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<undefined>();
 });
 
 test("readonly trivial empty array", () => {
   const result = only([] as const);
+
   expectTypeOf(result).toEqualTypeOf(undefined);
 });
 
 test("readonly array with last", () => {
   const result = only([1] as readonly [...Array<number>, number]);
+
   expectTypeOf(result).toEqualTypeOf<number | undefined>();
 });
 
 test("readonly tuple with last", () => {
   const result = only(["a", 1] as readonly [...Array<string>, number]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
 
 test("readonly tuple with optional and array", () => {
   const result = only(["a", 1] as readonly [string?, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
 
 test("readonly tuple with all optional", () => {
   const result = only(["a", 1] as readonly [string?, number?]);
+
   expectTypeOf(result).toEqualTypeOf<number | string | undefined>();
 });
diff --git a/src/partition.test-d.ts b/src/partition.test-d.ts
index 09fcb87..90386b2 100644
--- a/src/partition.test-d.ts
+++ b/src/partition.test-d.ts
@@ -4,6 +4,7 @@ import { pipe } from "./pipe";
 
 test("partition with type guard", () => {
   const actual = partition([1, "a", 2, "b"], isNumber);
+
   expectTypeOf(actual).toEqualTypeOf<[Array<number>, Array<string>]>();
 });
 
@@ -12,5 +13,6 @@ test("partition with type guard in pipe", () => {
     [1, "a", 2, "b"],
     partition((value): value is number => typeof value === "number"),
   );
+
   expectTypeOf(actual).toEqualTypeOf<[Array<number>, Array<string>]>();
 });
diff --git a/src/pick.test-d.ts b/src/pick.test-d.ts
index 9c44b8a..7cd9300 100644
--- a/src/pick.test-d.ts
+++ b/src/pick.test-d.ts
@@ -11,6 +11,7 @@ describe("data first", () => {
   test("complex type", () => {
     const obj = { a: 1 } as { a: number } | { a?: number; b: string };
     const result = pick(obj, ["a"]);
+
     expectTypeOf(result).toEqualTypeOf<
       Pick<{ a: number } | { a?: number; b: string }, "a">
     >();
@@ -20,18 +21,22 @@ describe("data first", () => {
     const data = { foo: "hello", bar: "world" };
 
     const raw = pick(data, ["foo"]);
+
     expectTypeOf(raw).toEqualTypeOf<{ foo: string }>();
 
     const wrapped = keys(pick(data, ["foo"]));
+
     expectTypeOf(wrapped).toEqualTypeOf<Array<"foo">>();
 
     const withConstKeys = keys(pick(data, ["foo"] as const));
+
     expectTypeOf(withConstKeys).toEqualTypeOf<Array<"foo">>();
   });
 
   it("handles optional keys (issue #911)", () => {
     const data = { foo: "hello", bar: "world" } as const;
     const result = pick(data, [] as Array<keyof typeof data>);
+
     expectTypeOf(result).toEqualTypeOf<{
       readonly foo?: "hello";
       readonly bar?: "world";
@@ -51,6 +56,7 @@ describe("data last", () => {
   test("complex type", () => {
     const obj = { a: 1 } as { a: number } | { a?: number; b: string };
     const result = pipe(obj, pick(["a"]));
+
     expectTypeOf(result).toEqualTypeOf<
       Pick<{ a: number } | { a?: number; b: string }, "a">
     >();
@@ -80,6 +86,7 @@ test("support inherited properties", () => {
   }
   class TestClass extends BaseClass {}
   const testClass = new TestClass();
+
   expectTypeOf(pick(testClass, ["testProp"])).toEqualTypeOf<{
     testProp: () => string;
   }>();
diff --git a/src/pickBy.test-d.ts b/src/pickBy.test-d.ts
index e5bf53c..7b7af86 100644
--- a/src/pickBy.test-d.ts
+++ b/src/pickBy.test-d.ts
@@ -11,11 +11,13 @@ describe("data first", () => {
   test("it should pick props", () => {
     const data = { a: 1, b: 2, A: 3, B: 4 };
     const result = pickBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Partial<typeof data>>();
   });
 
   test("allow partial type", () => {
     const result = pickBy({} as { a?: string; b?: number }, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Partial<{ a: string; b: number }>>();
   });
 });
@@ -24,6 +26,7 @@ describe("data last", () => {
   test("it should pick props", () => {
     const data = { a: 1, b: 2, A: 3, B: 4 };
     const result = pipe(data, pickBy(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Partial<typeof data>>();
   });
 
@@ -32,6 +35,7 @@ describe("data last", () => {
       {} as { a?: string; b?: number },
       pickBy(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Partial<{ a: string; b: number }>>();
   });
 });
@@ -39,6 +43,7 @@ describe("data last", () => {
 test("symbols are filtered out", () => {
   const mySymbol = Symbol("mySymbol");
   const result = pickBy({ [mySymbol]: 1, a: 123 }, constant(true));
+
   expectTypeOf(result).toEqualTypeOf<{ a?: number }>();
 });
 
@@ -46,15 +51,18 @@ test("symbols are not passed to the predicate", () => {
   pickBy({ [Symbol("mySymbol")]: 1, b: "hello", c: true }, (value, key) => {
     expectTypeOf(value).toEqualTypeOf<boolean | string>();
     expectTypeOf(key).toEqualTypeOf<"b" | "c">();
+
     return true;
   });
 });
 
 test("makes wide types partial", () => {
   const wide = pickBy({ a: 0 } as { a: number }, isDeepEqual(1 as const));
+
   expectTypeOf(wide).toEqualTypeOf<{ a?: 1 }>();
 
   const narrow = pickBy({ a: 1 } as const, (_x): _x is 1 => true);
+
   expectTypeOf(narrow).toEqualTypeOf<{ a: 1 }>();
 });
 
@@ -74,6 +82,7 @@ test("works with type-guards", () => {
     },
     isString,
   );
+
   expectTypeOf(result).toEqualTypeOf<{
     b: string;
     literalUnion: "cat" | "dog";
@@ -96,6 +105,7 @@ test("works well with nullish type-guards", () => {
     optionalNullish?: string | null | undefined;
   };
   const resultDefined = pickBy(data, isDefined);
+
   expectTypeOf(resultDefined).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -108,6 +118,7 @@ test("works well with nullish type-guards", () => {
   }>();
 
   const resultNonNull = pickBy(data, isNonNull);
+
   expectTypeOf(resultNonNull).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -120,6 +131,7 @@ test("works well with nullish type-guards", () => {
   }>();
 
   const resultNonNullish = pickBy(data, isNonNullish);
+
   expectTypeOf(resultNonNullish).toEqualTypeOf<{
     required: string;
     optional?: string;
@@ -137,29 +149,34 @@ describe("records with non-narrowing predicates (Issue #696)", () => {
   test("string keys", () => {
     const data = {} as Record<string, string>;
     const result = pickBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf(data);
   });
 
   test("number keys", () => {
     const data = {} as Record<number, string>;
     const result = pickBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Record<`${number}`, string>>();
   });
 
   test("combined numbers and strings", () => {
     const data = {} as Record<number | string, string>;
     const result = pickBy(data, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Record<string, string>>();
   });
 
   test("union of records", () => {
     const data = {} as Record<number, string> | Record<string, string>;
     const dataFirst = pickBy(data, constant(true));
+
     expectTypeOf(dataFirst).toEqualTypeOf<
       Record<`${number}`, string> | Record<string, string>
     >();
 
     const dataLast = pipe(data, pickBy(constant(true)));
+
     expectTypeOf(dataLast).toEqualTypeOf<
       Record<`${number}`, string> | Record<string, string>
     >();
diff --git a/src/product.test-d.ts b/src/product.test-d.ts
index fddfde4..18ee553 100644
--- a/src/product.test-d.ts
+++ b/src/product.test-d.ts
@@ -3,32 +3,38 @@ import { product } from "./product";
 
 test("empty arrays", () => {
   const result = product([] as const);
+
   expectTypeOf(result).toEqualTypeOf<1>();
 });
 
 describe("numbers", () => {
   test("arbitrary arrays", () => {
     const result = product([] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = product([] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = product([1, 2] as [number, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("consts", () => {
     const result = product([1, 2, 3] as const);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("fixed-size tuples", () => {
     const result = product([1, 2] as [number, number]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 });
@@ -36,26 +42,31 @@ describe("numbers", () => {
 describe("bigints", () => {
   test("arbitrary arrays", () => {
     const result = product([] as Array<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 1>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = product([] as ReadonlyArray<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 1>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = product([1n, 2n] as [bigint, ...Array<bigint>]);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("consts", () => {
     const result = product([1n, 2n, 3n] as const);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("fixed-size tuples", () => {
     const result = product([1n, 2n] as [bigint, bigint]);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 });
@@ -63,11 +74,13 @@ describe("bigints", () => {
 describe("dataLast", () => {
   test("numbers", () => {
     const result = pipe([1, 2, 3] as const, product());
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("bigints", () => {
     const result = pipe([1n, 2n, 3n] as const, product());
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 });
@@ -80,6 +93,7 @@ it("doesn't allow mixed arrays", () => {
 describe("KNOWN ISSUES", () => {
   it("returns 1 (`number`) instead of 1n (`bigint`) for empty `bigint` arrays", () => {
     const result = product([] as Array<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 1>();
   });
 });
diff --git a/src/prop.test-d.ts b/src/prop.test-d.ts
index d0d1809..727a2a2 100644
--- a/src/prop.test-d.ts
+++ b/src/prop.test-d.ts
@@ -7,21 +7,25 @@ test("prop typing", () => {
   const input = [{ a: 1 }];
 
   const works = sortBy(input, prop("a"));
+
   expectTypeOf(works).toEqualTypeOf<typeof input>();
 
   const doesntWork = pipe(input, sortBy(prop("a")));
+
   expectTypeOf(doesntWork).toEqualTypeOf<typeof input>();
 });
 
 test("prop typing standalone", () => {
   const standAlonePropA = prop("a");
   const result = standAlonePropA({ a: 1 });
+
   expectTypeOf(result).toEqualTypeOf<number>();
 });
 
 test("as a callback function", () => {
   const standAlonePropA = prop("a");
   const result = map([{ a: 1 }, { a: 2 }], standAlonePropA);
+
   expectTypeOf(result).toEqualTypeOf<[number, number]>();
 });
 
diff --git a/src/pullObject.test-d.ts b/src/pullObject.test-d.ts
index 56631a4..a22e2c9 100644
--- a/src/pullObject.test-d.ts
+++ b/src/pullObject.test-d.ts
@@ -7,9 +7,11 @@ test("string keys", () => {
   const data = ["a", "b"];
 
   const dataFirst = pullObject(data, identity(), constant("value"));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<string, string>>();
 
   const dataLast = pipe(data, pullObject(identity(), constant("value")));
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<string, string>>();
 });
 
@@ -17,9 +19,11 @@ test("number keys", () => {
   const data = [1, 2];
 
   const dataFirst = pullObject(data, identity(), constant(3));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<number, number>>();
 
   const dataLast = pipe(data, pullObject(identity(), constant(3)));
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<number, number>>();
 });
 
@@ -27,9 +31,11 @@ test("symbol keys", () => {
   const data = [Symbol("a"), Symbol("b")];
 
   const dataFirst = pullObject(data, identity(), constant(Symbol("c")));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<symbol, symbol>>();
 
   const dataLast = pipe(data, pullObject(identity(), constant(Symbol("c"))));
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<symbol, symbol>>();
 });
 
@@ -37,9 +43,11 @@ test("number constants", () => {
   const data = [1, 2] as const;
 
   const dataFirst = pullObject(data, identity(), constant(3 as const));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Partial<Record<1 | 2, 3>>>();
 
   const dataLast = pipe(data, pullObject(identity(), constant(3 as const)));
+
   expectTypeOf(dataLast).toEqualTypeOf<Partial<Record<1 | 2, 3>>>();
 });
 
@@ -47,9 +55,11 @@ test("string constants", () => {
   const data = ["a", "b"] as const;
 
   const dataFirst = pullObject(data, identity(), constant("c" as const));
+
   expectTypeOf(dataFirst).toEqualTypeOf<Partial<Record<"a" | "b", "c">>>();
 
   const dataLast = pipe(data, pullObject(identity(), constant("c" as const)));
+
   expectTypeOf(dataLast).toEqualTypeOf<Partial<Record<"a" | "b", "c">>>();
 });
 
@@ -61,6 +71,7 @@ test("literal unions keys", () => {
     (item) => (item % 2 === 0 ? "odd" : "even"),
     constant("c"),
   );
+
   expectTypeOf(dataFirst).toEqualTypeOf<
     Partial<Record<"even" | "odd", string>>
   >();
@@ -69,6 +80,7 @@ test("literal unions keys", () => {
     data,
     pullObject((item) => (item % 2 === 0 ? "odd" : "even"), constant("c")),
   );
+
   expectTypeOf(dataLast).toEqualTypeOf<
     Partial<Record<"even" | "odd", string>>
   >();
@@ -82,11 +94,13 @@ test("template string keys", () => {
     (item) => `prefix_${item}`,
     constant("value"),
   );
+
   expectTypeOf(dataFirst).toEqualTypeOf<Record<`prefix_${number}`, string>>();
 
   const dataLast = pipe(
     data,
     pullObject((item) => `prefix_${item}`, constant("value")),
   );
+
   expectTypeOf(dataLast).toEqualTypeOf<Record<`prefix_${number}`, string>>();
 });
diff --git a/src/reverse.test-d.ts b/src/reverse.test-d.ts
index ee3c1ad..7db6cdf 100644
--- a/src/reverse.test-d.ts
+++ b/src/reverse.test-d.ts
@@ -4,17 +4,20 @@ import { pipe } from "./pipe";
 describe("data first", () => {
   test("arrays", () => {
     const actual = reverse([1, 2, 3]);
+
     expectTypeOf(actual).toEqualTypeOf<Array<number>>();
   });
 
   test("tuples", () => {
     const actual = reverse([1, 2, [true], "a"] as const);
+
     expectTypeOf(actual).toEqualTypeOf<["a", readonly [true], 2, 1]>();
   });
 
   test("variadic tuples", () => {
     const input: [number, ...Array<string>] = [1, "two", "three"];
     const actual = reverse(input);
+
     expectTypeOf(actual).toEqualTypeOf<[...Array<string>, number]>();
   });
 });
@@ -22,17 +25,20 @@ describe("data first", () => {
 describe("data last", () => {
   test("arrays", () => {
     const actual = pipe([1, 2, 3], reverse());
+
     expectTypeOf(actual).toEqualTypeOf<Array<number>>();
   });
 
   test("tuples", () => {
     const actual = pipe([1, 2, [true], "a"] as const, reverse());
+
     expectTypeOf(actual).toEqualTypeOf<["a", readonly [true], 2, 1]>();
   });
 
   test("variadic tuples", () => {
     const input: [number, ...Array<string>] = [1, "two", "three"];
     const actual = pipe(input, reverse());
+
     expectTypeOf(actual).toEqualTypeOf<[...Array<string>, number]>();
   });
 });
diff --git a/src/sample.test-d.ts b/src/sample.test-d.ts
index 5531667..48dfd20 100644
--- a/src/sample.test-d.ts
+++ b/src/sample.test-d.ts
@@ -4,48 +4,56 @@ describe("sampleSize 0", () => {
   it("on arrays", () => {
     const array: Array<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on tuples", () => {
     const array: [number, number, number, number, number] = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on readonly tuples", () => {
     const array = [1, 2, 3, 4, 5] as const;
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on tuples with rest tail", () => {
     const array: [number, ...Array<number>] = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on tuples with rest head", () => {
     const array: [...Array<number>, number] = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on readonly tuples with rest tail", () => {
     const array: readonly [number, ...Array<number>] = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("on readonly tuples with rest head", () => {
     const array: readonly [...Array<number>, number] = [1, 2, 3, 4, 5];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 });
@@ -54,6 +62,7 @@ describe("sampleSize < n", () => {
   it("on arrays", () => {
     const array: Array<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [number, number, number, number]
@@ -66,6 +75,7 @@ describe("sampleSize < n", () => {
   it("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [number, number, number, number]
@@ -78,6 +88,7 @@ describe("sampleSize < n", () => {
   it("on tuples", () => {
     const array: [1, 2, 3, 4, 5] = [1, 2, 3, 4, 5];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       [1 | 2 | 3 | 4 | 5, 2 | 3 | 4 | 5, 3 | 4 | 5, 4 | 5]
     >();
@@ -86,6 +97,7 @@ describe("sampleSize < n", () => {
   it("on readonly tuples", () => {
     const array = [1, 2, 3, 4, 5] as const;
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       [1 | 2 | 3 | 4 | 5, 2 | 3 | 4 | 5, 3 | 4 | 5, 4 | 5]
     >();
@@ -100,6 +112,7 @@ describe("sampleSize < n", () => {
       "yey",
     ];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3 elements. Only when the tuple has 4 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [boolean | number | string, boolean | string, string, string]
@@ -117,6 +130,7 @@ describe("sampleSize < n", () => {
       "yey",
     ];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3 elements. Only when the tuple has 4 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [boolean | number | string, boolean | string, string, string]
@@ -134,6 +148,7 @@ describe("sampleSize < n", () => {
       3,
     ];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       | [boolean, number]
       | [string, boolean, number]
@@ -150,6 +165,7 @@ describe("sampleSize < n", () => {
       3,
     ];
     const result = sample(array, 4);
+
     expectTypeOf(result).toEqualTypeOf<
       | [boolean, number]
       | [string, boolean, number]
@@ -162,18 +178,21 @@ describe("sampleSize === n", () => {
   it("empty array", () => {
     const array: [] = [];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("empty readonly array", () => {
     const array: readonly [] = [];
     const result = sample(array, 0);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
   it("on arrays", () => {
     const array: Array<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [number, number, number, number, number]
@@ -187,6 +206,7 @@ describe("sampleSize === n", () => {
   it("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [number, number, number, number, number]
@@ -200,12 +220,14 @@ describe("sampleSize === n", () => {
   it("on tuples", () => {
     const array: [1, 2, 3, 4, 5] = [1, 2, 3, 4, 5];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
   it("on readonly tuples", () => {
     const array = [1, 2, 3, 4, 5] as const;
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
@@ -218,6 +240,7 @@ describe("sampleSize === n", () => {
       "yey",
     ];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3 and 4 elements. Only when the return tuple has 5 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [boolean | number | string, boolean | string, string, string, string]
@@ -236,6 +259,7 @@ describe("sampleSize === n", () => {
       "yey",
     ];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3 and 4 elements. Only when the return tuple has 5 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [boolean | number | string, boolean | string, string, string, string]
@@ -254,6 +278,7 @@ describe("sampleSize === n", () => {
       3,
     ];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       | [boolean, number]
       | [string, boolean, number]
@@ -271,6 +296,7 @@ describe("sampleSize === n", () => {
       3,
     ];
     const result = sample(array, 5);
+
     expectTypeOf(result).toEqualTypeOf<
       | [boolean, number]
       | [string, boolean, number]
@@ -284,18 +310,21 @@ describe("sampleSize > n", () => {
   it("empty array", () => {
     const array: [] = [];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("empty readonly array", () => {
     const array: readonly [] = [];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
   it("on arrays", () => {
     const array: Array<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       | [
           number,
@@ -325,6 +354,7 @@ describe("sampleSize > n", () => {
   it("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       | [
           number,
@@ -354,12 +384,14 @@ describe("sampleSize > n", () => {
   it("on tuples", () => {
     const array: [1, 2, 3, 4, 5] = [1, 2, 3, 4, 5];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
   it("on readonly tuples", () => {
     const array = [1, 2, 3, 4, 5] as const;
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
@@ -372,6 +404,7 @@ describe("sampleSize > n", () => {
       "yey",
     ];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3-9 elements. Only when the return tuple has 10 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [
@@ -440,6 +473,7 @@ describe("sampleSize > n", () => {
       "yey",
     ];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: This type is OK (it doesn't type things incorrectly) but it's not as narrow as it could be. If the tuple has only 2 elements, the result should be: `[number, boolean]` and similarly for 3-9 elements. Only when the return tuple has 10 elements then the type of the first and second item should be loosened because we don't know how many items are in the input.
       | [
@@ -508,6 +542,7 @@ describe("sampleSize > n", () => {
       3,
     ];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       | [
           string,
@@ -551,6 +586,7 @@ describe("sampleSize > n", () => {
       3,
     ];
     const result = sample(array, 10);
+
     expectTypeOf(result).toEqualTypeOf<
       | [
           string,
@@ -590,30 +626,35 @@ describe("non-const sampleSize", () => {
   it("empty array", () => {
     const array: [] = [];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   it("empty readonly array", () => {
     const array: readonly [] = [];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<typeof array>();
   });
 
   it("on arrays", () => {
     const array: Array<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   it("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [1, 2, 3, 4, 5];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   it("on tuples", () => {
     const array: [1, 2, 3, 4, 5] = [1, 2, 3, 4, 5];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [1, 2, 3, 4, 5]
@@ -653,6 +694,7 @@ describe("non-const sampleSize", () => {
   it("on readonly tuples", () => {
     const array = [1, 2, 3, 4, 5] as const;
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       | []
       | [1, 2, 3, 4, 5]
@@ -698,6 +740,7 @@ describe("non-const sampleSize", () => {
       "yey",
     ];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       | Array<string>
       | [boolean, ...Array<string>]
@@ -715,6 +758,7 @@ describe("non-const sampleSize", () => {
       "yey",
     ];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       | Array<string>
       | [boolean, ...Array<string>]
@@ -732,6 +776,7 @@ describe("non-const sampleSize", () => {
       3,
     ];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: the typing isn't ideal here. I'm not even sure what the type here should be...
       Array<boolean | number | string>
@@ -747,6 +792,7 @@ describe("non-const sampleSize", () => {
       3,
     ];
     const result = sample(array, 5 as number);
+
     expectTypeOf(result).toEqualTypeOf<
       // TODO: the typing isn't ideal here. I'm not even sure what the type here should be...
       Array<boolean | number | string>
diff --git a/src/set.test-d.ts b/src/set.test-d.ts
index 8223ab6..762e935 100644
--- a/src/set.test-d.ts
+++ b/src/set.test-d.ts
@@ -24,6 +24,7 @@ describe("parameter enforcing", () => {
 
 it("narrows the prop type", () => {
   const result = set({} as { a?: string }, "a", "hello" as const);
+
   expectTypeOf(result).toEqualTypeOf<{ a: "hello" }>();
 });
 
@@ -33,10 +34,12 @@ it("keeps the prop optional when the key isn't literal", () => {
     "a" as "a" | "b",
     "foo" as const,
   );
+
   expectTypeOf(result).toEqualTypeOf<{ a?: string; b?: number | "foo" }>();
 });
 
 it("works on simple objects", () => {
   const result = set({} as Record<string, string>, "a", "foo" as const);
+
   expectTypeOf(result).toEqualTypeOf<{ [x: string]: string; a: "foo" }>();
 });
diff --git a/src/shuffle.test-d.ts b/src/shuffle.test-d.ts
index 20b56ab..c5dabae 100644
--- a/src/shuffle.test-d.ts
+++ b/src/shuffle.test-d.ts
@@ -3,21 +3,25 @@ import { shuffle } from "./shuffle";
 
 test("regular array", () => {
   const result = shuffle([] as Array<string>);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("non-empty tail-rest array", () => {
   const result = shuffle([1] as [number, ...Array<number>]);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
 test("non-empty head-rest array", () => {
   const result = shuffle([1] as [...Array<number>, number]);
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 test("fixed size tuple", () => {
   const result = shuffle([1, "a", true] as [number, string, boolean]);
+
   expectTypeOf(result).toEqualTypeOf<
     [
       boolean | number | string,
@@ -29,11 +33,13 @@ test("fixed size tuple", () => {
 
 it("removes readonlyness from array", () => {
   const result = shuffle([] as ReadonlyArray<string>);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("infers type via a pipe", () => {
   const result = pipe(["a", 1, true] as [string, number, boolean], shuffle());
+
   expectTypeOf(result).toEqualTypeOf<
     [
       boolean | number | string,
diff --git a/src/sort.test-d.ts b/src/sort.test-d.ts
index 235eeae..db9a768 100644
--- a/src/sort.test-d.ts
+++ b/src/sort.test-d.ts
@@ -2,36 +2,43 @@ import { sort } from "./sort";
 
 it("on empty tuple", () => {
   const result = sort([] as [], (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("on empty readonly tuple", () => {
   const result = sort([] as const, (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("on array", () => {
   const result = sort([] as Array<number>, (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("on readonly array", () => {
   const result = sort([] as ReadonlyArray<number>, (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("on tuple", () => {
   const result = sort([1, 2, 3] as [1, 2, 3], (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[1 | 2 | 3, 1 | 2 | 3, 1 | 2 | 3]>();
 });
 
 it("on readonly tuple", () => {
   const result = sort([1, 2, 3] as const, (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[1 | 2 | 3, 1 | 2 | 3, 1 | 2 | 3]>();
 });
 
 it("on tuple with rest tail", () => {
   const result = sort([1] as [number, ...Array<number>], (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
@@ -40,11 +47,13 @@ it("on readonly tuple with rest tail", () => {
     [1] as readonly [number, ...Array<number>],
     (a, b) => a - b,
   );
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
 it("on tuple with rest head", () => {
   const result = sort([1] as [...Array<number>, number], (a, b) => a - b);
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
@@ -53,11 +62,13 @@ it("on readonly tuple with rest head", () => {
     [1] as readonly [...Array<number>, number],
     (a, b) => a - b,
   );
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 it("on mixed types tuple", () => {
   const result = sort([1, "hello", true] as [number, string, boolean], () => 1);
+
   expectTypeOf(result).toEqualTypeOf<
     [
       boolean | number | string,
diff --git a/src/sortBy.test-d.ts b/src/sortBy.test-d.ts
index 18f58fe..1691e7f 100644
--- a/src/sortBy.test-d.ts
+++ b/src/sortBy.test-d.ts
@@ -33,11 +33,13 @@ describe("dataFirst", () => {
   test("sortProjection", () => {
     const items = [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }] as const;
     const actual = sortBy(items, prop("a"));
+
     expectTypeOf(actual).toMatchTypeOf<Array<(typeof items)[number]>>();
   });
 
   test("sortPair", () => {
     const actual = sortBy(DATA, [(x) => x.active, "desc"]);
+
     expectTypeOf(actual).toEqualTypeOf<Array<(typeof DATA)[number]>>();
   });
 });
@@ -46,6 +48,7 @@ describe("dataLast", () => {
   test("sortProjection", () => {
     const items = [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }] as const;
     const actual = pipe(items, sortBy(prop("a")));
+
     expectTypeOf(actual).toMatchTypeOf<Array<(typeof items)[number]>>();
   });
 
@@ -54,47 +57,56 @@ describe("dataLast", () => {
       DATA,
       sortBy([prop("weight"), "asc"], [prop("color"), "desc"]),
     );
+
     expectTypeOf(actual).toEqualTypeOf<Array<(typeof DATA)[number]>>();
   });
 });
 
 it("on empty tuple", () => {
   const result = sortBy([] as [], identity);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("on empty readonly tuple", () => {
   const result = sortBy([] as const, identity);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("on array", () => {
   const result = sortBy([] as Array<number>, identity);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("on readonly array", () => {
   const result = sortBy([] as ReadonlyArray<number>, identity);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("on tuple", () => {
   const result = sortBy([1, 2, 3] as [1, 2, 3], identity);
+
   expectTypeOf(result).toEqualTypeOf<[1 | 2 | 3, 1 | 2 | 3, 1 | 2 | 3]>();
 });
 
 it("on readonly tuple", () => {
   const result = sortBy([1, 2, 3] as const, identity);
+
   expectTypeOf(result).toEqualTypeOf<[1 | 2 | 3, 1 | 2 | 3, 1 | 2 | 3]>();
 });
 
 it("on tuple with rest tail", () => {
   const result = sortBy([1] as [number, ...Array<number>], identity);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
 it("on readonly tuple with rest tail", () => {
   const result = sortBy([1] as readonly [number, ...Array<number>], identity);
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>]>();
 });
 
@@ -103,6 +115,7 @@ test("on tuple with rest middle", () => {
     [3, 2, 1] as [number, ...Array<number>, number],
     identity,
   );
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>, number]>();
 });
 
@@ -111,21 +124,25 @@ test("on readonly tuple with rest middle", () => {
     [3, 2, 1] as readonly [number, ...Array<number>, number],
     identity,
   );
+
   expectTypeOf(result).toEqualTypeOf<[number, ...Array<number>, number]>();
 });
 
 it("on tuple with rest head", () => {
   const result = sortBy([1] as [...Array<number>, number], identity);
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 it("on readonly tuple with rest head", () => {
   const result = sortBy([1] as readonly [...Array<number>, number], identity);
+
   expectTypeOf(result).toEqualTypeOf<[...Array<number>, number]>();
 });
 
 test("on tuple with optional values", () => {
   const result = sortBy([] as [number?, number?, number?], constant(0));
+
   expectTypeOf(result).toEqualTypeOf<[number?, number?, number?]>();
 });
 
@@ -134,6 +151,7 @@ test("on readonly tuple with optional values", () => {
     [] as readonly [number?, number?, number?],
     constant(0),
   );
+
   expectTypeOf(result).toEqualTypeOf<[number?, number?, number?]>();
 });
 
@@ -142,6 +160,7 @@ it("on mixed types tuple", () => {
     [1, "hello", true] as [number, string, boolean],
     identity,
   );
+
   expectTypeOf(result).toEqualTypeOf<
     [
       boolean | number | string,
diff --git a/src/splice.test-d.ts b/src/splice.test-d.ts
index 5b7ebfa..4bbc97c 100644
--- a/src/splice.test-d.ts
+++ b/src/splice.test-d.ts
@@ -3,18 +3,21 @@ import { splice } from "./splice";
 it("reflects the type of `items` in the return value", () => {
   const items: Array<number> = [];
   const result = splice(items, 0, 0, []);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("reflects the type of `replacement` in the return value", () => {
   const replacement: Array<number> = [];
   const result = splice([], 0, 0, replacement);
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("reflects the type of `replacement` in the return value (data-last)", () => {
   const replacement: Array<number> = [];
   const result = splice(0, 0, replacement);
+
   expectTypeOf(result).toEqualTypeOf<
     (items: ReadonlyArray<number>) => Array<number>
   >();
diff --git a/src/split.test-d.ts b/src/split.test-d.ts
index 9b84634..e8208da 100644
--- a/src/split.test-d.ts
+++ b/src/split.test-d.ts
@@ -2,105 +2,126 @@ import { split } from "./split";
 
 test("non-literals", () => {
   const result = split("" as string, "" as string);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("non-literal data", () => {
   const result = split("" as string, ",");
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("non-literal separator", () => {
   const result = split("", "," as string);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("non-literal limit", () => {
   const result = split("", "", 1 as number);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("literal empty strings", () => {
   const result = split("", "");
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 test("trivial literals", () => {
   const result = split("a", ",");
+
   expectTypeOf(result).toEqualTypeOf<["a"]>();
 });
 
 test("string contains separator", () => {
   const result = split(",", ",");
+
   expectTypeOf(result).toEqualTypeOf<["", ""]>();
 });
 
 test("useful split", () => {
   const result = split("a,b,c", ",");
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c"]>();
 });
 
 test("regex split", () => {
   const result = split("a,b,c", /,/u);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("limited split", () => {
   const result = split("a,b,c", ",", 2);
+
   expectTypeOf(result).toEqualTypeOf<["a", "b"]>();
 });
 
 test("limit is higher than splits", () => {
   const result = split("a,b,c", ",", 5);
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c"]>();
 });
 
 test("undefined limit", () => {
   const result = split("a,b,c", ",", undefined);
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c"]>();
 });
 
 test("multiple consecutive separators", () => {
   const result = split("a,,b", ",");
+
   expectTypeOf(result).toEqualTypeOf<["a", "", "b"]>();
 });
 
 test("separator at the start and end", () => {
   const result = split(",a,b,", ",");
+
   expectTypeOf(result).toEqualTypeOf<["", "a", "b", ""]>();
 });
 
 test("empty string separator", () => {
   const result = split("abcdef", "");
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c", "d", "e", "f"]>();
 });
 
 test("empty everything", () => {
   const result = split("", "");
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 test("literal string with multiple character separator", () => {
   const result = split("a--b--c", "--");
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c"]>();
 });
 
 test("negative limit", () => {
   const result = split("a,b,c", ",", -1);
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "c"]>();
 });
 
 test("fractional limits", () => {
   const result = split("a,b,c", ",", 1.5);
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 test("0 limit", () => {
   const result = split("a,b,c", ",", 0);
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 test("optional prefix separator on literal unions (issue: #921)", () => {
   const result = split("a" as "a" | "-a", "-");
+
   expectTypeOf(result).toEqualTypeOf<["a"] | ["", "a"]>();
 });
diff --git a/src/startsWith.test-d.ts b/src/startsWith.test-d.ts
index 0f6e9c6..4d5cde9 100644
--- a/src/startsWith.test-d.ts
+++ b/src/startsWith.test-d.ts
@@ -88,24 +88,28 @@ describe("data-last", () => {
       [] as Array<string>,
       startsWith("foo" as string),
     );
+
     expectTypeOf(yes).toEqualTypeOf<Array<string>>();
     expectTypeOf(no).toEqualTypeOf<Array<string>>();
   });
 
   test("const data that matches", () => {
     const [yes, no] = partition([] as Array<"foobar">, startsWith("foo"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<"foobar">>();
     expectTypeOf(no).toEqualTypeOf<Array<never>>();
   });
 
   test("const data that doesn't match", () => {
     const [yes, no] = partition([] as Array<"helloworld">, startsWith("foo"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<never>>();
     expectTypeOf(no).toEqualTypeOf<Array<"helloworld">>();
   });
 
   test("primitive string data", () => {
     const [yes, no] = partition([] as Array<string>, startsWith("foo"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<`foo${string}`>>();
     expectTypeOf(no).toEqualTypeOf<Array<string>>();
   });
@@ -115,6 +119,7 @@ describe("data-last", () => {
       [] as Array<`foo_${number}`>,
       startsWith("foo"),
     );
+
     expectTypeOf(yes).branded.toEqualTypeOf<Array<`foo_${number}`>>();
     expectTypeOf(no).toEqualTypeOf<Array<never>>();
   });
@@ -124,6 +129,7 @@ describe("data-last", () => {
       [] as Array<`foo_${number}`>,
       startsWith("hello"),
     );
+
     expectTypeOf(yes).toEqualTypeOf<
       // These should be equivalent to `never` but TypeScript doesn't infer
       // that...
@@ -134,6 +140,7 @@ describe("data-last", () => {
 
   test("literal union", () => {
     const [yes, no] = partition([] as Array<"cat" | "dog">, startsWith("c"));
+
     expectTypeOf(yes).toEqualTypeOf<Array<"cat">>();
     expectTypeOf(no).toEqualTypeOf<Array<"dog">>();
   });
@@ -143,6 +150,7 @@ describe("data-last", () => {
       [] as Array<`cat_${number}` | `dog_${boolean}`>,
       startsWith("c"),
     );
+
     expectTypeOf(yes).branded.toEqualTypeOf<Array<`cat_${number}`>>();
     expectTypeOf(no).toEqualTypeOf<Array<`dog_${boolean}`>>();
   });
diff --git a/src/stringToPath.test-d.ts b/src/stringToPath.test-d.ts
index ac874bc..15c2db4 100644
--- a/src/stringToPath.test-d.ts
+++ b/src/stringToPath.test-d.ts
@@ -2,11 +2,13 @@ import { stringToPath } from "./stringToPath";
 
 test("should convert a string to a deeply nested path", () => {
   const result = stringToPath("a.b[0].c");
+
   expectTypeOf(result).toEqualTypeOf<["a", "b", "0", "c"]>();
 });
 
 test("simple const string are inferred", () => {
   const result = stringToPath("foo[bar.baz].qui");
+
   expectTypeOf(result).toEqualTypeOf<["foo", "bar.baz", "qui"]>();
 });
 
@@ -14,6 +16,7 @@ test("should handle long paths", () => {
   const result = stringToPath(
     "lorem.ipsum[dolor.sit].amet.con.sec.tetur[adi.pisc.ing].elit.42",
   );
+
   expectTypeOf(result).toEqualTypeOf<
     [
       "lorem",
@@ -32,5 +35,6 @@ test("should handle long paths", () => {
 
 test("dynamic strings cannot be inferred", () => {
   const result = stringToPath(`foo.${"bar" as string}[baz]`);
+
   expectTypeOf(result).toEqualTypeOf<never>();
 });
diff --git a/src/sum.test-d.ts b/src/sum.test-d.ts
index 9f17830..41e600b 100644
--- a/src/sum.test-d.ts
+++ b/src/sum.test-d.ts
@@ -3,32 +3,38 @@ import { sum } from "./sum";
 
 test("empty arrays", () => {
   const result = sum([] as const);
+
   expectTypeOf(result).toEqualTypeOf<0>();
 });
 
 describe("numbers", () => {
   test("arbitrary arrays", () => {
     const result = sum([] as Array<number>);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = sum([] as ReadonlyArray<number>);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = sum([1, 2] as [number, ...Array<number>]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("consts", () => {
     const result = sum([1, 2, 3] as const);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("fixed-size tuples", () => {
     const result = sum([1, 2] as [number, number]);
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 });
@@ -36,26 +42,31 @@ describe("numbers", () => {
 describe("bigints", () => {
   test("arbitrary arrays", () => {
     const result = sum([] as Array<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 0>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = sum([] as ReadonlyArray<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 0>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = sum([1n, 2n] as [bigint, ...Array<bigint>]);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("consts", () => {
     const result = sum([1n, 2n, 3n] as const);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("fixed-size tuples", () => {
     const result = sum([1n, 2n] as [bigint, bigint]);
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 });
@@ -63,11 +74,13 @@ describe("bigints", () => {
 describe("dataLast", () => {
   test("numbers", () => {
     const result = pipe([1, 2, 3] as const, sum());
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("bigints", () => {
     const result = pipe([1n, 2n, 3n] as const, sum());
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 });
@@ -80,6 +93,7 @@ it("doesn't allow mixed arrays", () => {
 describe("KNOWN ISSUES", () => {
   it("returns 0 (`number`) instead of 0n (`bigint`) for empty `bigint` arrays", () => {
     const result = sum([] as Array<bigint>);
+
     expectTypeOf(result).toEqualTypeOf<bigint | 0>();
   });
 });
diff --git a/src/sumBy.test-d.ts b/src/sumBy.test-d.ts
index 19d753e..9a0e7ac 100644
--- a/src/sumBy.test-d.ts
+++ b/src/sumBy.test-d.ts
@@ -4,9 +4,11 @@ import { constant } from "./constant";
 
 test("empty array", () => {
   const result1 = sumBy([], constant(1n));
+
   expectTypeOf(result1).toEqualTypeOf<0>();
 
   const result2 = sumBy([], constant(1));
+
   expectTypeOf(result2).toEqualTypeOf<0>();
 });
 
@@ -23,26 +25,31 @@ test("disallow mixed mapper", () => {
 describe("numbers", () => {
   test("arbitrary arrays", () => {
     const result = sumBy([] as Array<unknown>, constant(1));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = sumBy([] as ReadonlyArray<unknown>, constant(1));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("arbitrary non-empty arrays", () => {
     const result = sumBy([1, 2] as [unknown, ...Array<unknown>], constant(1));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("consts", () => {
     const result = sumBy([1, 2, 3] as const, constant(1));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("fixed-size tuples", () => {
     const result = sumBy([1, 2] as [unknown, unknown], constant(1));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 });
@@ -50,11 +57,13 @@ describe("numbers", () => {
 describe("bigints", () => {
   test("arbitrary arrays", () => {
     const result = sumBy([] as Array<unknown>, constant(1n));
+
     expectTypeOf(result).toEqualTypeOf<bigint | 0>();
   });
 
   test("arbitrary readonly arrays", () => {
     const result = sumBy([] as ReadonlyArray<unknown>, constant(1n));
+
     expectTypeOf(result).toEqualTypeOf<bigint | 0>();
   });
 
@@ -63,16 +72,19 @@ describe("bigints", () => {
       [1n, 2n] as [unknown, ...Array<unknown>],
       constant(1n),
     );
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("consts", () => {
     const result = sumBy([1n, 2n, 3n] as const, constant(1n));
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("fixed-size tuples", () => {
     const result = sumBy([1n, 2n] as [unknown, unknown], constant(1n));
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 });
@@ -80,21 +92,25 @@ describe("bigints", () => {
 describe("dataLast", () => {
   test("numbers", () => {
     const result = pipe([1, 2, 3] as const, sumBy(constant(1)));
+
     expectTypeOf(result).toEqualTypeOf<number>();
   });
 
   test("bigints", () => {
     const result = pipe([1n, 2n, 3n] as const, sumBy(constant(1n)));
+
     expectTypeOf(result).toEqualTypeOf<bigint>();
   });
 
   test("empty array number", () => {
     const result = pipe([] as const, sumBy(constant(1)));
+
     expectTypeOf(result).toEqualTypeOf<0>();
   });
 
   test("empty array bigint", () => {
     const result = pipe([] as const, sumBy(constant(1n)));
+
     expectTypeOf(result).toEqualTypeOf<0>();
   });
 });
diff --git a/src/take.test-d.ts b/src/take.test-d.ts
index 2f0133f..da9fe06 100644
--- a/src/take.test-d.ts
+++ b/src/take.test-d.ts
@@ -4,41 +4,49 @@ import { take } from "./take";
 describe("data-first", () => {
   test("empty array", () => {
     const result = take([] as [], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = take([] as Array<number>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = take([] as Array<number | string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = take([1] as [number, ...Array<boolean>], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = take([1] as [...Array<boolean>, number], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("array with suffix and prefix", () => {
     const result = take([1, "a"] as [number, ...Array<boolean>, string], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = take([1, "a", true] as const, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = take([] as Array<boolean> | Array<string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -46,26 +54,31 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = pipe([] as Array<number | string>, take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = pipe([1] as [number, ...Array<boolean>], take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = pipe([1] as [...Array<boolean>, number], take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -74,16 +87,19 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       take(2),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = pipe([] as Array<boolean> | Array<string>, take(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
diff --git a/src/takeLast.test-d.ts b/src/takeLast.test-d.ts
index 5a0c5d9..9e1613f 100644
--- a/src/takeLast.test-d.ts
+++ b/src/takeLast.test-d.ts
@@ -4,41 +4,49 @@ import { takeLast } from "./takeLast";
 describe("data-first", () => {
   test("empty array", () => {
     const result = takeLast([] as [], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = takeLast([] as Array<number>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = takeLast([] as Array<number | string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = takeLast([1] as [number, ...Array<boolean>], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = takeLast([1] as [...Array<boolean>, number], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("array with suffix and prefix", () => {
     const result = takeLast([1, "a"] as [number, ...Array<boolean>, string], 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = takeLast([1, "a", true] as const, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = takeLast([] as Array<boolean> | Array<string>, 2);
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -46,26 +54,31 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = pipe([] as Array<number | string>, takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
   test("prefix array", () => {
     const result = pipe([1] as [number, ...Array<boolean>], takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
   test("suffix array", () => {
     const result = pipe([1] as [...Array<boolean>, number], takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -74,16 +87,19 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       takeLast(2),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
   test("union of arrays", () => {
     const result = pipe([] as Array<boolean> | Array<string>, takeLast(2));
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
diff --git a/src/takeLastWhile.test-d.ts b/src/takeLastWhile.test-d.ts
index c50b7e0..b03cc3c 100644
--- a/src/takeLastWhile.test-d.ts
+++ b/src/takeLastWhile.test-d.ts
@@ -5,16 +5,19 @@ import { takeLastWhile } from "./takeLastWhile";
 describe("data-first", () => {
   test("empty array", () => {
     const result = takeLastWhile([] as [], constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = takeLastWhile([] as Array<number>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = takeLastWhile([] as Array<number | string>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -23,6 +26,7 @@ describe("data-first", () => {
       [1] as [number, ...Array<boolean>],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -31,6 +35,7 @@ describe("data-first", () => {
       [1] as [...Array<boolean>, number],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -39,11 +44,13 @@ describe("data-first", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = takeLastWhile([1, "a", true] as const, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -52,6 +59,7 @@ describe("data-first", () => {
       [] as Array<boolean> | Array<string>,
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -59,11 +67,13 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], takeLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, takeLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -72,6 +82,7 @@ describe("data-last", () => {
       [] as Array<number | string>,
       takeLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -80,6 +91,7 @@ describe("data-last", () => {
       [1] as [number, ...Array<boolean>],
       takeLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -88,6 +100,7 @@ describe("data-last", () => {
       [1] as [...Array<boolean>, number],
       takeLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -96,11 +109,13 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       takeLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, takeLastWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -109,6 +124,7 @@ describe("data-last", () => {
       [] as Array<boolean> | Array<string>,
       takeLastWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
@@ -120,6 +136,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<never>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[]>();
+
           return true;
         }),
       );
@@ -132,6 +149,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number>>();
+
           return true;
         }),
       );
@@ -144,6 +162,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number | string>>();
+
           return true;
         }),
       );
@@ -156,6 +175,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[number, ...Array<boolean>]>();
+
           return true;
         }),
       );
@@ -168,6 +188,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[...Array<boolean>, number]>();
+
           return true;
         }),
       );
@@ -182,6 +203,7 @@ describe("data-last", () => {
           expectTypeOf(array).toEqualTypeOf<
             [number, ...Array<boolean>, string]
           >();
+
           return true;
         }),
       );
@@ -194,6 +216,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<"a" | 1 | true>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<readonly [1, "a", true]>();
+
           return true;
         }),
       );
@@ -206,6 +229,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<boolean> | Array<string>>();
+
           return true;
         }),
       );
diff --git a/src/takeWhile.test-d.ts b/src/takeWhile.test-d.ts
index 6cf1663..3b63b89 100644
--- a/src/takeWhile.test-d.ts
+++ b/src/takeWhile.test-d.ts
@@ -5,16 +5,19 @@ import { takeWhile } from "./takeWhile";
 describe("data-first", () => {
   test("empty array", () => {
     const result = takeWhile([] as [], constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = takeWhile([] as Array<number>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
   test("regular array with union type", () => {
     const result = takeWhile([] as Array<number | string>, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -23,6 +26,7 @@ describe("data-first", () => {
       [1] as [number, ...Array<boolean>],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -31,6 +35,7 @@ describe("data-first", () => {
       [1] as [...Array<boolean>, number],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -39,11 +44,13 @@ describe("data-first", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = takeWhile([1, "a", true] as const, constant(true));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -52,6 +59,7 @@ describe("data-first", () => {
       [] as Array<boolean> | Array<string>,
       constant(true),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 });
@@ -59,11 +67,13 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("empty array", () => {
     const result = pipe([] as [], takeWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<never>>();
   });
 
   test("regular array", () => {
     const result = pipe([] as Array<number>, takeWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<number>>();
   });
 
@@ -72,6 +82,7 @@ describe("data-last", () => {
       [] as Array<number | string>,
       takeWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
   });
 
@@ -80,6 +91,7 @@ describe("data-last", () => {
       [1] as [number, ...Array<boolean>],
       takeWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -88,6 +100,7 @@ describe("data-last", () => {
       [1] as [...Array<boolean>, number],
       takeWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number>>();
   });
 
@@ -96,11 +109,13 @@ describe("data-last", () => {
       [1, "a"] as [number, ...Array<boolean>, string],
       takeWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | number | string>>();
   });
 
   test("tuple", () => {
     const result = pipe([1, "a", true] as const, takeWhile(constant(true)));
+
     expectTypeOf(result).toEqualTypeOf<Array<"a" | 1 | true>>();
   });
 
@@ -109,6 +124,7 @@ describe("data-last", () => {
       [] as Array<boolean> | Array<string>,
       takeWhile(constant(true)),
     );
+
     expectTypeOf(result).toEqualTypeOf<Array<boolean | string>>();
   });
 
@@ -120,6 +136,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<never>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[]>();
+
           return true;
         }),
       );
@@ -132,6 +149,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number>>();
+
           return true;
         }),
       );
@@ -144,6 +162,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<number | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<number | string>>();
+
           return true;
         }),
       );
@@ -156,6 +175,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[number, ...Array<boolean>]>();
+
           return true;
         }),
       );
@@ -168,6 +188,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | number>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<[...Array<boolean>, number]>();
+
           return true;
         }),
       );
@@ -182,6 +203,7 @@ describe("data-last", () => {
           expectTypeOf(array).toEqualTypeOf<
             [number, ...Array<boolean>, string]
           >();
+
           return true;
         }),
       );
@@ -194,6 +216,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<"a" | 1 | true>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<readonly [1, "a", true]>();
+
           return true;
         }),
       );
@@ -206,6 +229,7 @@ describe("data-last", () => {
           expectTypeOf(item).toEqualTypeOf<boolean | string>();
           expectTypeOf(index).toEqualTypeOf<number>();
           expectTypeOf(array).toEqualTypeOf<Array<boolean> | Array<string>>();
+
           return true;
         }),
       );
diff --git a/src/tap.test-d.ts b/src/tap.test-d.ts
index 3eeb2f9..faf89cd 100644
--- a/src/tap.test-d.ts
+++ b/src/tap.test-d.ts
@@ -22,6 +22,7 @@ it("should infer types after tapping function reference with parameter type any"
     tap(foo),
     map((n) => {
       expectTypeOf(n).toEqualTypeOf<number>();
+
       return n * 2;
     }),
   );
diff --git a/src/times.test-d.ts b/src/times.test-d.ts
index f60ecad..4847000 100644
--- a/src/times.test-d.ts
+++ b/src/times.test-d.ts
@@ -3,16 +3,19 @@ import { times } from "./times";
 
 it("works with 0", () => {
   const result = times(0, identity());
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("works with non-literals", () => {
   const result = times(10 as number, identity());
+
   expectTypeOf(result).toEqualTypeOf<Array<number>>();
 });
 
 it("works with positive integer literals", () => {
   const result = times(10, identity());
+
   expectTypeOf(result).toEqualTypeOf<
     [
       number,
@@ -31,11 +34,13 @@ it("works with positive integer literals", () => {
 
 it("works with negative integers", () => {
   const result = times(-10, identity());
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("works with non-integer positive literals", () => {
   const result = times(10.5, identity());
+
   expectTypeOf(result).toEqualTypeOf<
     [
       number,
@@ -54,16 +59,19 @@ it("works with non-integer positive literals", () => {
 
 it("works with non-integer negative literals", () => {
   const result = times(-10.5, identity());
+
   expectTypeOf(result).toEqualTypeOf<[]>();
 });
 
 it("works with literal unions", () => {
   const result = times(1 as 1 | 3, identity());
+
   expectTypeOf(result).toEqualTypeOf<[number, number, number] | [number]>();
 });
 
 it("could be 'disabled' with large literals", () => {
   const result = times(10_000, identity());
+
   // The result is a tuple of our max length supported for a literal, with an
   // array tail for the rest of the items...
   expectTypeOf(result).toMatchTypeOf<Array<number>>();
diff --git a/src/toCamelCase.test-d.ts b/src/toCamelCase.test-d.ts
index 62dc19c..3ebfb52 100644
--- a/src/toCamelCase.test-d.ts
+++ b/src/toCamelCase.test-d.ts
@@ -4,6 +4,7 @@ import { toCamelCase } from "./toCamelCase";
 describe("data-last", () => {
   test("without options", () => {
     const result = pipe("hello world" as const, toCamelCase());
+
     expectTypeOf(result).toEqualTypeOf<"helloWorld">();
   });
 
@@ -12,6 +13,7 @@ describe("data-last", () => {
       "fooBAR" as const,
       toCamelCase({ preserveConsecutiveUppercase: true }),
     );
+
     expectTypeOf(result).toEqualTypeOf<"fooBAR">();
   });
 
@@ -20,6 +22,7 @@ describe("data-last", () => {
       "fooBAR" as const,
       toCamelCase({ preserveConsecutiveUppercase: false }),
     );
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 });
@@ -27,130 +30,155 @@ describe("data-last", () => {
 describe("tests copied from type-fest's tests", () => {
   test("pascal", () => {
     const result = toCamelCase("FooBar");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("kebab", () => {
     const result = toCamelCase("foo-bar");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("complex kebab", () => {
     const result = toCamelCase("foo-bar-abc-123");
+
     expectTypeOf(result).toEqualTypeOf<"fooBarAbc123">();
   });
 
   test("space", () => {
     const result = toCamelCase("foo bar");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("snake", () => {
     const result = toCamelCase("foo_bar");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("no delimiter from mono", () => {
     const result = toCamelCase("foobar");
+
     expectTypeOf(result).toEqualTypeOf<"foobar">();
   });
 
   test("mixed", () => {
     const result = toCamelCase("foo-bar_abc xyzBarFoo");
+
     expectTypeOf(result).toEqualTypeOf<"fooBarAbcXyzBarFoo">();
   });
 
   test("vendor prefixed css property", () => {
     const result = toCamelCase("-webkit-animation");
+
     expectTypeOf(result).toEqualTypeOf<"webkitAnimation">();
   });
 
   test("double prefixed kebab", () => {
     const result = toCamelCase("--very-prefixed");
+
     expectTypeOf(result).toEqualTypeOf<"veryPrefixed">();
   });
 
   test("repeated separators", () => {
     const result = toCamelCase("foo____bar");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("uppercase", () => {
     const result = toCamelCase("FOO");
+
     expectTypeOf(result).toEqualTypeOf<"foo">();
   });
 
   test("lowercase", () => {
     const result = toCamelCase("foo");
+
     expectTypeOf(result).toEqualTypeOf<"foo">();
   });
 
   test("screaming snake case", () => {
     const result = toCamelCase("FOO_BAR");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("screaming kebab case", () => {
     const result = toCamelCase("FOO-BAR");
+
     expectTypeOf(result).toEqualTypeOf<"fooBar">();
   });
 
   test("preserveConsecutiveUppercase: fooBAR", () => {
     const data = "fooBAR";
     const whenTrue = toCamelCase(data, { preserveConsecutiveUppercase: true });
+
     expectTypeOf(whenTrue).toEqualTypeOf<"fooBAR">();
 
     const whenFalse = toCamelCase(data, {
       preserveConsecutiveUppercase: false,
     });
+
     expectTypeOf(whenFalse).toEqualTypeOf<"fooBar">();
   });
 
   test("preserveConsecutiveUppercase: fooBARBiz", () => {
     const data = "fooBARBiz";
     const whenTrue = toCamelCase(data, { preserveConsecutiveUppercase: true });
+
     expectTypeOf(whenTrue).toEqualTypeOf<"fooBARBiz">();
 
     const whenFalse = toCamelCase(data, {
       preserveConsecutiveUppercase: false,
     });
+
     expectTypeOf(whenFalse).toEqualTypeOf<"fooBarBiz">();
   });
 
   test("preserveConsecutiveUppercase: foo BAR-Biz_BUZZ", () => {
     const data = "foo BAR-Biz_BUZZ";
     const whenTrue = toCamelCase(data, { preserveConsecutiveUppercase: true });
+
     expectTypeOf(whenTrue).toEqualTypeOf<"fooBARBizBUZZ">();
 
     const whenFalse = toCamelCase(data, {
       preserveConsecutiveUppercase: false,
     });
+
     expectTypeOf(whenFalse).toEqualTypeOf<"fooBarBizBuzz">();
   });
 
   test("preserveConsecutiveUppercase: foo\tBAR-Biz_BUZZ", () => {
     const data = "foo\tBAR-Biz_BUZZ";
     const whenTrue = toCamelCase(data, { preserveConsecutiveUppercase: true });
+
     expectTypeOf(whenTrue).toEqualTypeOf<"fooBARBizBUZZ">();
 
     const whenFalse = toCamelCase(data, {
       preserveConsecutiveUppercase: false,
     });
+
     expectTypeOf(whenFalse).toEqualTypeOf<"fooBarBizBuzz">();
   });
 });
 
 test("fallback when regular string", () => {
   const result = toCamelCase("hello world" as string);
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
 test("with template literal type (lowercase)", () => {
   const result = toCamelCase("this_is_1" as `this_is_${number}`);
+
   expectTypeOf(result).toEqualTypeOf<`thisIs${Capitalize<`${number}`>}`>();
 });
 
 test("with template literal type (uppercase)", () => {
   const result = toCamelCase("THIS_IS_1" as `THIS_IS_${number}`);
+
   expectTypeOf(result).toEqualTypeOf<`tHISIS${Capitalize<`${number}`>}`>();
 });
diff --git a/src/toKebabCase.test-d.ts b/src/toKebabCase.test-d.ts
index b30e08f..91a4aba 100644
--- a/src/toKebabCase.test-d.ts
+++ b/src/toKebabCase.test-d.ts
@@ -3,55 +3,66 @@ import { toKebabCase } from "./toKebabCase";
 
 test("primitive string", () => {
   const result = toKebabCase("hello world" as string);
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
 test("empty string", () => {
   const result = toKebabCase("" as const);
+
   expectTypeOf(result).toEqualTypeOf<"">();
 });
 
 test("camelCase", () => {
   const result = toKebabCase("helloWorld" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("spaces and mixed cases", () => {
   const result = toKebabCase("Hello World" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("spaces and lower case", () => {
   const result = toKebabCase("hello world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("spaces and UPPERCASE", () => {
   const result = toKebabCase("HELLO WORLD" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("snake_case", () => {
   const result = toKebabCase("hello_world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("kebab-case", () => {
   const result = toKebabCase("hello-world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world">();
 });
 
 test("string with multiple delimiters", () => {
   const result = toKebabCase("foo---bar" as const);
+
   expectTypeOf(result).toEqualTypeOf<"foo-bar">();
 });
 
 test("numbers", () => {
   const result = toKebabCase("helloWorld123" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-world-123">();
 });
 
 test("string with special characters", () => {
   const result = toKebabCase("hello@world!" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello-@world-!">();
 });
diff --git a/src/toLowerCase.test-d.ts b/src/toLowerCase.test-d.ts
index ec99739..d6b91f6 100644
--- a/src/toLowerCase.test-d.ts
+++ b/src/toLowerCase.test-d.ts
@@ -4,31 +4,37 @@ import { toLowerCase } from "./toLowerCase";
 describe("data-first", () => {
   test("on lower case", () => {
     const result = toLowerCase("hello world");
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on upper case", () => {
     const result = toLowerCase("HELLO WORLD");
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on mixed case", () => {
     const result = toLowerCase("HeLlO WoRlD");
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on empty string", () => {
     const result = toLowerCase("");
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = toLowerCase("hello world" as string);
+
     expectTypeOf(result).toEqualTypeOf<Lowercase<string>>();
   });
 
   test("on template literal type", () => {
     const result = toLowerCase("PREFIX_123" as `PREFIX_${number}`);
+
     expectTypeOf(result).toEqualTypeOf<`prefix_${Lowercase<`${number}`>}`>();
   });
 });
@@ -36,31 +42,37 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("on lower case", () => {
     const result = pipe("hello world" as const, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on upper case", () => {
     const result = pipe("HELLO WORLD" as const, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on mixed case", () => {
     const result = pipe("HeLlO WoRlD" as const, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on empty string", () => {
     const result = pipe("" as const, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = pipe("hello world" as string, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<Lowercase<string>>();
   });
 
   test("on template literal type", () => {
     const result = pipe("prefix_123" as `PREFIX_${number}`, toLowerCase());
+
     expectTypeOf(result).toEqualTypeOf<`prefix_${Lowercase<`${number}`>}`>();
   });
 });
diff --git a/src/toSnakeCase.test-d.ts b/src/toSnakeCase.test-d.ts
index 1e94894..e149b06 100644
--- a/src/toSnakeCase.test-d.ts
+++ b/src/toSnakeCase.test-d.ts
@@ -3,55 +3,66 @@ import { toSnakeCase } from "./toSnakeCase";
 
 test("primitive string", () => {
   const result = toSnakeCase("hello world" as string);
+
   expectTypeOf(result).toEqualTypeOf<string>();
 });
 
 test("empty string", () => {
   const result = toSnakeCase("" as const);
+
   expectTypeOf(result).toEqualTypeOf<"">();
 });
 
 test("camelCase", () => {
   const result = toSnakeCase("helloWorld" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("spaces and mixed cases", () => {
   const result = toSnakeCase("Hello World" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("spaces and lower case", () => {
   const result = toSnakeCase("hello world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("spaces and UPPERCASE", () => {
   const result = toSnakeCase("HELLO WORLD" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("snake_case", () => {
   const result = toSnakeCase("hello_world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("kebab-case", () => {
   const result = toSnakeCase("hello-world" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world">();
 });
 
 test("string with multiple delimiters", () => {
   const result = toSnakeCase("foo___bar" as const);
+
   expectTypeOf(result).toEqualTypeOf<"foo_bar">();
 });
 
 test("numbers", () => {
   const result = toSnakeCase("helloWorld123" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_world_123">();
 });
 
 test("string with special characters", () => {
   const result = toSnakeCase("hello@world!" as const);
+
   expectTypeOf(result).toEqualTypeOf<"hello_@world_!">();
 });
diff --git a/src/toUpperCase.test-d.ts b/src/toUpperCase.test-d.ts
index 3e3125c..c103f24 100644
--- a/src/toUpperCase.test-d.ts
+++ b/src/toUpperCase.test-d.ts
@@ -4,31 +4,37 @@ import { toUpperCase } from "./toUpperCase";
 describe("data-first", () => {
   test("on lower case", () => {
     const result = toUpperCase("hello world");
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on upper case", () => {
     const result = toUpperCase("HELLO WORLD");
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = toUpperCase("HeLlO WoRlD");
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on empty string", () => {
     const result = toUpperCase("");
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = toUpperCase("hello world" as string);
+
     expectTypeOf(result).toEqualTypeOf<Uppercase<string>>();
   });
 
   test("on template literal type", () => {
     const result = toUpperCase("prefix_123" as `prefix_${number}`);
+
     expectTypeOf(result).toEqualTypeOf<`PREFIX_${Uppercase<`${number}`>}`>();
   });
 });
@@ -36,31 +42,37 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("on lower case", () => {
     const result = pipe("hello world" as const, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on upper case", () => {
     const result = pipe("HELLO WORLD" as const, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = pipe("HeLlO WoRlD" as const, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<"HELLO WORLD">();
   });
 
   test("on empty string", () => {
     const result = pipe("" as const, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = pipe("hello world" as string, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<Uppercase<string>>();
   });
 
   test("on template literal type", () => {
     const result = pipe("prefix_123" as `prefix_${number}`, toUpperCase());
+
     expectTypeOf(result).toEqualTypeOf<`PREFIX_${Uppercase<`${number}`>}`>();
   });
 });
diff --git a/src/uncapitalize.test-d.ts b/src/uncapitalize.test-d.ts
index d1a1215..a93140a 100644
--- a/src/uncapitalize.test-d.ts
+++ b/src/uncapitalize.test-d.ts
@@ -4,31 +4,37 @@ import { uncapitalize } from "./uncapitalize";
 describe("data-first", () => {
   test("on lower case", () => {
     const result = uncapitalize("hello world");
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on upper case", () => {
     const result = uncapitalize("HELLO WORLD");
+
     expectTypeOf(result).toEqualTypeOf<"hELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = uncapitalize("HeLlO WoRlD");
+
     expectTypeOf(result).toEqualTypeOf<"heLlO WoRlD">();
   });
 
   test("on empty string", () => {
     const result = uncapitalize("");
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = uncapitalize("hello world" as string);
+
     expectTypeOf(result).toEqualTypeOf<Uncapitalize<string>>();
   });
 
   test("on template literal type", () => {
     const result = uncapitalize("PREFIX_123" as `PREFIX_${number}`);
+
     expectTypeOf(result).toEqualTypeOf<`pREFIX_${number}`>();
   });
 });
@@ -36,31 +42,37 @@ describe("data-first", () => {
 describe("data-last", () => {
   test("on lower case", () => {
     const result = pipe("hello world" as const, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<"hello world">();
   });
 
   test("on upper case", () => {
     const result = pipe("HELLO WORLD" as const, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<"hELLO WORLD">();
   });
 
   test("on mixed case", () => {
     const result = pipe("HeLlO WoRlD" as const, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<"heLlO WoRlD">();
   });
 
   test("on empty string", () => {
     const result = pipe("" as const, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<"">();
   });
 
   test("on non-literal string", () => {
     const result = pipe("hello world" as string, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<Uncapitalize<string>>();
   });
 
   test("on template literal type", () => {
     const result = pipe("PREFIX_123" as `PREFIX_${number}`, uncapitalize());
+
     expectTypeOf(result).toEqualTypeOf<`pREFIX_${number}`>();
   });
 });
diff --git a/src/values.test-d.ts b/src/values.test-d.ts
index e82cde4..1f6abed 100644
--- a/src/values.test-d.ts
+++ b/src/values.test-d.ts
@@ -3,31 +3,37 @@ import { values } from "./values";
 
 it("should correctly types indexed types", () => {
   const result = values<Record<string, string>>({ a: "b" });
+
   expectTypeOf(result).toEqualTypeOf<Array<string>>();
 });
 
 it("should correctly type functions", () => {
   const result = values(doNothing());
+
   expectTypeOf(result).toEqualTypeOf<Array<never>>();
 });
 
 it("should correctly type arrays", () => {
   const results = values([1, 2, 3]);
+
   expectTypeOf(results).toEqualTypeOf<Array<number>>();
 });
 
 it("should correctly type const arrays", () => {
   const results = values([1, 2, 3] as const);
+
   expectTypeOf(results).toEqualTypeOf<Array<1 | 2 | 3>>();
 });
 
 it("should correctly type objects", () => {
   const result = values({ a: true });
+
   expectTypeOf(result).toEqualTypeOf<Array<boolean>>();
 });
 
 it("should correctly type Records", () => {
   const result = values<Record<string, boolean>>({ a: true });
+
   expectTypeOf(result).toEqualTypeOf<Array<boolean>>();
 });
 
@@ -44,15 +50,18 @@ it("should correctly type typed objects", () => {
     type: "cat",
     age: 7,
   });
+
   expectTypeOf(result).toEqualTypeOf<Array<number | "cat" | "dog">>();
 });
 
 it("should skip symbol keys", () => {
   const result = values({ [Symbol("a")]: true, a: "b", 123: 456 });
+
   expectTypeOf(result).toEqualTypeOf<Array<number | string>>();
 });
 
 it("should return a useful type when all keys are symbols", () => {
   const result = values({ [Symbol("a")]: true, [Symbol("b")]: "c" });
+
   expectTypeOf(result).toEqualTypeOf<Array<never>>();
 });
diff --git a/src/when.test-d.ts b/src/when.test-d.ts
index 60b318f..94737d0 100644
--- a/src/when.test-d.ts
+++ b/src/when.test-d.ts
@@ -17,6 +17,7 @@ describe("dataFirst", () => {
       it("return type is not narrowed", () => {
         const data = "hello" as number | string;
         const result = when(data, constant(true), constant({ a: 1 }));
+
         // The result contains both the input type, and the result of the
         // branch.
         expectTypeOf(result).toEqualTypeOf<typeof data | { a: number }>();
@@ -52,6 +53,7 @@ describe("dataFirst", () => {
       it("removes narrowed types from the output", () => {
         const data = "hello" as number | string;
         const result = when(data, isString, constant("cat" as const));
+
         // The result doesn't contain the input type that was narrowed against
         // (string), but does contain the input type that wasn't (number).
         expectTypeOf(result).toEqualTypeOf<number | "cat">();
@@ -97,6 +99,7 @@ describe("dataFirst", () => {
           onTrue: constant("cat" as const),
           onFalse: constant("dog" as const),
         });
+
         expectTypeOf(result).toEqualTypeOf<"cat" | "dog">();
       });
 
@@ -148,6 +151,7 @@ describe("dataFirst", () => {
           onTrue: constant("cat" as const),
           onFalse: constant("dog" as const),
         });
+
         expectTypeOf(result).toEqualTypeOf<"cat" | "dog">();
       });
 
@@ -198,6 +202,7 @@ describe("dataLast", () => {
       it("return type is not narrowed", () => {
         const data = "hello" as number | string;
         const result = pipe(data, when(constant(true), constant({ a: 1 })));
+
         // The result contains both the input type, and the result of the
         // branch.
         expectTypeOf(result).toEqualTypeOf<typeof data | { a: number }>();
@@ -230,6 +235,7 @@ describe("dataLast", () => {
       it("removes narrowed types from the output", () => {
         const data = "hello" as number | string;
         const result = pipe(data, when(isString, constant("cat" as const)));
+
         // The result doesn't contain the input type that was narrowed against
         // (string), but does contain the input type that wasn't (number).
         expectTypeOf(result).toEqualTypeOf<number | "cat">();
@@ -275,6 +281,7 @@ describe("dataLast", () => {
             onFalse: constant("dog" as const),
           }),
         );
+
         expectTypeOf(result).toEqualTypeOf<"cat" | "dog">();
       });
 
@@ -325,6 +332,7 @@ describe("dataLast", () => {
             onFalse: constant("dog" as const),
           }),
         );
+
         expectTypeOf(result).toEqualTypeOf<"cat" | "dog">();
       });
 
diff --git a/src/zip.test-d.ts b/src/zip.test-d.ts
index 2348413..2a91a4a 100644
--- a/src/zip.test-d.ts
+++ b/src/zip.test-d.ts
@@ -4,6 +4,7 @@ import { zip } from "./zip";
 describe("dataFirst", () => {
   test("arrays", () => {
     const actual = zip([1, 2, 3], ["a", "b", "c"]);
+
     expectTypeOf(actual).toEqualTypeOf<
       [[number, string], [number, string], [number, string]]
     >();
@@ -14,6 +15,7 @@ describe("dataFirst", () => {
       [1, 2, 3] as [1, 2, 3],
       ["a", "b", "c"] as ["a", "b", "c"],
     );
+
     expectTypeOf(actual).toEqualTypeOf<[[1, "a"], [2, "b"], [3, "c"]]>();
   });
 
@@ -21,6 +23,7 @@ describe("dataFirst", () => {
     const firstVariadic: [number, ...Array<string>] = [1, "b", "c"];
     const secondVariadic: [string, ...Array<number>] = ["a", 2, 3];
     const actual = zip(firstVariadic, secondVariadic);
+
     expectTypeOf(actual).toEqualTypeOf<
       [[number, string], ...Array<[string, number]>]
     >();
@@ -29,18 +32,21 @@ describe("dataFirst", () => {
   test("on empty tuples", () => {
     const array: [] = [];
     const result = zip(array, array);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("on empty readonly tuples", () => {
     const array: readonly [] = [];
     const result = zip(array, array);
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("on arrays", () => {
     const array: Array<number> = [];
     const result = zip(array, array);
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, number]>>();
   });
 
@@ -48,12 +54,14 @@ describe("dataFirst", () => {
     const array1: Array<number> = [];
     const array2: Array<string> = [];
     const result = zip(array1, array2);
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, string]>>();
   });
 
   test("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [];
     const result = zip(array, array);
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, number]>>();
   });
 
@@ -61,6 +69,7 @@ describe("dataFirst", () => {
     const array1: [1, 2, 3] = [1, 2, 3];
     const array2: [4, 5, 6] = [4, 5, 6];
     const result = zip(array1, array2);
+
     expectTypeOf(result).toEqualTypeOf<[[1, 4], [2, 5], [3, 6]]>();
   });
 
@@ -68,6 +77,7 @@ describe("dataFirst", () => {
     const array1: readonly [1, 2, 3] = [1, 2, 3];
     const array2: readonly [4, 5, 6] = [4, 5, 6];
     const result = zip(array1, array2);
+
     expectTypeOf(result).toEqualTypeOf<[[1, 4], [2, 5], [3, 6]]>();
   });
 
@@ -75,8 +85,11 @@ describe("dataFirst", () => {
     const array1: [1, 2, 3] = [1, 2, 3];
     const array2: [4, 5] = [4, 5];
     const result1 = zip(array1, array2);
+
     expectTypeOf(result1).toEqualTypeOf<[[1, 4], [2, 5]]>();
+
     const result2 = zip(array2, array1);
+
     expectTypeOf(result2).toEqualTypeOf<[[4, 1], [5, 2]]>();
   });
 
@@ -84,6 +97,7 @@ describe("dataFirst", () => {
     const firstVariadic: [number, ...Array<string>] = [1, "b", "c"];
     const secondVariadic: [string, ...Array<number>] = ["a", 2, 3];
     const result = zip(firstVariadic, secondVariadic);
+
     expectTypeOf(result).toEqualTypeOf<
       [[number, string], ...Array<[string, number]>]
     >();
@@ -93,6 +107,7 @@ describe("dataFirst", () => {
 describe("dataLast", () => {
   test("arrays", () => {
     const actual = pipe([1, 2, 3], zip(["a", "b", "c"]));
+
     expectTypeOf(actual).toEqualTypeOf<
       [[number, string], [number, string], [number, string]]
     >();
@@ -103,6 +118,7 @@ describe("dataLast", () => {
       [1, 2, 3] as [1, 2, 3],
       zip(["a", "b", "c"] as ["a", "b", "c"]),
     );
+
     expectTypeOf(actual).toEqualTypeOf<[[1, "a"], [2, "b"], [3, "c"]]>();
   });
 
@@ -110,6 +126,7 @@ describe("dataLast", () => {
     const firstVariadic: [number, ...Array<string>] = [1, "b", "c"];
     const secondVariadic: [string, ...Array<number>] = ["a", 2, 3];
     const actual = pipe(firstVariadic, zip(secondVariadic));
+
     expectTypeOf(actual).toEqualTypeOf<
       [[number, string], ...Array<[string, number]>]
     >();
@@ -118,18 +135,21 @@ describe("dataLast", () => {
   test("on empty tuples", () => {
     const array: [] = [];
     const result = pipe(array, zip(array));
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("on empty readonly tuples", () => {
     const array: readonly [] = [];
     const result = pipe(array, zip(array));
+
     expectTypeOf(result).toEqualTypeOf<[]>();
   });
 
   test("on arrays", () => {
     const array: Array<number> = [];
     const result = pipe(array, zip(array));
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, number]>>();
   });
 
@@ -137,12 +157,14 @@ describe("dataLast", () => {
     const array1: Array<number> = [];
     const array2: Array<string> = [];
     const result = pipe(array1, zip(array2));
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, string]>>();
   });
 
   test("on readonly arrays", () => {
     const array: ReadonlyArray<number> = [];
     const result = pipe(array, zip(array));
+
     expectTypeOf(result).toEqualTypeOf<Array<[number, number]>>();
   });
 
@@ -150,6 +172,7 @@ describe("dataLast", () => {
     const array1: [1, 2, 3] = [1, 2, 3];
     const array2: [4, 5, 6] = [4, 5, 6];
     const result = pipe(array1, zip(array2));
+
     expectTypeOf(result).toEqualTypeOf<[[1, 4], [2, 5], [3, 6]]>();
   });
 
@@ -157,6 +180,7 @@ describe("dataLast", () => {
     const array1: readonly [1, 2, 3] = [1, 2, 3];
     const array2: readonly [4, 5, 6] = [4, 5, 6];
     const result = pipe(array1, zip(array2));
+
     expectTypeOf(result).toEqualTypeOf<[[1, 4], [2, 5], [3, 6]]>();
   });
 
@@ -164,8 +188,11 @@ describe("dataLast", () => {
     const array1: [1, 2, 3] = [1, 2, 3];
     const array2: [4, 5] = [4, 5];
     const result1 = pipe(array1, zip(array2));
+
     expectTypeOf(result1).toEqualTypeOf<[[1, 4], [2, 5]]>();
+
     const result2 = pipe(array2, zip(array1));
+
     expectTypeOf(result2).toEqualTypeOf<[[4, 1], [5, 2]]>();
   });
 
@@ -173,6 +200,7 @@ describe("dataLast", () => {
     const firstVariadic: [number, ...Array<string>] = [1, "b", "c"];
     const secondVariadic: [string, ...Array<number>] = ["a", 2, 3];
     const result = pipe(firstVariadic, zip(secondVariadic));
+
     expectTypeOf(result).toEqualTypeOf<
       [[number, string], ...Array<[string, number]>]
     >();
diff --git a/src/zipWith.test-d.ts b/src/zipWith.test-d.ts
index 46d427e..2e0c2b4 100644
--- a/src/zipWith.test-d.ts
+++ b/src/zipWith.test-d.ts
@@ -7,6 +7,7 @@ test("data first typings", () => {
     ["a", "b", "c"],
     (a, b) => `${a}${b}`,
   );
+
   expectTypeOf(actual).toEqualTypeOf<Array<string>>();
 });
 
@@ -15,6 +16,7 @@ test("data second typings", () => {
     ["1", "2", "3"],
     ["a", "b", "c"],
   );
+
   expectTypeOf(actual).toEqualTypeOf<Array<string>>();
 });
 
@@ -23,5 +25,6 @@ test("data second with initial arg typings", () => {
     ["1", "2", "3"],
     zipWith(["a", "b", "c"], (a, b) => `${a}${b}`),
   );
+
   expectTypeOf(actual).toEqualTypeOf<Array<string>>();
 });