Repository: karen-irc/option-t
Pull request #1030 (2021-06-05 18:19:22)

Rewrite the test to exported items 


Patch:
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 4834467a..71190709 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -13,7 +13,8 @@ updates:
       versioning-strategy: increase
       ignore:
           - dependency-name: typescript
-            update-types: ["version-update:semver-major", "version-update:semver-minor"]
+            versions:
+                - ">=4.2"
 
     - package-ecosystem: github-actions
       directory: "/"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e10874e0..eb63fbaf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,7 +39,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -69,7 +69,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -100,7 +100,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -131,7 +131,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -163,7 +163,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -195,7 +195,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -227,7 +227,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
@@ -259,7 +259,7 @@ jobs:
               run: echo "::set-output name=dir::$(yarn cache dir)"
             - name: Restore dependencies from cache
               id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-              uses: actions/cache@v2.1.6
+              uses: actions/cache@v2.1.5
               with:
                   path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
                   key: v0-${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
diff --git a/Makefile b/Makefile
index 2a63e539..a944fee9 100644
--- a/Makefile
+++ b/Makefile
@@ -193,7 +193,7 @@ test_distribution_contain_all: distribution
 
 .PHONY: run_test_distribution_contain_all
 run_test_distribution_contain_all:
-	OUTDIR=$(DIST_DIR) $(NODE_BIN) $(CURDIR)/tools/pkg_files_tester.mjs
+	OUTDIR=$(DIST_DIR) $(NODE_BIN) $(CURDIR)/tools/test_package_contains_expected_all.mjs
 
 .PHONY: test_esmodule_path_rewrite
 test_esmodule_path_rewrite: distribution
@@ -201,7 +201,7 @@ test_esmodule_path_rewrite: distribution
 
 .PHONY: run_test_esmodule_path_rewrite
 run_test_esmodule_path_rewrite:
-	OUTDIR=$(DIST_DIR) $(NODE_BIN) $(CURDIR)/tools/esmodule_path_rewrite_tester.mjs
+	OUTDIR=$(DIST_DIR) $(NODE_BIN) $(CURDIR)/tools/test_esmodule_path_rewrite.mjs
 
 .PHONY: test_package_install
 test_package_install: distribution __run_install_package
@@ -214,7 +214,7 @@ __run_install_package: distribution
 
 .PHONY: run_test_package_install
 run_test_package_install:
-	$(NODE_BIN) $(CURDIR)/tools/package_export_tester.mjs
+	$(NODE_BIN) $(CURDIR)/tools/test_package_exports.mjs
 
 .PHONY: post_cleanup_to_test_package_install
 post_cleanup_to_test_package_install:
diff --git a/package.json b/package.json
index 9bf5ce74..29d74f25 100644
--- a/package.json
+++ b/package.json
@@ -55,8 +55,8 @@
     "@ava/babel": "^1.0.1",
     "@babel/cli": "^7.14.3",
     "@babel/core": "^7.14.3",
-    "@babel/preset-env": "^7.14.4",
-    "@typescript-eslint/eslint-plugin": "^4.25.0",
+    "@babel/preset-env": "^7.14.2",
+    "@typescript-eslint/eslint-plugin": "^4.23.0",
     "@typescript-eslint/parser": "^4.25.0",
     "ava": "^3.15.0",
     "cpx": "^1.5.0",
diff --git a/tools/generate_import_path_list_markdown.mjs b/tools/generate_import_path_list_markdown.mjs
index ee589d99..1e7df013 100644
--- a/tools/generate_import_path_list_markdown.mjs
+++ b/tools/generate_import_path_list_markdown.mjs
@@ -3,17 +3,20 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 
+import {
+    generateExposedPathSequence,
+} from './public_api/mod.mjs';
+
+
 const THIS_FILE_NAME = fileURLToPath(import.meta.url);
 const THIS_DIR_NAME = path.dirname(THIS_FILE_NAME);
 
 const RELATIVE_PATH_TO_SRC_DIR = '../src';
 
 const FILENAME = 'public_api_list.md';
-const API_DEFINITIONS_PATH = './public_api.mjs';
 
 const PKG_NAME = 'option-t';
 
-
 class ListItem {
     constructor(key, subpath, extension = 'ts') {
         this._key = key;
@@ -27,7 +30,7 @@ class ListItem {
 
     href() {
         const subpath = this._subpath;
-        if (subpath === undefined) {
+        if (!subpath) {
             return this._key;
         }
 
@@ -120,8 +123,14 @@ ${str}
         assert.strictEqual(actual, expected, `SRC_DIR (${actual}) should be ${expected}`);
     }
 
-    const table = await import(API_DEFINITIONS_PATH).then((mod) => mod.default);
-    const list = Object.entries(table).map(([key, { path }]) => new ListItem(key, path));
+    const apiList = generateExposedPathSequence();
+    const list = Array.from(apiList)
+        .map((pathItem) => {
+            const key = pathItem.name();
+            const path = pathItem.path();
+            const item = new ListItem(key, path);
+            return item;
+        });
 
     const sectionList = categorize(list);
 
diff --git a/tools/package_json_rewriter/transformer/add_exports_field/compatibility.mjs b/tools/package_json_rewriter/transformer/add_exports_field/compatibility.mjs
index 157b4508..738a6964 100644
--- a/tools/package_json_rewriter/transformer/add_exports_field/compatibility.mjs
+++ b/tools/package_json_rewriter/transformer/add_exports_field/compatibility.mjs
@@ -1,43 +1,22 @@
-import { loadJSON } from '../../json.mjs';
+import * as assert from 'assert';
 
 const SHOULD_EXPOSE_LIB = true;
 
-function filterJSDir(histricalPathInfo) {
-    const result = [];
-    for (const [filepath, info] of Object.entries(histricalPathInfo)) {
-        if (!SHOULD_EXPOSE_LIB) {
-            if ((/^lib\//u).test(filepath)) {
+export function addHistoricalPathToExportsFields(o, histricalJSPathSeq) {
+    // https://nodejs.org/api/esm.html
+    for (const entry of histricalJSPathSeq) {
+        assert.ok(entry.isForCompat());
+        if (entry.isLib()) {
+            if (!SHOULD_EXPOSE_LIB) {
                 continue;
             }
         }
 
-        if (!!info && info.private) {
-            continue;
-        }
-
-        if (!(/^(cjs|esm|lib)\//u).test(filepath)) {
-            continue;
-        }
-
-        if (!(/^.+\.(js|mjs|cjs)$/u).test(filepath)) {
+        if (!entry.hasExtension()) {
             continue;
         }
 
-        result.push(filepath);
-    }
-
-    return result;
-}
-
-export async function loadHistoricalPathInfo(baseDir, filename) {
-    const histricalPathInfo = await loadJSON(baseDir, filename);
-    const histricalJSPathList = filterJSDir(histricalPathInfo);
-    return histricalJSPathList;
-}
-
-export function addHistoricalPathToExportsFields(o, histricalJSPathList) {
-    // https://nodejs.org/api/esm.html
-    for (const file of histricalJSPathList) {
+        const file = entry.name();
         const filepath = `./${file}`;
         // eslint-disable-next-line no-param-reassign
         o[filepath] = filepath;
diff --git a/tools/package_json_rewriter/transformer/add_exports_field/main.mjs b/tools/package_json_rewriter/transformer/add_exports_field/main.mjs
index f2644703..05a7d436 100644
--- a/tools/package_json_rewriter/transformer/add_exports_field/main.mjs
+++ b/tools/package_json_rewriter/transformer/add_exports_field/main.mjs
@@ -1,8 +1,9 @@
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+import {
+    generateLegacyExposedPathSequence,
+    generateExposedPathSequence,
+} from '../../../public_api/mod.mjs';
 
 import {
-    loadHistoricalPathInfo,
     addHistoricalPathToExportsFields,
 } from './compatibility.mjs';
 import {
@@ -10,18 +11,14 @@ import {
     addPublicAPIToExportsFields,
 } from './public_api.mjs';
 
-const THIS_FILENAME = fileURLToPath(import.meta.url);
-const THIS_DIRNAME = dirname(THIS_FILENAME);
-
-const BASE_DIR = THIS_DIRNAME;
-
 export async function addExportsFields(json) {
     const o = Object.create(null);
 
-    const histricalJSPathList = await loadHistoricalPathInfo(BASE_DIR, '../../../pkg_files.json');
-    addHistoricalPathToExportsFields(o, histricalJSPathList);
+    const historicalPathSeq = generateLegacyExposedPathSequence();
+    addHistoricalPathToExportsFields(o, historicalPathSeq);
 
-    const publicApiList = await loadPublicAPIDefinitions(BASE_DIR, '../../../public_api.mjs');
+    const publicApiSourceSeq = generateExposedPathSequence();
+    const publicApiList = loadPublicAPIDefinitions(publicApiSourceSeq);
     await addPublicAPIToExportsFields(o, publicApiList);
 
     // eslint-disable-next-line no-param-reassign
diff --git a/tools/package_json_rewriter/transformer/add_exports_field/public_api.mjs b/tools/package_json_rewriter/transformer/add_exports_field/public_api.mjs
index c5de9ef4..d78866cd 100644
--- a/tools/package_json_rewriter/transformer/add_exports_field/public_api.mjs
+++ b/tools/package_json_rewriter/transformer/add_exports_field/public_api.mjs
@@ -1,8 +1,7 @@
 import * as assert from 'assert';
-import * as path from 'path';
 
 class ExportEntity {
-    constructor(key, path = undefined) {
+    constructor(key, path) {
         assert.strictEqual(key.startsWith('/'), false, `key (${key}) should not start with /`);
         assert.strictEqual(key.endsWith('/'), false, `key (${key}) should not end with /`);
 
@@ -22,7 +21,7 @@ class ExportEntity {
     }
 
     toJSON() {
-        const p = this._path !== undefined ? this._path : this._key;
+        const p = this._path !== null ? this._path : this._key;
 
         const esm = `./esm/${p}.mjs`;
         const cjs = `./cjs/${p}.js`;
@@ -40,13 +39,14 @@ class ExportEntity {
     }
 }
 
-export async function loadPublicAPIDefinitions(baseDir, filepath) {
-    const p = path.resolve(baseDir, filepath);
-    const publicApiTestCases = await import(p).then((obj) => obj.default);
+export function loadPublicAPIDefinitions(seq) {
     const EXPORT_ENTRIES = [];
-    for (const [key, value] of Object.entries(publicApiTestCases)) {
-        const path = value.path;
-        const entry = new ExportEntity(key, path);
+    for (const item of seq) {
+        assert.ok(!item.isForCompat());
+
+        const name = item.name();
+        const path = item.path();
+        const entry = new ExportEntity(name, path);
         EXPORT_ENTRIES.push(entry);
     }
 
diff --git a/tools/pkg_files.json b/tools/pkg_files.json
index bea07b30..9e9b85d9 100644
--- a/tools/pkg_files.json
+++ b/tools/pkg_files.json
@@ -3,54 +3,22 @@
     "CHANGELOG_OLD.md": null,
     "LICENSE.MIT": null,
     "README.md": null,
-    "cjs/ClassOption/ClassicOption.d.ts": {
-        "private": true
-    },
-    "cjs/ClassOption/ClassicOption.js": {
-        "private": true
-    },
-    "cjs/ClassOption/compat.d.ts": {
-        "private": true
-    },
-    "cjs/ClassOption/compat.js": {
-        "private": true
-    },
-    "cjs/ClassResult/ClassicResult.d.ts": {
-        "private": true
-    },
-    "cjs/ClassResult/ClassicResult.js": {
-        "private": true
-    },
-    "cjs/ClassResult/compat.d.ts": {
-        "private": true
-    },
-    "cjs/ClassResult/compat.js": {
-        "private": true
-    },
-    "cjs/internal/assert.d.ts": {
-        "private": true
-    },
-    "cjs/internal/assert.js": {
-        "private": true
-    },
-    "cjs/internal/ErrorMessage.d.ts": {
-        "private": true
-    },
-    "cjs/internal/ErrorMessage.js": {
-        "private": true
-    },
-    "cjs/internal/Function.d.ts": {
-        "private": true
-    },
-    "cjs/internal/Function.js": {
-        "private": true
-    },
-    "cjs/internal/Mutable.d.ts": {
-        "private": true
-    },
-    "cjs/internal/Mutable.js": {
-        "private": true
-    },
+    "cjs/ClassOption/ClassicOption.d.ts": null,
+    "cjs/ClassOption/ClassicOption.js": null,
+    "cjs/ClassOption/compat.d.ts": null,
+    "cjs/ClassOption/compat.js": null,
+    "cjs/ClassResult/ClassicResult.d.ts": null,
+    "cjs/ClassResult/ClassicResult.js": null,
+    "cjs/ClassResult/compat.d.ts": null,
+    "cjs/ClassResult/compat.js": null,
+    "cjs/internal/assert.d.ts": null,
+    "cjs/internal/assert.js": null,
+    "cjs/internal/ErrorMessage.d.ts": null,
+    "cjs/internal/ErrorMessage.js": null,
+    "cjs/internal/Function.d.ts": null,
+    "cjs/internal/Function.js": null,
+    "cjs/internal/Mutable.d.ts": null,
+    "cjs/internal/Mutable.js": null,
     "cjs/Maybe/ErrorMessage.d.ts": null,
     "cjs/Maybe/ErrorMessage.js": null,
     "cjs/Maybe/Maybe.d.ts": null,
@@ -301,54 +269,22 @@
     "docs/idiom/README.md": null,
     "docs/public_api_list.md": null,
     "docs/wrapper_objects.md": null,
-    "esm/ClassOption/ClassicOption.d.ts": {
-        "private": true
-    },
-    "esm/ClassOption/ClassicOption.mjs": {
-        "private": true
-    },
-    "esm/ClassOption/compat.d.ts": {
-        "private": true
-    },
-    "esm/ClassOption/compat.mjs": {
-        "private": true
-    },
-    "esm/ClassResult/ClassicResult.d.ts": {
-        "private": true
-    },
-    "esm/ClassResult/ClassicResult.mjs": {
-        "private": true
-    },
-    "esm/ClassResult/compat.d.ts": {
-        "private": true
-    },
-    "esm/ClassResult/compat.mjs": {
-        "private": true
-    },
-    "esm/internal/assert.d.ts": {
-        "private": true
-    },
-    "esm/internal/assert.mjs": {
-        "private": true
-    },
-    "esm/internal/ErrorMessage.d.ts": {
-        "private": true
-    },
-    "esm/internal/ErrorMessage.mjs": {
-        "private": true
-    },
-    "esm/internal/Function.d.ts": {
-        "private": true
-    },
-    "esm/internal/Function.mjs": {
-        "private": true
-    },
-    "esm/internal/Mutable.d.ts": {
-        "private": true
-    },
-    "esm/internal/Mutable.mjs": {
-        "private": true
-    },
+    "esm/ClassOption/ClassicOption.d.ts": null,
+    "esm/ClassOption/ClassicOption.mjs": null,
+    "esm/ClassOption/compat.d.ts": null,
+    "esm/ClassOption/compat.mjs": null,
+    "esm/ClassResult/ClassicResult.d.ts": null,
+    "esm/ClassResult/ClassicResult.mjs": null,
+    "esm/ClassResult/compat.d.ts": null,
+    "esm/ClassResult/compat.mjs": null,
+    "esm/internal/assert.d.ts": null,
+    "esm/internal/assert.mjs": null,
+    "esm/internal/ErrorMessage.d.ts": null,
+    "esm/internal/ErrorMessage.mjs": null,
+    "esm/internal/Function.d.ts": null,
+    "esm/internal/Function.mjs": null,
+    "esm/internal/Mutable.d.ts": null,
+    "esm/internal/Mutable.mjs": null,
     "esm/Maybe/ErrorMessage.d.ts": null,
     "esm/Maybe/ErrorMessage.mjs": null,
     "esm/Maybe/Maybe.d.ts": null,
@@ -595,78 +531,30 @@
     "esm/shared/Function.mjs": null,
     "esm/shared/Mutable.d.ts": null,
     "esm/shared/Mutable.mjs": null,
-    "lib/ClassOption/ClassicOption.d.ts": {
-        "private": true
-    },
-    "lib/ClassOption/ClassicOption.js": {
-        "private": true
-    },
-    "lib/ClassOption/ClassicOption.mjs": {
-        "private": true
-    },
-    "lib/ClassOption/compat.d.ts": {
-        "private": true
-    },
-    "lib/ClassOption/compat.js": {
-        "private": true
-    },
-    "lib/ClassOption/compat.mjs": {
-        "private": true
-    },
-    "lib/ClassResult/ClassicResult.d.ts": {
-        "private": true
-    },
-    "lib/ClassResult/ClassicResult.js": {
-        "private": true
-    },
-    "lib/ClassResult/ClassicResult.mjs": {
-        "private": true
-    },
-    "lib/ClassResult/compat.d.ts": {
-        "private": true
-    },
-    "lib/ClassResult/compat.js": {
-        "private": true
-    },
-    "lib/ClassResult/compat.mjs": {
-        "private": true
-    },
-    "lib/internal/assert.d.ts": {
-        "private": true
-    },
-    "lib/internal/assert.js": {
-        "private": true
-    },
-    "lib/internal/assert.mjs": {
-        "private": true
-    },
-    "lib/internal/ErrorMessage.d.ts": {
-        "private": true
-    },
-    "lib/internal/ErrorMessage.js": {
-        "private": true
-    },
-    "lib/internal/ErrorMessage.mjs": {
-        "private": true
-    },
-    "lib/internal/Function.d.ts": {
-        "private": true
-    },
-    "lib/internal/Function.js": {
-        "private": true
-    },
-    "lib/internal/Function.mjs": {
-        "private": true
-    },
-    "lib/internal/Mutable.d.ts": {
-        "private": true
-    },
-    "lib/internal/Mutable.js": {
-        "private": true
-    },
-    "lib/internal/Mutable.mjs": {
-        "private": true
-    },
+    "lib/ClassOption/ClassicOption.d.ts": null,
+    "lib/ClassOption/ClassicOption.js": null,
+    "lib/ClassOption/ClassicOption.mjs": null,
+    "lib/ClassOption/compat.d.ts": null,
+    "lib/ClassOption/compat.js": null,
+    "lib/ClassOption/compat.mjs": null,
+    "lib/ClassResult/ClassicResult.d.ts": null,
+    "lib/ClassResult/ClassicResult.js": null,
+    "lib/ClassResult/ClassicResult.mjs": null,
+    "lib/ClassResult/compat.d.ts": null,
+    "lib/ClassResult/compat.js": null,
+    "lib/ClassResult/compat.mjs": null,
+    "lib/internal/assert.d.ts": null,
+    "lib/internal/assert.js": null,
+    "lib/internal/assert.mjs": null,
+    "lib/internal/ErrorMessage.d.ts": null,
+    "lib/internal/ErrorMessage.js": null,
+    "lib/internal/ErrorMessage.mjs": null,
+    "lib/internal/Function.d.ts": null,
+    "lib/internal/Function.js": null,
+    "lib/internal/Function.mjs": null,
+    "lib/internal/Mutable.d.ts": null,
+    "lib/internal/Mutable.js": null,
+    "lib/internal/Mutable.mjs": null,
     "lib/Maybe/ErrorMessage.d.ts": null,
     "lib/Maybe/ErrorMessage.js": null,
     "lib/Maybe/ErrorMessage.mjs": null,
diff --git a/tools/platform.mjs b/tools/platform.mjs
deleted file mode 100644
index aaff741a..00000000
--- a/tools/platform.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-import * as os from 'os';
-
-export function getSuffixedCommandName(command) {
-    const suffix = (os.platform() === 'win32') ? '.cmd' : '';
-    const name = command + suffix;
-    return name;
-}
diff --git a/tools/public_api.mjs b/tools/public_api.mjs
deleted file mode 100644
index 2af2be82..00000000
--- a/tools/public_api.mjs
+++ /dev/null
@@ -1,729 +0,0 @@
-export default {
-    '.': {
-        'path': 'index',
-        'exports': []
-    },
-
-    'Maybe': {
-        'path': 'Maybe/index',
-        'exports': [
-            'isNotNullAndUndefined',
-            'isNullOrUndefined',
-            'andThen',
-            'andThenAsync',
-            'expect',
-            'map',
-            'mapAsync',
-            'mapOr',
-            'mapOrAsync',
-            'mapOrElse',
-            'mapOrElseAsync',
-            'orElse',
-            'orElseAsync',
-            'tap',
-            'unwrap',
-            'unwrapOr',
-            'unwrapOrElse',
-            'unwrapOrElseAsync',
-        ]
-    },
-    'Maybe/and': {
-        'exports': [
-            'andForMaybe'
-        ]
-    },
-    'Maybe/andThen': {
-        'exports': [
-            'andThenForMaybe'
-        ]
-    },
-    'Maybe/andThenAsync': {
-        'exports': [
-            'andThenAsyncForMaybe'
-        ]
-    },
-    'Maybe/expect': {
-        'exports': [
-            'expectNotNullAndUndefined'
-        ]
-    },
-    'Maybe/map': {
-        'exports': [
-            'mapForMaybe'
-        ]
-    },
-    'Maybe/mapAsync': {
-        'exports': [
-            'mapAsyncForMaybe'
-        ]
-    },
-    'Maybe/Maybe': {
-        'exports': [
-            'isNotNullAndUndefined',
-            'isNullOrUndefined',
-        ]
-    },
-    'Maybe/mapOr': {
-        'exports': [
-            'mapOrForMaybe'
-        ]
-    },
-    'Maybe/mapOrAsync': {
-        'exports': [
-            'mapOrAsyncForMaybe'
-        ]
-    },
-    'Maybe/mapOrElse': {
-        'exports': [
-            'mapOrElseForMaybe'
-        ]
-    },
-    'Maybe/mapOrElseAsync': {
-        'exports': [
-            'mapOrElseAsyncForMaybe'
-        ]
-    },
-    'Maybe/or': {
-        'exports': [
-            'orForMaybe'
-        ]
-    },
-    'Maybe/orElse': {
-        'exports': [
-            'orElseForMaybe'
-        ]
-    },
-    'Maybe/orElseAsync': {
-        'exports': [
-            'orElseAsyncForMaybe'
-        ]
-    },
-    'Maybe/tap': {
-        'exports': [
-            'tapMaybe'
-        ]
-    },
-    'Maybe/unwrap': {
-        'exports': [
-            'unwrapMaybe'
-        ]
-    },
-    'Maybe/unwrapOr': {
-        'exports': [
-            'unwrapOrFromMaybe'
-        ]
-    },
-    'Maybe/unwrapOrElse': {
-        'exports': [
-            'unwrapOrElseFromMaybe'
-        ]
-    },
-    'Maybe/unwrapOrElseAsync': {
-        'exports': [
-            'unwrapOrElseAsyncFromMaybe'
-        ]
-    },
-    'Maybe/xor': {
-        'exports': [
-            'xorForMaybe'
-        ]
-    },
-
-    'Nullable': {
-        'path': 'Nullable/index',
-        'exports': [
-            'isNotNull',
-            'isNull',
-            'andThen',
-            'andThenAsync',
-            'expect',
-            'map',
-            'mapAsync',
-            'mapOr',
-            'mapOrAsync',
-            'mapOrElse',
-            'mapOrElseAsync',
-            'orElse',
-            'orElseAsync',
-            'tap',
-            'unwrap',
-            'unwrapOr',
-            'unwrapOrElse',
-            'unwrapOrElseAsync',
-        ]
-    },
-    'Nullable/and': {
-        'exports': [
-            'andForNullable',
-        ]
-    },
-    'Nullable/andThen': {
-        'exports': [
-            'andThenForNullable'
-        ]
-    },
-    'Nullable/andThenAsync': {
-        'exports': [
-            'andThenAsyncForNullable'
-        ]
-    },
-    'Nullable/expect': {
-        'exports': [
-            'expectNotNull',
-        ]
-    },
-    'Nullable/map': {
-        'exports': [
-            'mapForNullable'
-        ]
-    },
-    'Nullable/mapAsync': {
-        'exports': [
-            'mapAsyncForNullable'
-        ]
-    },
-    'Nullable/mapOr': {
-        'exports': [
-            'mapOrForNullable',
-        ]
-    },
-    'Nullable/mapOrAsync': {
-        'exports': [
-            'mapOrAsyncForNullable',
-        ]
-    },
-    'Nullable/mapOrElse': {
-        'exports': [
-            'mapOrElseForNullable'
-        ]
-    },
-    'Nullable/mapOrElseAsync': {
-        'exports': [
-            'mapOrElseAsyncForNullable'
-        ]
-    },
-    'Nullable/Nullable': {
-        'exports': [
-            'isNotNull',
-            'isNull',
-        ]
-    },
-    'Nullable/or': {
-        'exports': [
-            'orForNullable'
-        ]
-    },
-    'Nullable/orElse': {
-        'exports': [
-            'orElseForNullable'
-        ]
-    },
-    'Nullable/orElseAsync': {
-        'exports': [
-            'orElseAsyncForNullable'
-        ]
-    },
-    'Nullable/tap': {
-        'exports': [
-            'tapNullable'
-        ]
-    },
-    'Nullable/unwrap': {
-        'exports': [
-            'unwrapNullable'
-        ]
-    },
-    'Nullable/unwrapOr': {
-        'exports': [
-            'unwrapOrFromNullable'
-        ]
-    },
-    'Nullable/unwrapOrElse': {
-        'exports': [
-            'unwrapOrElseFromNullable'
-        ]
-    },
-    'Nullable/unwrapOrElseAsync': {
-        'exports': [
-            'unwrapOrElseAsyncFromNullable'
-        ]
-    },
-    'Nullable/xor': {
-        'exports': [
-            'xorForNullable'
-        ]
-    },
-
-    'PlainOption': {
-        'path': 'PlainOption/index',
-        'exports': [
-            'createSome',
-            'createNone',
-            'isSome',
-            'isNone',
-            'and',
-            'andThen',
-            'equal',
-            'expect',
-            'filter',
-            'flatten',
-            'map',
-            'mapAsync',
-            'mapOr',
-            'mapOrElse',
-            'or',
-            'orElse',
-            'transpose',
-            'tap',
-            'unwrap',
-            'unwrapOr',
-            'unwrapOrElse'
-        ]
-    },
-
-    'PlainOption/and': {
-        'exports': [
-            'andForOption'
-        ]
-    },
-    'PlainOption/andThen': {
-        'exports': [
-            'andThenForOption'
-        ]
-    },
-    'PlainOption/asMut': {
-        'exports': [
-            'asMutOption'
-        ]
-    },
-    'PlainOption/drop': {
-        'exports': [
-            'unsafeDropForOption'
-        ]
-    },
-    'PlainOption/equal': {
-        'exports': [
-            'equalForOption'
-        ]
-    },
-    'PlainOption/expect': {
-        'exports': [
-            'expectIsSome'
-        ]
-    },
-    'PlainOption/filter': {
-        'exports': [
-            'filterForOption',
-        ]
-    },
-    'PlainOption/flatten': {
-        'exports': [
-            'flattenForOption'
-        ]
-    },
-    'PlainOption/map': {
-        'exports': [
-            'mapForOption'
-        ]
-    },
-    'PlainOption/mapAsync': {
-        'exports': [
-            'mapAsyncForOption'
-        ]
-    },
-    'PlainOption/mapOr': {
-        'exports': [
-            'mapOrForOption'
-        ]
-    },
-    'PlainOption/mapOrElse': {
-        'exports': [
-            'mapOrElseForOption'
-        ]
-    },
-    'PlainOption/okOr': {
-        'exports': [
-            'okOrForPlainOption'
-        ]
-    },
-    'PlainOption/okOrElse': {
-        'exports': [
-            'okOrElseForPlainOption'
-        ]
-    },
-    'PlainOption/Option': {
-        'exports': [
-            'isSome',
-            'isNone',
-            'createSome',
-            'createNone'
-        ]
-    },
-    'PlainOption/or': {
-        'exports': [
-            'orForOption'
-        ]
-    },
-    'PlainOption/orElse': {
-        'exports': [
-            'orElseForOption'
-        ]
-    },
-    'PlainOption/transpose': {
-        'exports': [
-            'transposeForOption'
-        ]
-    },
-    'PlainOption/tap': {
-        'exports': [
-            'tapOption'
-        ]
-    },
-    'PlainOption/unwrap': {
-        'exports': [
-            'unwrapOption'
-        ]
-    },
-    'PlainOption/unwrapOr': {
-        'exports': [
-            'unwrapOrFromOption'
-        ]
-    },
-    'PlainOption/unwrapOrElse': {
-        'exports': [
-            'unwrapOrElseFromOption'
-        ]
-    },
-    'PlainOption/xor': {
-        'exports': [
-            'xorForOption'
-        ]
-    },
-
-    'PlainResult': {
-        'path': 'PlainResult/index',
-        'exports': [
-            'createOk',
-            'createErr',
-            'isOk',
-            'isErr',
-            'and',
-            'andThen',
-            'andThenAsync',
-            'equal',
-            'expect',
-            'expectErr',
-            'flatten',
-            'map',
-            'mapAsync',
-            'mapOr',
-            'mapOrAsync',
-            'mapOrElse',
-            'mapOrElseAsync',
-            'mapErr',
-            'mapErrAsync',
-            'or',
-            'orElse',
-            'orElseAsync',
-            'tapOk',
-            'tapErr',
-            'tapBoth',
-            'transpose',
-            'toOptionFromOk',
-            'toOptionFromErr',
-            'unwrap',
-            'unwrapErr',
-            'unwrapOr',
-            'unwrapOrElse',
-            'unwrapOrElseAsync',
-        ]
-    },
-
-
-    'PlainResult/and': {
-        'exports': [
-            'andForResult'
-        ]
-    },
-    'PlainResult/andThen': {
-        'exports': [
-            'andThenForResult'
-        ]
-    },
-    'PlainResult/andThenAsync': {
-        'exports': [
-            'andThenAsyncForResult'
-        ]
-    },
-    'PlainResult/asMut': {
-        'exports': [
-            'asMutResult'
-        ]
-    },
-    'PlainResult/drop': {
-        'exports': [
-            'unsafeDropBothForResult',
-            'unsafeDropOkForResult',
-            'unsafeDropErrForResult',
-        ]
-    },
-    'PlainResult/equal': {
-        'exports': [
-            'equalForResult',
-        ]
-    },
-    'PlainResult/expect': {
-        'exports': [
-            'expectIsOk',
-            'expectIsErr',
-        ]
-    },
-    'PlainResult/flatten': {
-        'exports': [
-            'flattenForResult'
-        ]
-    },
-    'PlainResult/map': {
-        'exports': [
-            'mapForResult'
-        ]
-    },
-    'PlainResult/mapAsync': {
-        'exports': [
-            'mapAsyncForResult'
-        ]
-    },
-    'PlainResult/mapErr': {
-        'exports': [
-            'mapErrForResult',
-        ]
-    },
-    'PlainResult/mapErrAsync': {
-        'exports': [
-            'mapErrAsyncForResult',
-        ]
-    },
-    'PlainResult/mapOr': {
-        'exports': [
-            'mapOrForResult'
-        ]
-    },
-    'PlainResult/mapOrAsync': {
-        'exports': [
-            'mapOrAsyncForResult'
-        ]
-    },
-    'PlainResult/mapOrElse': {
-        'exports': [
-            'mapOrElseForResult'
-        ]
-    },
-    'PlainResult/mapOrElseAsync': {
-        'exports': [
-            'mapOrElseAsyncForResult'
-        ]
-    },
-    'PlainResult/or': {
-        'exports': [
-            'orForResult'
-        ]
-    },
-    'PlainResult/orElse': {
-        'exports': [
-            'orElseForResult'
-        ]
-    },
-    'PlainResult/orElseAsync': {
-        'exports': [
-            'orElseAsyncForResult'
-        ]
-    },
-    'PlainResult/Result': {
-        'exports': [
-            'isOk',
-            'createOk',
-            'isErr',
-            'createErr'
-        ]
-    },
-    'PlainResult/tap': {
-        'exports': [
-            'tapOk',
-            'tapErr',
-            'tapBoth',
-        ]
-    },
-    'PlainResult/toOption': {
-        'exports': [
-            'toOptionFromOk',
-            'toOptionFromErr'
-        ]
-    },
-    'PlainResult/transpose': {
-        'exports': [
-            'transposeForResult',
-        ]
-    },
-    'PlainResult/unwrap': {
-        'exports': [
-            'unwrapFromResult',
-            'unwrapErrFromResult',
-        ]
-    },
-    'PlainResult/unwrapOr': {
-        'exports': [
-            'unwrapOrFromResult'
-        ]
-    },
-    'PlainResult/unwrapOrElse': {
-        'exports': [
-            'unwrapOrElseFromResult'
-        ]
-    },
-    'PlainResult/unwrapOrElseAsync': {
-        'exports': [
-            'unwrapOrElseAsyncFromResult'
-        ]
-    },
-
-    'Undefinable': {
-        'path': 'Undefinable/index',
-        'exports': [
-            'isNotUndefined',
-            'isUndefined',
-            'andThen',
-            'andThenAsync',
-            'expect',
-            'map',
-            'mapAsync',
-            'mapOr',
-            'mapOrAsync',
-            'mapOrElse',
-            'mapOrElseAsync',
-            'orElse',
-            'orElseAsync',
-            'tap',
-            'unwrap',
-            'unwrapOr',
-            'unwrapOrElse',
-            'unwrapOrElseAsync',
-        ]
-    },
-
-    'Undefinable/and': {
-        'exports': [
-            'andForUndefinable',
-        ]
-    },
-    'Undefinable/andThen': {
-        'exports': [
-            'andThenForUndefinable'
-        ]
-    },
-    'Undefinable/andThenAsync': {
-        'exports': [
-            'andThenAsyncForUndefinable'
-        ]
-    },
-    'Undefinable/expect': {
-        'exports': [
-            'expectNotUndefined'
-        ]
-    },
-    'Undefinable/map': {
-        'exports': [
-            'mapForUndefinable'
-        ]
-    },
-    'Undefinable/mapAsync': {
-        'exports': [
-            'mapAsyncForUndefinable'
-        ]
-    },
-    'Undefinable/mapOr': {
-        'exports': [
-            'mapOrForUndefinable'
-        ]
-    },
-    'Undefinable/mapOrAsync': {
-        'exports': [
-            'mapOrAsyncForUndefinable'
-        ]
-    },
-    'Undefinable/mapOrElse': {
-        'exports': [
-            'mapOrElseForUndefinable'
-        ]
-    },
-    'Undefinable/mapOrElseAsync': {
-        'exports': [
-            'mapOrElseAsyncForUndefinable'
-        ]
-    },
-    'Undefinable/or': {
-        'exports': [
-            'orForUndefinable'
-        ]
-    },
-    'Undefinable/orElse': {
-        'exports': [
-            'orElseForUndefinable'
-        ]
-    },
-    'Undefinable/orElseAsync': {
-        'exports': [
-            'orElseAsyncForUndefinable'
-        ]
-    },
-    'Undefinable/tap': {
-        'exports': [
-            'tapUndefinable'
-        ]
-    },
-    'Undefinable/Undefinable': {
-        'exports': [
-            'isNotUndefined',
-            'isUndefined',
-        ]
-    },
-    'Undefinable/unwrap': {
-        'exports': [
-            'unwrapUndefinable'
-        ]
-    },
-    'Undefinable/unwrapOr': {
-        'exports': [
-            'unwrapOrFromUndefinable'
-        ]
-    },
-    'Undefinable/unwrapOrElse': {
-        'exports': [
-            'unwrapOrElseFromUndefinable'
-        ]
-    },
-    'Undefinable/unwrapOrElseAsync': {
-        'exports': [
-            'unwrapOrElseAsyncFromUndefinable'
-        ]
-    },
-    'Undefinable/xor': {
-        'exports': [
-            'xorForUndefinable'
-        ]
-    },
-
-    /*
-        // TODO:
-        // 'Maybe/ErrorMessage': [],
-        // TODO:
-        // 'Nullable/ErrorMessage': [],
-        // TODO:
-        // 'Option': [],
-        // TODO:
-        // 'Result': [],
-        // TODO:
-        // 'Undefinable/ErrorMessage': [],
-        // TODO:
-        // 'index': [],
-    */
-};
diff --git a/tools/public_api/ExposedPath.mjs b/tools/public_api/ExposedPath.mjs
new file mode 100644
index 00000000..4e0b9797
--- /dev/null
+++ b/tools/public_api/ExposedPath.mjs
@@ -0,0 +1,90 @@
+import { apiTable, legacyApiTable } from './table.mjs';
+
+const PKG_NAME = 'option-t';
+
+export class ExposedPath {
+    constructor(key, raw) {
+        this._key = key;
+        this._raw = raw;
+        Object.freeze(this);
+    }
+
+    name() {
+        return this._key;
+    }
+
+    path() {
+        return this._raw.path ?? null;
+    }
+
+    getCalcPath() {
+        const raw = this.name();
+        if (raw === '.') {
+            return PKG_NAME;
+        }
+
+        const concat = `${PKG_NAME}/${raw}`;
+        return concat;
+    }
+
+    exports() {
+        return this._raw.exports ?? null;
+    }
+
+    isForCompat() {
+        return false;
+    }
+}
+
+export class QuirksLegacyExposedPath extends ExposedPath {
+    isForCompat() {
+        return true;
+    }
+
+    isESM() {
+        const name = this.name();
+        const isESM = /^esm\//u.test(name) || /\.mjs$/u.test(name);
+        return isESM;
+    }
+
+    isCJS() {
+        const name = this.name();
+        const isCJS = /^cjs\//u.test(name) || /\.js$/u.test(name);
+        return isCJS;
+    }
+
+    isLib() {
+        const name = this.name();
+        const ok = /^lib\//u.test(name);
+        return ok;
+    }
+
+    isLibButWithoutExtension() {
+        return this.isLib() && !this.hasExtension();
+    }
+
+    hasExtension() {
+        const name = this.name();
+        const has = /\.(js|mjs|cjs)$/u.test(name);
+        return has;
+    }
+}
+
+export function* generateExposedPathSequence() {
+    for (const [key, value] of Object.entries(apiTable)) {
+        const o = new ExposedPath(key, value);
+        yield o;
+    }
+}
+
+export function* generateLegacyExposedPathSequence() {
+    for (const [key, value] of Object.entries(legacyApiTable)) {
+        const o = new QuirksLegacyExposedPath(key, value);
+        yield o;
+    }
+}
+
+export function* generateAllExposedPathSequence() {
+    yield* generateExposedPathSequence();
+    yield* generateLegacyExposedPathSequence();
+}
diff --git a/tools/public_api/mod.mjs b/tools/public_api/mod.mjs
new file mode 100644
index 00000000..ea6d7d04
--- /dev/null
+++ b/tools/public_api/mod.mjs
@@ -0,0 +1,7 @@
+export {
+    generateExposedPathSequence,
+    generateAllExposedPathSequence,
+    generateLegacyExposedPathSequence,
+    ExposedPath,
+    QuirksLegacyExposedPath,
+} from './ExposedPath.mjs';
diff --git a/tools/public_api/table.mjs b/tools/public_api/table.mjs
new file mode 100644
index 00000000..fa500efc
--- /dev/null
+++ b/tools/public_api/table.mjs
@@ -0,0 +1,1611 @@
+export const apiTable = Object.freeze({
+    '.': {
+        'path': 'index',
+        'exports': []
+    },
+
+    'Maybe': {
+        'path': 'Maybe/index',
+        'exports': [
+            'isNotNullAndUndefined',
+            'isNullOrUndefined',
+            'andThen',
+            'andThenAsync',
+            'expect',
+            'map',
+            'mapAsync',
+            'mapOr',
+            'mapOrAsync',
+            'mapOrElse',
+            'mapOrElseAsync',
+            'orElse',
+            'orElseAsync',
+            'tap',
+            'unwrap',
+            'unwrapOr',
+            'unwrapOrElse',
+            'unwrapOrElseAsync',
+        ]
+    },
+    'Maybe/and': {
+        'exports': [
+            'andForMaybe'
+        ]
+    },
+    'Maybe/andThen': {
+        'exports': [
+            'andThenForMaybe'
+        ]
+    },
+    'Maybe/andThenAsync': {
+        'exports': [
+            'andThenAsyncForMaybe'
+        ]
+    },
+    'Maybe/expect': {
+        'exports': [
+            'expectNotNullAndUndefined'
+        ]
+    },
+    'Maybe/map': {
+        'exports': [
+            'mapForMaybe'
+        ]
+    },
+    'Maybe/mapAsync': {
+        'exports': [
+            'mapAsyncForMaybe'
+        ]
+    },
+    'Maybe/Maybe': {
+        'exports': [
+            'isNotNullAndUndefined',
+            'isNullOrUndefined',
+        ]
+    },
+    'Maybe/mapOr': {
+        'exports': [
+            'mapOrForMaybe'
+        ]
+    },
+    'Maybe/mapOrAsync': {
+        'exports': [
+            'mapOrAsyncForMaybe'
+        ]
+    },
+    'Maybe/mapOrElse': {
+        'exports': [
+            'mapOrElseForMaybe'
+        ]
+    },
+    'Maybe/mapOrElseAsync': {
+        'exports': [
+            'mapOrElseAsyncForMaybe'
+        ]
+    },
+    'Maybe/or': {
+        'exports': [
+            'orForMaybe'
+        ]
+    },
+    'Maybe/orElse': {
+        'exports': [
+            'orElseForMaybe'
+        ]
+    },
+    'Maybe/orElseAsync': {
+        'exports': [
+            'orElseAsyncForMaybe'
+        ]
+    },
+    'Maybe/tap': {
+        'exports': [
+            'tapMaybe'
+        ]
+    },
+    'Maybe/unwrap': {
+        'exports': [
+            'unwrapMaybe'
+        ]
+    },
+    'Maybe/unwrapOr': {
+        'exports': [
+            'unwrapOrFromMaybe'
+        ]
+    },
+    'Maybe/unwrapOrElse': {
+        'exports': [
+            'unwrapOrElseFromMaybe'
+        ]
+    },
+    'Maybe/unwrapOrElseAsync': {
+        'exports': [
+            'unwrapOrElseAsyncFromMaybe'
+        ]
+    },
+    'Maybe/xor': {
+        'exports': [
+            'xorForMaybe'
+        ]
+    },
+
+    'Nullable': {
+        'path': 'Nullable/index',
+        'exports': [
+            'isNotNull',
+            'isNull',
+            'andThen',
+            'andThenAsync',
+            'expect',
+            'map',
+            'mapAsync',
+            'mapOr',
+            'mapOrAsync',
+            'mapOrElse',
+            'mapOrElseAsync',
+            'orElse',
+            'orElseAsync',
+            'tap',
+            'unwrap',
+            'unwrapOr',
+            'unwrapOrElse',
+            'unwrapOrElseAsync',
+        ]
+    },
+    'Nullable/and': {
+        'exports': [
+            'andForNullable',
+        ]
+    },
+    'Nullable/andThen': {
+        'exports': [
+            'andThenForNullable'
+        ]
+    },
+    'Nullable/andThenAsync': {
+        'exports': [
+            'andThenAsyncForNullable'
+        ]
+    },
+    'Nullable/expect': {
+        'exports': [
+            'expectNotNull',
+        ]
+    },
+    'Nullable/map': {
+        'exports': [
+            'mapForNullable'
+        ]
+    },
+    'Nullable/mapAsync': {
+        'exports': [
+            'mapAsyncForNullable'
+        ]
+    },
+    'Nullable/mapOr': {
+        'exports': [
+            'mapOrForNullable',
+        ]
+    },
+    'Nullable/mapOrAsync': {
+        'exports': [
+            'mapOrAsyncForNullable',
+        ]
+    },
+    'Nullable/mapOrElse': {
+        'exports': [
+            'mapOrElseForNullable'
+        ]
+    },
+    'Nullable/mapOrElseAsync': {
+        'exports': [
+            'mapOrElseAsyncForNullable'
+        ]
+    },
+    'Nullable/Nullable': {
+        'exports': [
+            'isNotNull',
+            'isNull',
+        ]
+    },
+    'Nullable/or': {
+        'exports': [
+            'orForNullable'
+        ]
+    },
+    'Nullable/orElse': {
+        'exports': [
+            'orElseForNullable'
+        ]
+    },
+    'Nullable/orElseAsync': {
+        'exports': [
+            'orElseAsyncForNullable'
+        ]
+    },
+    'Nullable/tap': {
+        'exports': [
+            'tapNullable'
+        ]
+    },
+    'Nullable/unwrap': {
+        'exports': [
+            'unwrapNullable'
+        ]
+    },
+    'Nullable/unwrapOr': {
+        'exports': [
+            'unwrapOrFromNullable'
+        ]
+    },
+    'Nullable/unwrapOrElse': {
+        'exports': [
+            'unwrapOrElseFromNullable'
+        ]
+    },
+    'Nullable/unwrapOrElseAsync': {
+        'exports': [
+            'unwrapOrElseAsyncFromNullable'
+        ]
+    },
+    'Nullable/xor': {
+        'exports': [
+            'xorForNullable'
+        ]
+    },
+
+    'PlainOption': {
+        'path': 'PlainOption/index',
+        'exports': [
+            'createSome',
+            'createNone',
+            'isSome',
+            'isNone',
+            'and',
+            'andThen',
+            'equal',
+            'expect',
+            'filter',
+            'flatten',
+            'map',
+            'mapAsync',
+            'mapOr',
+            'mapOrElse',
+            'or',
+            'orElse',
+            'transpose',
+            'tap',
+            'unwrap',
+            'unwrapOr',
+            'unwrapOrElse'
+        ]
+    },
+
+    'PlainOption/and': {
+        'exports': [
+            'andForOption'
+        ]
+    },
+    'PlainOption/andThen': {
+        'exports': [
+            'andThenForOption'
+        ]
+    },
+    'PlainOption/asMut': {
+        'exports': [
+            'asMutOption'
+        ]
+    },
+    'PlainOption/drop': {
+        'exports': [
+            'unsafeDropForOption'
+        ]
+    },
+    'PlainOption/equal': {
+        'exports': [
+            'equalForOption'
+        ]
+    },
+    'PlainOption/expect': {
+        'exports': [
+            'expectIsSome'
+        ]
+    },
+    'PlainOption/filter': {
+        'exports': [
+            'filterForOption',
+        ]
+    },
+    'PlainOption/flatten': {
+        'exports': [
+            'flattenForOption'
+        ]
+    },
+    'PlainOption/map': {
+        'exports': [
+            'mapForOption'
+        ]
+    },
+    'PlainOption/mapAsync': {
+        'exports': [
+            'mapAsyncForOption'
+        ]
+    },
+    'PlainOption/mapOr': {
+        'exports': [
+            'mapOrForOption'
+        ]
+    },
+    'PlainOption/mapOrElse': {
+        'exports': [
+            'mapOrElseForOption'
+        ]
+    },
+    'PlainOption/okOr': {
+        'exports': [
+            'okOrForPlainOption'
+        ]
+    },
+    'PlainOption/okOrElse': {
+        'exports': [
+            'okOrElseForPlainOption'
+        ]
+    },
+    'PlainOption/Option': {
+        'exports': [
+            'isSome',
+            'isNone',
+            'createSome',
+            'createNone'
+        ]
+    },
+    'PlainOption/or': {
+        'exports': [
+            'orForOption'
+        ]
+    },
+    'PlainOption/orElse': {
+        'exports': [
+            'orElseForOption'
+        ]
+    },
+    'PlainOption/transpose': {
+        'exports': [
+            'transposeForOption'
+        ]
+    },
+    'PlainOption/tap': {
+        'exports': [
+            'tapOption'
+        ]
+    },
+    'PlainOption/unwrap': {
+        'exports': [
+            'unwrapOption'
+        ]
+    },
+    'PlainOption/unwrapOr': {
+        'exports': [
+            'unwrapOrFromOption'
+        ]
+    },
+    'PlainOption/unwrapOrElse': {
+        'exports': [
+            'unwrapOrElseFromOption'
+        ]
+    },
+    'PlainOption/xor': {
+        'exports': [
+            'xorForOption'
+        ]
+    },
+
+    'PlainResult': {
+        'path': 'PlainResult/index',
+        'exports': [
+            'createOk',
+            'createErr',
+            'isOk',
+            'isErr',
+            'and',
+            'andThen',
+            'andThenAsync',
+            'equal',
+            'expect',
+            'expectErr',
+            'flatten',
+            'map',
+            'mapAsync',
+            'mapOr',
+            'mapOrAsync',
+            'mapOrElse',
+            'mapOrElseAsync',
+            'mapErr',
+            'mapErrAsync',
+            'or',
+            'orElse',
+            'orElseAsync',
+            'tapOk',
+            'tapErr',
+            'tapBoth',
+            'transpose',
+            'toOptionFromOk',
+            'toOptionFromErr',
+            'unwrap',
+            'unwrapErr',
+            'unwrapOr',
+            'unwrapOrElse',
+            'unwrapOrElseAsync',
+        ]
+    },
+
+
+    'PlainResult/and': {
+        'exports': [
+            'andForResult'
+        ]
+    },
+    'PlainResult/andThen': {
+        'exports': [
+            'andThenForResult'
+        ]
+    },
+    'PlainResult/andThenAsync': {
+        'exports': [
+            'andThenAsyncForResult'
+        ]
+    },
+    'PlainResult/asMut': {
+        'exports': [
+            'asMutResult'
+        ]
+    },
+    'PlainResult/drop': {
+        'exports': [
+            'unsafeDropBothForResult',
+            'unsafeDropOkForResult',
+            'unsafeDropErrForResult',
+        ]
+    },
+    'PlainResult/equal': {
+        'exports': [
+            'equalForResult',
+        ]
+    },
+    'PlainResult/expect': {
+        'exports': [
+            'expectIsOk',
+            'expectIsErr',
+        ]
+    },
+    'PlainResult/flatten': {
+        'exports': [
+            'flattenForResult'
+        ]
+    },
+    'PlainResult/map': {
+        'exports': [
+            'mapForResult'
+        ]
+    },
+    'PlainResult/mapAsync': {
+        'exports': [
+            'mapAsyncForResult'
+        ]
+    },
+    'PlainResult/mapErr': {
+        'exports': [
+            'mapErrForResult',
+        ]
+    },
+    'PlainResult/mapErrAsync': {
+        'exports': [
+            'mapErrAsyncForResult',
+        ]
+    },
+    'PlainResult/mapOr': {
+        'exports': [
+            'mapOrForResult'
+        ]
+    },
+    'PlainResult/mapOrAsync': {
+        'exports': [
+            'mapOrAsyncForResult'
+        ]
+    },
+    'PlainResult/mapOrElse': {
+        'exports': [
+            'mapOrElseForResult'
+        ]
+    },
+    'PlainResult/mapOrElseAsync': {
+        'exports': [
+            'mapOrElseAsyncForResult'
+        ]
+    },
+    'PlainResult/or': {
+        'exports': [
+            'orForResult'
+        ]
+    },
+    'PlainResult/orElse': {
+        'exports': [
+            'orElseForResult'
+        ]
+    },
+    'PlainResult/orElseAsync': {
+        'exports': [
+            'orElseAsyncForResult'
+        ]
+    },
+    'PlainResult/Result': {
+        'exports': [
+            'isOk',
+            'createOk',
+            'isErr',
+            'createErr'
+        ]
+    },
+    'PlainResult/tap': {
+        'exports': [
+            'tapOk',
+            'tapErr',
+            'tapBoth',
+        ]
+    },
+    'PlainResult/toOption': {
+        'exports': [
+            'toOptionFromOk',
+            'toOptionFromErr'
+        ]
+    },
+    'PlainResult/transpose': {
+        'exports': [
+            'transposeForResult',
+        ]
+    },
+    'PlainResult/unwrap': {
+        'exports': [
+            'unwrapFromResult',
+            'unwrapErrFromResult',
+        ]
+    },
+    'PlainResult/unwrapOr': {
+        'exports': [
+            'unwrapOrFromResult'
+        ]
+    },
+    'PlainResult/unwrapOrElse': {
+        'exports': [
+            'unwrapOrElseFromResult'
+        ]
+    },
+    'PlainResult/unwrapOrElseAsync': {
+        'exports': [
+            'unwrapOrElseAsyncFromResult'
+        ]
+    },
+
+    'Undefinable': {
+        'path': 'Undefinable/index',
+        'exports': [
+            'isNotUndefined',
+            'isUndefined',
+            'andThen',
+            'andThenAsync',
+            'expect',
+            'map',
+            'mapAsync',
+            'mapOr',
+            'mapOrAsync',
+            'mapOrElse',
+            'mapOrElseAsync',
+            'orElse',
+            'orElseAsync',
+            'tap',
+            'unwrap',
+            'unwrapOr',
+            'unwrapOrElse',
+            'unwrapOrElseAsync',
+        ]
+    },
+
+    'Undefinable/and': {
+        'exports': [
+            'andForUndefinable',
+        ]
+    },
+    'Undefinable/andThen': {
+        'exports': [
+            'andThenForUndefinable'
+        ]
+    },
+    'Undefinable/andThenAsync': {
+        'exports': [
+            'andThenAsyncForUndefinable'
+        ]
+    },
+    'Undefinable/expect': {
+        'exports': [
+            'expectNotUndefined'
+        ]
+    },
+    'Undefinable/map': {
+        'exports': [
+            'mapForUndefinable'
+        ]
+    },
+    'Undefinable/mapAsync': {
+        'exports': [
+            'mapAsyncForUndefinable'
+        ]
+    },
+    'Undefinable/mapOr': {
+        'exports': [
+            'mapOrForUndefinable'
+        ]
+    },
+    'Undefinable/mapOrAsync': {
+        'exports': [
+            'mapOrAsyncForUndefinable'
+        ]
+    },
+    'Undefinable/mapOrElse': {
+        'exports': [
+            'mapOrElseForUndefinable'
+        ]
+    },
+    'Undefinable/mapOrElseAsync': {
+        'exports': [
+            'mapOrElseAsyncForUndefinable'
+        ]
+    },
+    'Undefinable/or': {
+        'exports': [
+            'orForUndefinable'
+        ]
+    },
+    'Undefinable/orElse': {
+        'exports': [
+            'orElseForUndefinable'
+        ]
+    },
+    'Undefinable/orElseAsync': {
+        'exports': [
+            'orElseAsyncForUndefinable'
+        ]
+    },
+    'Undefinable/tap': {
+        'exports': [
+            'tapUndefinable'
+        ]
+    },
+    'Undefinable/Undefinable': {
+        'exports': [
+            'isNotUndefined',
+            'isUndefined',
+        ]
+    },
+    'Undefinable/unwrap': {
+        'exports': [
+            'unwrapUndefinable'
+        ]
+    },
+    'Undefinable/unwrapOr': {
+        'exports': [
+            'unwrapOrFromUndefinable'
+        ]
+    },
+    'Undefinable/unwrapOrElse': {
+        'exports': [
+            'unwrapOrElseFromUndefinable'
+        ]
+    },
+    'Undefinable/unwrapOrElseAsync': {
+        'exports': [
+            'unwrapOrElseAsyncFromUndefinable'
+        ]
+    },
+    'Undefinable/xor': {
+        'exports': [
+            'xorForUndefinable'
+        ]
+    },
+
+    /*
+        // TODO:
+        // 'Maybe/ErrorMessage': [],
+        // TODO:
+        // 'Nullable/ErrorMessage': [],
+        // TODO:
+        // 'Option': [],
+        // TODO:
+        // 'Result': [],
+        // TODO:
+        // 'Undefinable/ErrorMessage': [],
+        // TODO:
+        // 'index': [],
+    */
+});
+
+const COMPAT_DESCRIPTOR = Object.freeze({
+});
+
+export const legacyApiTable = Object.freeze({
+    'cjs/Maybe/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/ErrorMessage': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/Maybe.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/Maybe': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/and.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/and': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/andThen.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/andThen': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/andThenAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/expect.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/expect': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/index.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/index': COMPAT_DESCRIPTOR,
+    'cjs/Maybe': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/map.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/map': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOr': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/or.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/or': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/orElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/orElse': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/orElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/tap.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/tap': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrap.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrap': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOr': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/xor.js': COMPAT_DESCRIPTOR,
+    'cjs/Maybe/xor': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/Nullable.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/Nullable': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/and.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/and': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/andThen.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/andThen': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/andThenAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/expect.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/expect': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/index.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/index': COMPAT_DESCRIPTOR,
+    'cjs/Nullable': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/map.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/map': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOr': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/or.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/or': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/orElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/orElse': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/orElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/tap.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/tap': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrap.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrap': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOr': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/xor.js': COMPAT_DESCRIPTOR,
+    'cjs/Nullable/xor': COMPAT_DESCRIPTOR,
+    'cjs/Option.js': COMPAT_DESCRIPTOR,
+    'cjs/Option': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/Option.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/Option': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/and.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/and': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/andThen.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/andThen': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/asMut.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/asMut': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/drop.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/drop': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/equal.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/equal': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/expect.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/expect': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/filter.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/filter': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/flatten.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/flatten': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/index.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/index': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/map.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/map': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapOr': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/mapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/okOr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/okOr': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/okOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/okOrElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/or.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/or': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/orElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/orElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/transpose.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/transpose': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/tap.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/tap': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrap.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrap': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrapOr': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/xor.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainOption/xor': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/Result.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/Result': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/and.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/and': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/andThen.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/andThen': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/andThenAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/asMut.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/asMut': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/drop.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/drop': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/equal.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/equal': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/expect.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/expect': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/flatten.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/flatten': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/index.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/index': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/map.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/map': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapErr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapErr': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapErrAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapErrAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOr': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/or.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/or': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/orElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/orElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/orElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/tap.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/tap': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/transpose.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/transpose': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/toOption.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/toOption': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrap.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrap': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOr': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/PlainResult/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Result.js': COMPAT_DESCRIPTOR,
+    'cjs/Result': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/Undefinable.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/Undefinable': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/and.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/and': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/andThen.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/andThen': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/andThenAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/expect.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/expect': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/index.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/index': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/map.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/map': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOr': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/or.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/or': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/orElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/orElse': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/orElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/tap.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/tap': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrap.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrap': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOr': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/xor.js': COMPAT_DESCRIPTOR,
+    'cjs/Undefinable/xor': COMPAT_DESCRIPTOR,
+    'cjs/index.js': COMPAT_DESCRIPTOR,
+    'cjs/index': COMPAT_DESCRIPTOR,
+    'cjs/shared/Function.js': COMPAT_DESCRIPTOR,
+    'cjs/shared/Function': COMPAT_DESCRIPTOR,
+    'cjs/shared/Mutable.js': COMPAT_DESCRIPTOR,
+    'cjs/shared/Mutable': COMPAT_DESCRIPTOR,
+    'esm/Maybe/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/ErrorMessage': COMPAT_DESCRIPTOR,
+    'esm/Maybe/Maybe.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/Maybe': COMPAT_DESCRIPTOR,
+    'esm/Maybe/and.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/and': COMPAT_DESCRIPTOR,
+    'esm/Maybe/andThen.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/andThen': COMPAT_DESCRIPTOR,
+    'esm/Maybe/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/andThenAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/expect.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/expect': COMPAT_DESCRIPTOR,
+    'esm/Maybe/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/index': COMPAT_DESCRIPTOR,
+    'esm/Maybe': COMPAT_DESCRIPTOR,
+    'esm/Maybe/map.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/map': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOr': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/or.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/or': COMPAT_DESCRIPTOR,
+    'esm/Maybe/orElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/orElse': COMPAT_DESCRIPTOR,
+    'esm/Maybe/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/orElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/tap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/tap': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrap': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOr': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Maybe/xor.mjs': COMPAT_DESCRIPTOR,
+    'esm/Maybe/xor': COMPAT_DESCRIPTOR,
+    'esm/Nullable/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'esm/Nullable/Nullable.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/Nullable': COMPAT_DESCRIPTOR,
+    'esm/Nullable/and.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/and': COMPAT_DESCRIPTOR,
+    'esm/Nullable/andThen.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/andThen': COMPAT_DESCRIPTOR,
+    'esm/Nullable/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/andThenAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/expect.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/expect': COMPAT_DESCRIPTOR,
+    'esm/Nullable/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/index': COMPAT_DESCRIPTOR,
+    'esm/Nullable': COMPAT_DESCRIPTOR,
+    'esm/Nullable/map.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/map': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOr': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/or.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/or': COMPAT_DESCRIPTOR,
+    'esm/Nullable/orElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/orElse': COMPAT_DESCRIPTOR,
+    'esm/Nullable/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/orElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/tap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/tap': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrap': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOr': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Nullable/xor.mjs': COMPAT_DESCRIPTOR,
+    'esm/Nullable/xor': COMPAT_DESCRIPTOR,
+    'esm/Option.mjs': COMPAT_DESCRIPTOR,
+    'esm/Option': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/Option.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/Option': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/and.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/and': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/andThen.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/andThen': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/asMut.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/asMut': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/drop.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/drop': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/equal.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/equal': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/expect.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/expect': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/filter.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/filter': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/flatten.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/flatten': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/index': COMPAT_DESCRIPTOR,
+    'esm/PlainOption': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/map.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/map': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapOr': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/mapOrElse': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/okOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/okOr': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/okOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/okOrElse': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/or.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/or': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/orElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/orElse': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/transpose.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/transpose': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/tap.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/tap': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrap': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrapOr': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/xor.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainOption/xor': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/Result.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/Result': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/and.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/and': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/andThen.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/andThen': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/andThenAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/asMut.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/asMut': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/drop.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/drop': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/equal.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/equal': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/expect.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/expect': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/flatten.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/flatten': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/index': COMPAT_DESCRIPTOR,
+    'esm/PlainResult': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/map.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/map': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapErr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapErr': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapErrAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapErrAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOr': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrElse': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/or.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/or': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/orElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/orElse': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/orElseAsync': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/transpose.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/transpose': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/tap.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/tap': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/toOption.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/toOption': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrap': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOr': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/PlainResult/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Result.mjs': COMPAT_DESCRIPTOR,
+    'esm/Result': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/Undefinable.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/Undefinable': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/and.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/and': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/andThen.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/andThen': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/andThenAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/expect.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/expect': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/index': COMPAT_DESCRIPTOR,
+    'esm/Undefinable': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/map.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/map': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOr': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/or.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/or': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/orElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/orElse': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/orElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/tap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/tap': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrap': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOr': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/xor.mjs': COMPAT_DESCRIPTOR,
+    'esm/Undefinable/xor': COMPAT_DESCRIPTOR,
+    'esm/index.mjs': COMPAT_DESCRIPTOR,
+    'esm/index': COMPAT_DESCRIPTOR,
+    'esm/shared/Function.mjs': COMPAT_DESCRIPTOR,
+    'esm/shared/Function': COMPAT_DESCRIPTOR,
+    'esm/shared/Mutable.mjs': COMPAT_DESCRIPTOR,
+    'esm/shared/Mutable': COMPAT_DESCRIPTOR,
+    'lib/Maybe/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/ErrorMessage': COMPAT_DESCRIPTOR,
+    'lib/Maybe/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/Maybe.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/Maybe': COMPAT_DESCRIPTOR,
+    'lib/Maybe/Maybe.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/and.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/and': COMPAT_DESCRIPTOR,
+    'lib/Maybe/and.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThen.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThen': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThen.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThenAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/expect.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/expect': COMPAT_DESCRIPTOR,
+    'lib/Maybe/expect.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/index.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/index': COMPAT_DESCRIPTOR,
+    'lib/Maybe/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe': COMPAT_DESCRIPTOR,
+    'lib/Maybe/map.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/map': COMPAT_DESCRIPTOR,
+    'lib/Maybe/map.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOr': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/or.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/or': COMPAT_DESCRIPTOR,
+    'lib/Maybe/or.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElse.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElse': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/tap.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/tap': COMPAT_DESCRIPTOR,
+    'lib/Maybe/tap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrap.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrap': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOr': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Maybe/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Maybe/xor.js': COMPAT_DESCRIPTOR,
+    'lib/Maybe/xor': COMPAT_DESCRIPTOR,
+    'lib/Maybe/xor.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'lib/Nullable/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/Nullable.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/Nullable': COMPAT_DESCRIPTOR,
+    'lib/Nullable/Nullable.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/and.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/and': COMPAT_DESCRIPTOR,
+    'lib/Nullable/and.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThen.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThen': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThen.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThenAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/expect.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/expect': COMPAT_DESCRIPTOR,
+    'lib/Nullable/expect.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/index.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/index': COMPAT_DESCRIPTOR,
+    'lib/Nullable/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable': COMPAT_DESCRIPTOR,
+    'lib/Nullable/map.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/map': COMPAT_DESCRIPTOR,
+    'lib/Nullable/map.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOr': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/or.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/or': COMPAT_DESCRIPTOR,
+    'lib/Nullable/or.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElse.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElse': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/tap.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/tap': COMPAT_DESCRIPTOR,
+    'lib/Nullable/tap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrap.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrap': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOr': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Nullable/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Nullable/xor.js': COMPAT_DESCRIPTOR,
+    'lib/Nullable/xor': COMPAT_DESCRIPTOR,
+    'lib/Nullable/xor.mjs': COMPAT_DESCRIPTOR,
+    'lib/Option.js': COMPAT_DESCRIPTOR,
+    'lib/Option': COMPAT_DESCRIPTOR,
+    'lib/Option.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/Option.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/Option': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/Option.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/and.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/and': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/and.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/andThen.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/andThen': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/andThen.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/asMut.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/asMut': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/asMut.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/drop.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/drop': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/drop.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/expect.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/expect': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/expect.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/equal.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/equal': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/equal.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/flatten.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/flatten': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/flatten.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/filter.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/filter': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/filter.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/index.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/index': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/map.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/map': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/map.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOr': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOrElse': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOr': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOrElse': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/okOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/or.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/or': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/or.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/orElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/orElse': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/orElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/transpose.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/transpose': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/transpose.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/tap.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/tap': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/tap.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrap.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrap': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOr': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/xor.js': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/xor': COMPAT_DESCRIPTOR,
+    'lib/PlainOption/xor.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/Result.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/Result': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/Result.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/and.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/and': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/and.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThen.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThen': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThen.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThenAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/asMut.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/asMut': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/asMut.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/drop.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/drop': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/drop.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/equal.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/equal': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/equal.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/expect.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/expect': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/expect.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/flatten.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/flatten': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/flatten.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/index.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/index': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/map.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/map': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/map.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErr': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErrAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErrAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapErrAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOr': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElse': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/or.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/or': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/or.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElse': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElseAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/transpose.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/transpose': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/transpose.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/tap.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/tap': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/tap.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/toOption.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/toOption': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/toOption.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrap.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrap': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOr': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/PlainResult/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Result.js': COMPAT_DESCRIPTOR,
+    'lib/Result': COMPAT_DESCRIPTOR,
+    'lib/Result.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/ErrorMessage.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/ErrorMessage': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/ErrorMessage.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/Undefinable.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/Undefinable': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/Undefinable.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/and.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/and': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/and.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThen.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThen': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThen.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThenAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThenAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/andThenAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/expect.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/expect': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/expect.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/index.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/index': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/map.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/map': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/map.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOr': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/mapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/or.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/or': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/or.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElse.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElse': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/orElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/tap.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/tap': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/tap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrap.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrap': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrap.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOr.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOr': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOr.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElse.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElse': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElse.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElseAsync.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElseAsync': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/unwrapOrElseAsync.mjs': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/xor.js': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/xor': COMPAT_DESCRIPTOR,
+    'lib/Undefinable/xor.mjs': COMPAT_DESCRIPTOR,
+    'lib/index.js': COMPAT_DESCRIPTOR,
+    'lib/index': COMPAT_DESCRIPTOR,
+    'lib/index.mjs': COMPAT_DESCRIPTOR,
+    'lib/shared/Function.js': COMPAT_DESCRIPTOR,
+    'lib/shared/Function': COMPAT_DESCRIPTOR,
+    'lib/shared/Function.mjs': COMPAT_DESCRIPTOR,
+    'lib/shared/Mutable.js': COMPAT_DESCRIPTOR,
+    'lib/shared/Mutable': COMPAT_DESCRIPTOR,
+    'lib/shared/Mutable.mjs': COMPAT_DESCRIPTOR,
+});
diff --git a/tools/spawn.mjs b/tools/spawn.mjs
deleted file mode 100644
index ca272229..00000000
--- a/tools/spawn.mjs
+++ /dev/null
@@ -1,82 +0,0 @@
-import * as childProcess from 'child_process';
-
-/**
- *  Spawn a child process.
- *
- *  @param  {string}    bin
- *      the same as the 1st argument of `child_process.spawn()`.
- *  @param  {Array}     args
- *      the same as the 2nd argument of `child_process.spawn()`.
- *  @param  {Object}    option
- *      the same as the 3rd argument of `child_process.spawn()`.
- *
- *  @return {!PromiseLike<number>}
- */
-export function spawnChildProcess(bin, args, option) {
-    const result = spawnCancelableChild(bin, args, option);
-    return result.process;
-}
-
-/**
- *  Spawn a child process with the canceller function.
- *
- *  XXX: This should be implemented with using a cancelable promise.
- *
- *  @param  {string}    bin
- *      the same as the 1st argument of `child_process.spawn()`.
- *  @param  {Array}     args
- *      the same as the 2nd argument of `child_process.spawn()`.
- *  @param  {Object}    option
- *      the same as the 3rd argument of `child_process.spawn()`.
- *
- *  @return { !{ process: !PromiseLike<number>, canceller: !function(): void, } }
- *      - `process`: This is fulfilled with the process's exit status.
- *      - `canceller`: try to cancel the process if you call this.
- */
-export function spawnCancelableChild(bin, args, option) {
-    let innerCancel = null;
-    let isCanceled = false;
-    const canceller = function () {
-        if (isCanceled) {
-            return;
-        }
-
-        isCanceled = true;
-        if (typeof innerCancel === 'function') {
-            innerCancel();
-        }
-    };
-
-    const process = new Promise(function (resolve, reject) {
-        if (isCanceled) {
-            reject();
-            return;
-        }
-
-        console.log('spawn: ' + bin + ' ' + args.join(' '));
-        const proc = childProcess.spawn(bin, args, option);
-        innerCancel = function () {
-            proc.kill('SIGINT');
-        };
-
-        proc.on('exit', function (status) {
-            resolve(status);
-        });
-    });
-
-    return {
-        canceller,
-        process,
-    };
-}
-
-/**
- *  @param  {number}    status
- *      the process's exit status.
- *  @return {!PromiseLike<number>}
- */
-export function assertReturnCode(status) {
-    return (status === 0) ?
-        Promise.resolve(status) :
-        Promise.reject(status);
-}
diff --git a/yarn.lock b/yarn.lock
index 9ebb5be5..67fdbf3a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -64,10 +64,10 @@
   dependencies:
     "@babel/highlight" "^7.12.13"
 
-"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.14.4.tgz#45720fe0cecf3fd42019e1d12cc3d27fadc98d58"
-  integrity sha512-i2wXrWQNkH6JplJQGn3Rd2I4Pij8GdHkXwHMxm+zV5YG/Jci+bCNrWZEWC4o+umiDkRrRs4dVzH3X4GP7vyjQQ==
+"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.13.15", "@babel/compat-data@^7.14.0":
+  version "7.14.0"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.14.0.tgz#a901128bce2ad02565df95e6ecbf195cf9465919"
+  integrity sha512-vu9V3uMM/1o5Hl5OekMUowo3FqXLJSw+s+66nt0fSWVWTtmosdzn45JHOB3cPtZoe6CTBDzvSw0RdOY85Q37+Q==
 
 "@babel/core@^7.14.3", "@babel/core@^7.8.4":
   version "7.14.3"
@@ -114,14 +114,14 @@
     "@babel/helper-explode-assignable-expression" "^7.12.13"
     "@babel/types" "^7.12.13"
 
-"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.16", "@babel/helper-compilation-targets@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.4.tgz#33ebd0ffc34248051ee2089350a929ab02f2a516"
-  integrity sha512-JgdzOYZ/qGaKTVkn5qEDV/SXAh8KcyUVkCoSWGN8T3bwrgd6m+/dJa2kVGi6RJYJgEYPBdZ84BZp9dUjNWkBaA==
+"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.16":
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.16.tgz#6e91dccf15e3f43e5556dffe32d860109887563c"
+  integrity sha512-3gmkYIrpqsLlieFwjkGgLaSHmhnvlAYzZLlYVjlW+QwI+1zE17kGxuJGmIqDQdYp56XdmGeD+Bswx0UTyG18xA==
   dependencies:
-    "@babel/compat-data" "^7.14.4"
+    "@babel/compat-data" "^7.13.15"
     "@babel/helper-validator-option" "^7.12.17"
-    browserslist "^4.16.6"
+    browserslist "^4.14.5"
     semver "^6.3.0"
 
 "@babel/helper-create-class-features-plugin@^7.13.0":
@@ -147,18 +147,6 @@
     "@babel/helper-replace-supers" "^7.13.12"
     "@babel/helper-split-export-declaration" "^7.12.13"
 
-"@babel/helper-create-class-features-plugin@^7.14.3":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.14.4.tgz#abf888d836a441abee783c75229279748705dc42"
-  integrity sha512-idr3pthFlDCpV+p/rMgGLGYIVtazeatrSOQk8YzO2pAepIjQhCN3myeihVg58ax2bbbGK9PUE1reFi7axOYIOw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.12.13"
-    "@babel/helper-function-name" "^7.14.2"
-    "@babel/helper-member-expression-to-functions" "^7.13.12"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.14.4"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-
 "@babel/helper-create-regexp-features-plugin@^7.12.13":
   version "7.12.16"
   resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.16.tgz#3b31d13f39f930fad975e151163b7df7d4ffe9d3"
@@ -321,16 +309,6 @@
     "@babel/traverse" "^7.13.0"
     "@babel/types" "^7.13.12"
 
-"@babel/helper-replace-supers@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.14.4.tgz#b2ab16875deecfff3ddfcd539bc315f72998d836"
-  integrity sha512-zZ7uHCWlxfEAAOVDYQpEf/uyi1dmeC7fX4nCf2iz9drnCwi1zvwXL3HwWWNXUQEJ1k23yVn3VbddiI9iJEXaTQ==
-  dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.13.12"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/traverse" "^7.14.2"
-    "@babel/types" "^7.14.4"
-
 "@babel/helper-simple-access@^7.13.12":
   version "7.13.12"
   resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz#dd6c538afb61819d205a012c31792a39c7a5eaf6"
@@ -426,12 +404,11 @@
     "@babel/helper-create-class-features-plugin" "^7.13.0"
     "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-proposal-class-static-block@^7.14.3":
-  version "7.14.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.14.3.tgz#5a527e2cae4a4753119c3a3e7f64ecae8ccf1360"
-  integrity sha512-HEjzp5q+lWSjAgJtSluFDrGGosmwTgKwCXdDQZvhKsRlwv3YdkUEqxNrrjesJd+B9E9zvr1PVPVBvhYZ9msjvQ==
+"@babel/plugin-proposal-class-static-block@^7.13.11":
+  version "7.13.11"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.13.11.tgz#6fcbba4a962702c17e5371a0c7b39afde186d703"
+  integrity sha512-fJTdFI4bfnMjvxJyNuaf8i9mVcZ0UhetaGEUHaHV9KEnibLugJkZAtXikR8KcYj+NYmI4DZMS8yQAyg+hvfSqg==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.14.3"
     "@babel/helper-plugin-utils" "^7.13.0"
     "@babel/plugin-syntax-class-static-block" "^7.12.13"
 
@@ -483,13 +460,13 @@
     "@babel/helper-plugin-utils" "^7.13.0"
     "@babel/plugin-syntax-numeric-separator" "^7.10.4"
 
-"@babel/plugin-proposal-object-rest-spread@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.14.4.tgz#0e2b4de419915dc0b409378e829412e2031777c4"
-  integrity sha512-AYosOWBlyyXEagrPRfLJ1enStufsr7D1+ddpj8OLi9k7B6+NdZ0t/9V7Fh+wJ4g2Jol8z2JkgczYqtWrZd4vbA==
+"@babel/plugin-proposal-object-rest-spread@^7.14.2":
+  version "7.14.2"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.14.2.tgz#e17d418f81cc103fedd4ce037e181c8056225abc"
+  integrity sha512-hBIQFxwZi8GIp934+nj5uV31mqclC1aYDhctDu5khTi9PCCUOczyy0b34W0oE9U/eJXiqQaKyVsmjeagOaSlbw==
   dependencies:
-    "@babel/compat-data" "^7.14.4"
-    "@babel/helper-compilation-targets" "^7.14.4"
+    "@babel/compat-data" "^7.14.0"
+    "@babel/helper-compilation-targets" "^7.13.16"
     "@babel/helper-plugin-utils" "^7.13.0"
     "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
     "@babel/plugin-transform-parameters" "^7.14.2"
@@ -658,23 +635,23 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-block-scoping@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.14.4.tgz#caf140b0b2e2462c509553d140e6d0abefb61ed8"
-  integrity sha512-5KdpkGxsZlTk+fPleDtGKsA+pon28+ptYmMO8GBSa5fHERCJWAzj50uAfCKBqq42HO+Zot6JF1x37CRprwmN4g==
+"@babel/plugin-transform-block-scoping@^7.14.2":
+  version "7.14.2"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.14.2.tgz#761cb12ab5a88d640ad4af4aa81f820e6b5fdf5c"
+  integrity sha512-neZZcP19NugZZqNwMTH+KoBjx5WyvESPSIOQb4JHpfd+zPfqcH65RMu5xJju5+6q/Y2VzYrleQTr+b6METyyxg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-classes@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.14.4.tgz#a83c15503fc71a0f99e876fdce7dadbc6575ec3a"
-  integrity sha512-p73t31SIj6y94RDVX57rafVjttNr8MvKEgs5YFatNB/xC68zM3pyosuOEcQmYsYlyQaGY9R7rAULVRcat5FKJQ==
+"@babel/plugin-transform-classes@^7.14.2":
+  version "7.14.2"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.14.2.tgz#3f1196c5709f064c252ad056207d87b7aeb2d03d"
+  integrity sha512-7oafAVcucHquA/VZCsXv/gmuiHeYd64UJyyTYU+MPfNu0KeNlxw06IeENBO8bJjXVbolu+j1MM5aKQtH1OMCNg==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.12.13"
     "@babel/helper-function-name" "^7.14.2"
     "@babel/helper-optimise-call-expression" "^7.12.13"
     "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-replace-supers" "^7.14.4"
+    "@babel/helper-replace-supers" "^7.13.12"
     "@babel/helper-split-export-declaration" "^7.12.13"
     globals "^11.1.0"
 
@@ -685,10 +662,10 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-destructuring@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.14.4.tgz#acbec502e9951f30f4441eaca1d2f29efade59ed"
-  integrity sha512-JyywKreTCGTUsL1OKu1A3ms/R1sTP0WxbpXlALeGzF53eB3bxtNkYdMj9SDgK7g6ImPy76J5oYYKoTtQImlhQA==
+"@babel/plugin-transform-destructuring@^7.13.17":
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.17.tgz#678d96576638c19d5b36b332504d3fd6e06dea27"
+  integrity sha512-UAUqiLv+uRLO+xuBKKMEpC+t7YRNVRqBsWWq1yKXbBZBje/t3IXCiSinZhjn/DC3qzBfICeYd2EFGEbHsh5RLA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
@@ -883,26 +860,26 @@
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
     "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/preset-env@^7.14.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.14.4.tgz#73fc3228c59727e5e974319156f304f0d6685a2d"
-  integrity sha512-GwMMsuAnDtULyOtuxHhzzuSRxFeP0aR/LNzrHRzP8y6AgDNgqnrfCCBm/1cRdTU75tRs28Eh76poHLcg9VF0LA==
+"@babel/preset-env@^7.14.2":
+  version "7.14.2"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.14.2.tgz#e80612965da73579c84ad2f963c2359c71524ed5"
+  integrity sha512-7dD7lVT8GMrE73v4lvDEb85cgcQhdES91BSD7jS/xjC6QY8PnRhux35ac+GCpbiRhp8crexBvZZqnaL6VrY8TQ==
   dependencies:
-    "@babel/compat-data" "^7.14.4"
-    "@babel/helper-compilation-targets" "^7.14.4"
+    "@babel/compat-data" "^7.14.0"
+    "@babel/helper-compilation-targets" "^7.13.16"
     "@babel/helper-plugin-utils" "^7.13.0"
     "@babel/helper-validator-option" "^7.12.17"
     "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.13.12"
     "@babel/plugin-proposal-async-generator-functions" "^7.14.2"
     "@babel/plugin-proposal-class-properties" "^7.13.0"
-    "@babel/plugin-proposal-class-static-block" "^7.14.3"
+    "@babel/plugin-proposal-class-static-block" "^7.13.11"
     "@babel/plugin-proposal-dynamic-import" "^7.14.2"
     "@babel/plugin-proposal-export-namespace-from" "^7.14.2"
     "@babel/plugin-proposal-json-strings" "^7.14.2"
     "@babel/plugin-proposal-logical-assignment-operators" "^7.14.2"
     "@babel/plugin-proposal-nullish-coalescing-operator" "^7.14.2"
     "@babel/plugin-proposal-numeric-separator" "^7.14.2"
-    "@babel/plugin-proposal-object-rest-spread" "^7.14.4"
+    "@babel/plugin-proposal-object-rest-spread" "^7.14.2"
     "@babel/plugin-proposal-optional-catch-binding" "^7.14.2"
     "@babel/plugin-proposal-optional-chaining" "^7.14.2"
     "@babel/plugin-proposal-private-methods" "^7.13.0"
@@ -925,10 +902,10 @@
     "@babel/plugin-transform-arrow-functions" "^7.13.0"
     "@babel/plugin-transform-async-to-generator" "^7.13.0"
     "@babel/plugin-transform-block-scoped-functions" "^7.12.13"
-    "@babel/plugin-transform-block-scoping" "^7.14.4"
-    "@babel/plugin-transform-classes" "^7.14.4"
+    "@babel/plugin-transform-block-scoping" "^7.14.2"
+    "@babel/plugin-transform-classes" "^7.14.2"
     "@babel/plugin-transform-computed-properties" "^7.13.0"
-    "@babel/plugin-transform-destructuring" "^7.14.4"
+    "@babel/plugin-transform-destructuring" "^7.13.17"
     "@babel/plugin-transform-dotall-regex" "^7.12.13"
     "@babel/plugin-transform-duplicate-keys" "^7.12.13"
     "@babel/plugin-transform-exponentiation-operator" "^7.12.13"
@@ -955,7 +932,7 @@
     "@babel/plugin-transform-unicode-escapes" "^7.12.13"
     "@babel/plugin-transform-unicode-regex" "^7.12.13"
     "@babel/preset-modules" "^0.1.4"
-    "@babel/types" "^7.14.4"
+    "@babel/types" "^7.14.2"
     babel-plugin-polyfill-corejs2 "^0.2.0"
     babel-plugin-polyfill-corejs3 "^0.2.0"
     babel-plugin-polyfill-regenerator "^0.2.0"
@@ -1003,10 +980,10 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.14.0", "@babel/types@^7.14.2", "@babel/types@^7.14.4", "@babel/types@^7.4.4":
-  version "7.14.4"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.14.4.tgz#bfd6980108168593b38b3eb48a24aa026b919bc0"
-  integrity sha512-lCj4aIs0xUefJFQnwwQv2Bxg7Omd6bgquZ6LGC+gGMh6/s5qDVfjuCMlDmYQ15SLsWHd9n+X3E75lKIhl5Lkiw==
+"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.14.0", "@babel/types@^7.14.2", "@babel/types@^7.4.4":
+  version "7.14.2"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.14.2.tgz#4208ae003107ef8a057ea8333e56eb64d2f6a2c3"
+  integrity sha512-SdjAG/3DikRHpUOjxZgnkbR11xUlyDMUFJdvnIgZEE16mqmY0BINMmc4//JMJglEmn6i7sq6p+mGrFWyZ98EEw==
   dependencies:
     "@babel/helper-validator-identifier" "^7.14.0"
     to-fast-properties "^2.0.0"
@@ -1116,13 +1093,13 @@
   resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e"
   integrity sha512-f5j5b/Gf71L+dbqxIpQ4Z2WlmI/mPJ0fOkGGmFgtb6sAu97EPczzbS3/tJKxmcYDj55OX6ssqwDAWOHIYDRDGA==
 
-"@typescript-eslint/eslint-plugin@^4.25.0":
-  version "4.25.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.25.0.tgz#d82657b6ab4caa4c3f888ff923175fadc2f31f2a"
-  integrity sha512-Qfs3dWkTMKkKwt78xp2O/KZQB8MPS1UQ5D3YW2s6LQWBE1074BE+Rym+b1pXZIX3M3fSvPUDaCvZLKV2ylVYYQ==
+"@typescript-eslint/eslint-plugin@^4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.23.0.tgz#29d3c9c81f6200b1fd6d8454cfb007ba176cde80"
+  integrity sha512-tGK1y3KIvdsQEEgq6xNn1DjiFJtl+wn8JJQiETtCbdQxw1vzjXyAaIkEmO2l6Nq24iy3uZBMFQjZ6ECf1QdgGw==
   dependencies:
-    "@typescript-eslint/experimental-utils" "4.25.0"
-    "@typescript-eslint/scope-manager" "4.25.0"
+    "@typescript-eslint/experimental-utils" "4.23.0"
+    "@typescript-eslint/scope-manager" "4.23.0"
     debug "^4.1.1"
     functional-red-black-tree "^1.0.1"
     lodash "^4.17.15"
@@ -1130,15 +1107,15 @@
     semver "^7.3.2"
     tsutils "^3.17.1"
 
-"@typescript-eslint/experimental-utils@4.25.0":
-  version "4.25.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.25.0.tgz#b2febcfa715d2c1806fd5f0335193a6cd270df54"
-  integrity sha512-f0doRE76vq7NEEU0tw+ajv6CrmPelw5wLoaghEHkA2dNLFb3T/zJQqGPQ0OYt5XlZaS13MtnN+GTPCuUVg338w==
+"@typescript-eslint/experimental-utils@4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.23.0.tgz#f2059434cd6e5672bfeab2fb03b7c0a20622266f"
+  integrity sha512-WAFNiTDnQfrF3Z2fQ05nmCgPsO5o790vOhmWKXbbYQTO9erE1/YsFot5/LnOUizLzU2eeuz6+U/81KV5/hFTGA==
   dependencies:
     "@types/json-schema" "^7.0.3"
-    "@typescript-eslint/scope-manager" "4.25.0"
-    "@typescript-eslint/types" "4.25.0"
-    "@typescript-eslint/typescript-estree" "4.25.0"
+    "@typescript-eslint/scope-manager" "4.23.0"
+    "@typescript-eslint/types" "4.23.0"
+    "@typescript-eslint/typescript-estree" "4.23.0"
     eslint-scope "^5.0.0"
     eslint-utils "^2.0.0"
 
@@ -1152,6 +1129,14 @@
     "@typescript-eslint/typescript-estree" "4.25.0"
     debug "^4.1.1"
 
+"@typescript-eslint/scope-manager@4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.23.0.tgz#8792ef7eacac122e2ec8fa2d30a59b8d9a1f1ce4"
+  integrity sha512-ZZ21PCFxPhI3n0wuqEJK9omkw51wi2bmeKJvlRZPH5YFkcawKOuRMQMnI8mH6Vo0/DoHSeZJnHiIx84LmVQY+w==
+  dependencies:
+    "@typescript-eslint/types" "4.23.0"
+    "@typescript-eslint/visitor-keys" "4.23.0"
+
 "@typescript-eslint/scope-manager@4.25.0":
   version "4.25.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.25.0.tgz#9d86a5bcc46ef40acd03d85ad4e908e5aab8d4ca"
@@ -1160,11 +1145,29 @@
     "@typescript-eslint/types" "4.25.0"
     "@typescript-eslint/visitor-keys" "4.25.0"
 
+"@typescript-eslint/types@4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.23.0.tgz#da1654c8a5332f4d1645b2d9a1c64193cae3aa3b"
+  integrity sha512-oqkNWyG2SLS7uTWLZf6Sr7Dm02gA5yxiz1RP87tvsmDsguVATdpVguHr4HoGOcFOpCvx9vtCSCyQUGfzq28YCw==
+
 "@typescript-eslint/types@4.25.0":
   version "4.25.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.25.0.tgz#0e444a5c5e3c22d7ffa5e16e0e60510b3de5af87"
   integrity sha512-+CNINNvl00OkW6wEsi32wU5MhHti2J25TJsJJqgQmJu3B3dYDBcmOxcE5w9cgoM13TrdE/5ND2HoEnBohasxRQ==
 
+"@typescript-eslint/typescript-estree@4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.23.0.tgz#0753b292097523852428a6f5a1aa8ccc1aae6cd9"
+  integrity sha512-5Sty6zPEVZF5fbvrZczfmLCOcby3sfrSPu30qKoY1U3mca5/jvU5cwsPb/CO6Q3ByRjixTMIVsDkqwIxCf/dMw==
+  dependencies:
+    "@typescript-eslint/types" "4.23.0"
+    "@typescript-eslint/visitor-keys" "4.23.0"
+    debug "^4.1.1"
+    globby "^11.0.1"
+    is-glob "^4.0.1"
+    semver "^7.3.2"
+    tsutils "^3.17.1"
+
 "@typescript-eslint/typescript-estree@4.25.0":
   version "4.25.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.25.0.tgz#942e4e25888736bff5b360d9b0b61e013d0cfa25"
@@ -1178,6 +1181,14 @@
     semver "^7.3.2"
     tsutils "^3.17.1"
 
+"@typescript-eslint/visitor-keys@4.23.0":
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.23.0.tgz#7215cc977bd3b4ef22467b9023594e32f9e4e455"
+  integrity sha512-5PNe5cmX9pSifit0H+nPoQBXdbNzi5tOEec+3riK+ku4e3er37pKxMKDH5Ct5Y4fhWxcD4spnlYjxi9vXbSpwg==
+  dependencies:
+    "@typescript-eslint/types" "4.23.0"
+    eslint-visitor-keys "^2.0.0"
+
 "@typescript-eslint/visitor-keys@4.25.0":
   version "4.25.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.25.0.tgz#863e7ed23da4287c5b469b13223255d0fde6aaa7"
@@ -1605,7 +1616,7 @@ braces@^3.0.1, braces@~3.0.2:
   dependencies:
     fill-range "^7.0.1"
 
-browserslist@^4.16.3, browserslist@^4.16.6:
+browserslist@^4.14.5, browserslist@^4.16.3:
   version "4.16.6"
   resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.6.tgz#d7901277a5a88e554ed305b183ec9b0c08f66fa2"
   integrity sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==


Test patch:
diff --git a/tools/package_export_tester.mjs b/tools/package_export_tester.mjs
deleted file mode 100644
index 2435e5ba..00000000
--- a/tools/package_export_tester.mjs
+++ /dev/null
@@ -1,220 +0,0 @@
-import * as assert from 'assert';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const require = createRequire(import.meta.url);
-
-import { loadJSON } from './package_json_rewriter/json.mjs';
-
-const THIS_FILENAME = fileURLToPath(import.meta.url);
-const THIS_DIRNAME = dirname(THIS_FILENAME);
-
-const BASE_DIR = THIS_DIRNAME;
-const PACKAGE_NAME = 'option-t';
-
-const SHOULD_EXPOSE_LIB = true;
-
-function calcModulePath(file) {
-    return (file === '.') ? PACKAGE_NAME : `${PACKAGE_NAME}/${file}`;
-}
-
-function tryLoadCJS(file) {
-    const modulepath = calcModulePath(file);
-    const mod = require(modulepath);
-    return mod;
-}
-
-function assertLoadCJS(file, condition) {
-    assert.notStrictEqual(condition, undefined);
-    const modulepath = calcModulePath(file);
-
-    const isPrivate = !!condition && condition.private;
-    const tester = () => {
-        require(modulepath);
-    };
-
-    if (!isPrivate) {
-        assert.doesNotThrow(tester, `\`${modulepath}\` should not be exposed`);
-    }
-    else {
-        assert.throws(tester, `\`${modulepath}\` should not be exposed, but there is!`);
-    }
-}
-
-async function tryLoadESM(file) {
-    const modulepath = calcModulePath(file);
-    const mod = await import(modulepath);
-    return mod;
-}
-
-async function assertLoadESM(file, condition) {
-    assert.notStrictEqual(condition, undefined);
-    const modulepath = calcModulePath(file);
-    const tester = async () => {
-        await import(modulepath);
-    };
-
-    const isPrivate = !!condition && condition.private;
-    if (!isPrivate) {
-        await assert.doesNotReject(tester, `\`${modulepath}\` should not be exposed`);
-    }
-    else {
-        await assert.rejects(tester, `\`${modulepath}\` should not be exposed, but there is!`);
-    }
-}
-
-
-async function assertLoadJSFileAsModule(file, condition) {
-    if (file.endsWith('.js')) {
-        assertLoadCJS(file, condition);
-    }
-    else if (file.endsWith('.mjs')) {
-        await assertLoadESM(file, condition);
-    }
-    else {
-        throw Error(`${file} is not unknown module type`);
-    }
-}
-
-async function testSpecialCaseLoadIndexJS(installedPackageJSON) {
-    const DIR_SUBPATH = [
-        'Maybe',
-        'Nullable',
-        'PlainOption',
-        'PlainResult',
-        'Undefinable',
-    ];
-    let NODE_MODULE_RESOLUTION_SPECIAL_CASE_CJS = [
-        ...DIR_SUBPATH.map((path) => `cjs/${path}`),
-    ];
-
-    if (SHOULD_EXPOSE_LIB) {
-        NODE_MODULE_RESOLUTION_SPECIAL_CASE_CJS = [
-            ...NODE_MODULE_RESOLUTION_SPECIAL_CASE_CJS,
-            ...DIR_SUBPATH.map((path) => `lib/${path}`),
-        ];
-    }
-
-    // `require()` can load `./index.js` with a parent directry name.
-    // This behavior is not supported by Node.js' ESM implementation.
-    // But it might be supported by webpack or other bundlers. It's sad for package developer.
-
-    for (const file of NODE_MODULE_RESOLUTION_SPECIAL_CASE_CJS) {
-        assertLoadCJS(file, null);
-    }
-
-    const NODE_MODULE_RESOLUTION_SPECIAL_CASE_ESM = DIR_SUBPATH.map((path) => `./esm/${path}`);
-    for (const name of NODE_MODULE_RESOLUTION_SPECIAL_CASE_ESM) {
-        const filename = `${name}/index.mjs`;
-        testPackageJSONHasExportsEntry(installedPackageJSON, name, filename, null);
-    }
-}
-
-function testPackageJSONHasExportsEntry(pkgObj, entryName, entryFileName, condition) {
-    const exports = pkgObj.exports;
-    const actual = exports[entryName];
-
-    const isPrivate = !!condition && condition.private;
-    if (isPrivate) {
-        assert.strictEqual(actual, undefined, `${entryName} should not specify ${entryFileName}, but ${actual}`);
-    }
-    else {
-        assert.strictEqual(actual, entryFileName, `${entryName} should specify ${entryFileName}, but ${actual}`);
-    }
-}
-
-(async function main() {
-    console.log('====== This script tests whether the path is exported or not by the list ======');
-
-    const json = await loadJSON(BASE_DIR, './pkg_files.json');
-    const fileList = new Map(Object.entries(json));
-
-    const cjsFileSet = new Map([
-        ['.', null],
-    ]);
-    const esmFileSet = new Map([
-        ['.', null],
-    ]);
-    const libFileSet = new Map();
-    for (const [file, info] of fileList) {
-        if (file.endsWith('.d.ts')) {
-            continue;
-        }
-
-        if (file.startsWith('cjs/')) {
-            cjsFileSet.set(file, info);
-        }
-        else if (file.startsWith('esm/')) {
-            esmFileSet.set(file, info);
-        }
-        else if (SHOULD_EXPOSE_LIB && file.startsWith('lib/')) {
-            libFileSet.set(file, info);
-        }
-        else {
-            continue;
-        }
-    }
-
-    const installedPackageJSON = await loadJSON(BASE_DIR, `../node_modules/${PACKAGE_NAME}/package.json`);
-
-    const EXTENSION_PATTERN = /\.(js|mjs|cjs)$/u;
-
-    for (const [file, condition] of cjsFileSet) {
-        assertLoadCJS(file, condition);
-
-        // With classic Node.js Module resolution support without extension.
-        assertLoadCJS(file.replace(EXTENSION_PATTERN, ''), condition);
-    }
-
-    const testSpecialCaseESMWithoutExtension = (file, condition) => {
-        // Out package type is not module. Let's return.
-        if (file === '.') {
-            return;
-        }
-
-        // With classic Node.js Module resolution support without extension.
-        // It's supported by various bundlers (webpack, rollup, and more).
-        // But Node.js does not support its style.
-        // Instead of loading a module, we'll test by checking a value in package.json.
-
-        const fileValue = `./${file}`;
-        const classicPath = fileValue.replace(EXTENSION_PATTERN, '');
-        testPackageJSONHasExportsEntry(installedPackageJSON, classicPath, fileValue, condition);
-    };
-
-    for (const [file, condition] of esmFileSet) {
-        // eslint-disable-next-line no-await-in-loop
-        await assertLoadESM(file, condition);
-
-        testSpecialCaseESMWithoutExtension(file, condition);
-    }
-
-    for (const [file, condition] of libFileSet) {
-        // eslint-disable-next-line no-await-in-loop
-        await assertLoadJSFileAsModule(file, condition);
-        assertLoadCJS(file.replace(EXTENSION_PATTERN, ''), condition);
-    }
-
-    await testSpecialCaseLoadIndexJS(installedPackageJSON);
-
-    const publicApiTestCases = await import(`${THIS_DIRNAME}/public_api.mjs`).then((obj) => obj.default);
-
-    const matcher = (packagePath, recods, list) => {
-        const actual = Object.keys(recods).sort();
-        const expected = list.sort();
-        assert.deepStrictEqual(actual, expected, `all exported symbols should be actual exported: ${packagePath}`);
-    };
-
-    for (const [key, { exports: expected }] of Object.entries(publicApiTestCases)) {
-        // eslint-disable-next-line no-await-in-loop
-        const importESMObj = await tryLoadESM(key);
-        matcher(`mjs:${key}`, importESMObj, expected);
-
-        const importCJSObj = tryLoadCJS(key);
-        matcher(`cjs:${key}`, importCJSObj, expected);
-    }
-})().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
diff --git a/tools/esmodule_path_rewrite_tester.mjs b/tools/test_esmodule_path_rewrite.mjs
similarity index 100%
rename from tools/esmodule_path_rewrite_tester.mjs
rename to tools/test_esmodule_path_rewrite.mjs
diff --git a/tools/pkg_files_tester.mjs b/tools/test_package_contains_expected_all.mjs
similarity index 100%
rename from tools/pkg_files_tester.mjs
rename to tools/test_package_contains_expected_all.mjs
diff --git a/tools/test_package_exports.mjs b/tools/test_package_exports.mjs
new file mode 100644
index 00000000..d9c3d792
--- /dev/null
+++ b/tools/test_package_exports.mjs
@@ -0,0 +1,93 @@
+import * as assert from 'assert';
+import { createRequire } from 'module';
+
+import {
+    generateAllExposedPathSequence,
+    ExposedPath,
+    QuirksLegacyExposedPath,
+} from './public_api/mod.mjs';
+
+const require = createRequire(import.meta.url);
+
+async function tryImportPathAsESM(pathItem) {
+    assert.ok(pathItem instanceof ExposedPath);
+
+    const targetPath = pathItem.getCalcPath();
+    let actualExportedObj;
+    await assert.doesNotReject(async () => {
+        actualExportedObj = await import(targetPath);
+    }, `Fail to import ${targetPath} as ES Module`);
+
+    checkExportedItems(actualExportedObj, pathItem);
+}
+
+function tryImportPathAsCJS(pathItem) {
+    assert.ok(pathItem instanceof ExposedPath);
+
+    const targetPath = pathItem.getCalcPath();
+
+    let actualExportedObj;
+    assert.doesNotThrow(() => {
+        actualExportedObj = require(targetPath);
+    }, `Fail to import ${targetPath} as ES Module`);
+
+    checkExportedItems(actualExportedObj, pathItem);
+}
+
+function checkExportedItems(actualExportedObj, pathItem) {
+    assert.ok(pathItem instanceof ExposedPath);
+
+    const targetPath = pathItem.getCalcPath();
+    const rawExpected = pathItem.exports();
+    if (!!rawExpected) {
+        const expected = rawExpected.sort();
+        const actual = Object.keys(actualExportedObj).sort();
+        assert.deepStrictEqual(actual, expected, `Mismatch the exported items for ${targetPath}`);
+    }
+}
+
+async function tryImportPathForCompat(pathItem) {
+    assert.ok(pathItem instanceof QuirksLegacyExposedPath);
+    assert.ok(pathItem.isForCompat());
+
+    if (pathItem.isESM()) {
+        await tryImportPathAsESM(pathItem);
+    }
+    else if (pathItem.isCJS()) {
+        tryImportPathAsCJS(pathItem);
+    }
+    else if (pathItem.isLibButWithoutExtension()) {
+        tryImportPathAsCJS(pathItem);
+    }
+    else {
+        throw new RangeError(`unreachable, but ${pathItem.getCalcPath()} reach to here`);
+    }
+}
+
+async function tryImportPath(pathItem) {
+    assert.ok(pathItem instanceof ExposedPath);
+
+    await tryImportPathAsESM(pathItem);
+    tryImportPathAsCJS(pathItem);
+}
+
+(async function main() {
+    console.log('====== This script tests whether the path is exported or not by the list ======');
+
+    const list = generateAllExposedPathSequence();
+
+    const testingItems = [];
+    for (const item of list) {
+        let testing = null;
+        if (item.isForCompat()) {
+            testing = tryImportPathForCompat(item);
+        }
+        else {
+            testing = tryImportPath(item);
+        }
+
+        testingItems.push(testing);
+    }
+
+    await Promise.all(testingItems);
+})();