@yao-pkg/pkg 6.13.0 → 6.14.0

package/README.md

@@ -53,7 +53,7 @@ After installing it, run `pkg --help` without arguments to see list of options:
   – Makes executable for particular target machine
     $ pkg -t node14-win-arm64 index.js
   – Makes executables for target machines of your choice
-    $ pkg -t node16-linux,node18-linux,node18-win index.js
+    $ pkg -t node20-linux,node22-linux,node22-win index.js
   – Bakes '--expose-gc' and '--max-heap-size=34' into executable
     $ pkg --options "expose-gc,max-heap-size=34" index.js
   – Consider packageA and packageB to be public
@@ -82,7 +82,7 @@ The entrypoint of your project is a mandatory CLI argument. It may be:
 `pkg` can generate executables for several target machines at a
 time. You can specify a comma-separated list of targets via `--targets`
 option. A canonical target consists of 3 elements, separated by
-dashes, for example `node18-macos-x64` or `node14-linux-arm64`:
+dashes, for example `node20-macos-x64` or `node22-linux-arm64`:
 
 - **nodeRange** (node8), node10, node12, node14, node16 or latest
 - **platform** alpine, linux, linuxstatic, win, macos, (freebsd)
@@ -422,6 +422,37 @@ await exec(['app.js', '--target', 'host', '--output', 'app.exe']);
 // do something with app.exe, run, test, upload, deploy, etc
 ```
 
+## ECMAScript Modules (ESM) Support
+
+Starting from version **6.13.0**, pkg has improved support for ECMAScript Modules (ESM). Most ESM features are now automatically transformed to CommonJS during the packaging process.
+
+### Supported ESM Features
+
+The following ESM features are now supported and will work in your packaged executables:
+
+- **`import` and `export` statements** - Automatically transformed to `require()` and `module.exports`
+- **Top-level `await`** - Wrapped in an async IIFE to work in CommonJS context
+- **Top-level `for await...of`** - Wrapped in an async IIFE to work in CommonJS context
+- **`import.meta.url`** - Polyfilled to provide the file URL of the current module
+- **`import.meta.dirname`** - Polyfilled to provide the directory path (Node.js 20.11+ property)
+- **`import.meta.filename`** - Polyfilled to provide the file path (Node.js 20.11+ property)
+
+### Known Limitations
+
+While most ESM features work, there are some limitations to be aware of:
+
+1. **Modules with both top-level await and exports**: Modules that use `export` statements alongside top-level `await` cannot be wrapped in an async IIFE and will not be transformed to bytecode. These modules will be included as source code instead.
+
+2. **`import.meta.main`** and other custom properties: Only the standard `import.meta` properties listed above are polyfilled. Custom properties added by your code or other tools may not work as expected.
+
+3. **Dynamic imports**: `import()` expressions work but may have limitations depending on the module being imported.
+
+### Best Practices
+
+- For entry point scripts (the main file you're packaging), feel free to use top-level await
+- For library modules that will be imported by other code, avoid using both exports and top-level await together
+- Test your packaged executable to ensure all ESM features work as expected in your specific use case
+
 ## Use custom Node.js binary
 
 In case you want to use custom node binary, you can set `PKG_NODE_PATH` environment variable to the path of the node binary you want to use and `pkg` will use it instead of the default one.
@@ -535,43 +566,45 @@ or
 Note: make sure not to use --debug flag in production.
 
 ### Injecting Windows Executable Metadata After Packaging
-Executables created with `pkg` are based on a Node.js binary and, by default, 
-inherit its embedded metadata – such as version number, product name, company 
-name, icon, and description. This can be misleading or unpolished in 
+
+Executables created with `pkg` are based on a Node.js binary and, by default,
+inherit its embedded metadata – such as version number, product name, company
+name, icon, and description. This can be misleading or unpolished in
 distributed applications.
 
 There are two ways to customize the metadata of the resulting `.exe`:
+
 1. **Use a custom Node.js binary** with your own metadata already embedded.  
    See: [Use Custom Node.js Binary](#use-custom-nodejs-binary)
 
-2. **Post-process the generated executable** using 
-   [`resedit`](https://www.npmjs.com/package/resedit), a Node.js-compatible 
-   tool for modifying Windows executable resources. This allows injecting 
+2. **Post-process the generated executable** using
+   [`resedit`](https://www.npmjs.com/package/resedit), a Node.js-compatible
+   tool for modifying Windows executable resources. This allows injecting
    correct version info, icons, copyright,
    and more.
 
 This section focuses on the second approach: post-processing the packaged
-binary using  [`resedit`](https://www.npmjs.com/package/resedit).
+binary using [`resedit`](https://www.npmjs.com/package/resedit).
 
 > ⚠️ Other tools may corrupt the executable, resulting in runtime errors such as  
-> `Pkg: Error reading from file.` – 
+> `Pkg: Error reading from file.` –
 > [`resedit`](https://www.npmjs.com/package/resedit) has proven to work reliably  
 > with `pkg`-generated binaries.
 
 Below is a working example for post-processing an `.exe` file using the Node.js API of [`resedit`](https://www.npmjs.com/package/resedit):
 
 ```ts
-import * as ResEdit from "resedit";
-import * as fs from "fs";
-import * as path from "path";
+import * as ResEdit from 'resedit';
+import * as fs from 'fs';
+import * as path from 'path';
 
 // Set your inputs:
-const exePath = "dist/my-tool.exe";  // Path to the generated executable
-const outputPath = exePath;          // Overwrite or use a different path
-const version = "1.2.3";             // Your application version
+const exePath = 'dist/my-tool.exe'; // Path to the generated executable
+const outputPath = exePath; // Overwrite or use a different path
+const version = '1.2.3'; // Your application version
 
-const lang = 1033;       // en-US
-const codepage = 1200;   // Unicode
+const lang = 1033; // en-US
+const codepage = 1200; // Unicode
 
 const exeData = fs.readFileSync(exePath);
 const exe = ResEdit.NtExecutable.from(exeData);
@@ -580,19 +613,22 @@ const res = ResEdit.NtExecutableResource.from(exe);
 const viList = ResEdit.Resource.VersionInfo.fromEntries(res.entries);
 const vi = viList[0];
 
-const [major, minor, patch] = version.split(".");
+const [major, minor, patch] = version.split('.');
 vi.setFileVersion(Number(major), Number(minor), Number(patch), 0, lang);
 vi.setProductVersion(Number(major), Number(minor), Number(patch), 0, lang);
 
-vi.setStringValues({ lang, codepage }, {
-  FileDescription: "ACME CLI Tool",
-  ProductName: "ACME Application",
-  CompanyName: "ACME Corporation",
-  ProductVersion: version,
-  FileVersion: version,
-  OriginalFilename: path.basename(exePath),
-  LegalCopyright: `© ${new Date().getFullYear()} ACME Corporation`
-});
+vi.setStringValues(
+  { lang, codepage },
+  {
+    FileDescription: 'ACME CLI Tool',
+    ProductName: 'ACME Application',
+    CompanyName: 'ACME Corporation',
+    ProductVersion: version,
+    FileVersion: version,
+    OriginalFilename: path.basename(exePath),
+    LegalCopyright: `© ${new Date().getFullYear()} ACME Corporation`,
+  },
+);
 
 vi.outputToResourceEntries(res.entries);
 res.outputResource(exe);
@@ -610,6 +646,7 @@ The following command examples inject an icon and metadata into the executable
 `dist/bin/app.exe`.
 
 - **Example (PowerShell on Windows)**
+
   ```powershell
   npx resedit dist/bin/app.exe dist/bin/app_with_metadata.exe `
     --icon 1,dist/favicon.ico `

package/lib-es5/detector.js

@@ -86,7 +86,6 @@ function reconstructSpecifiers(specs) {
     return defaults.join(', ');
 }
 function reconstruct(node) {
-    // @ts-expect-error Type mismatch due to @babel/types version in @types/babel__generator
     let v = (0, generator_1.default)(node, { comments: false }).code.replace(/\n/g, '');
     let v2;
     while (true) {

package/lib-es5/esm-transformer.js

@@ -33,39 +33,70 @@ const esbuild = __importStar(require("esbuild"));
 const log_1 = require("./log");
 const common_1 = require("./common");
 /**
- * Detect ESM features that cannot be safely transformed to CommonJS
- * These include:
- * - Top-level await (no CJS equivalent)
- * - import.meta (no CJS equivalent)
+ * Wrapper for top-level await support
+ * Wraps code in an async IIFE to allow top-level await in CommonJS
+ */
+const ASYNC_IIFE_WRAPPER = {
+    prefix: '(async () => {\n',
+    suffix: '\n})()',
+};
+/**
+ * Check if code contains import.meta usage
  *
  * @param code - The ESM source code to check
- * @param filename - The filename for error reporting
- * @returns Array of unsupported features found, or null if parse fails
+ * @returns true if import.meta is used, false otherwise
  */
-function detectUnsupportedESMFeatures(code, filename) {
+function hasImportMeta(code) {
     try {
         const ast = babel.parse(code, {
             sourceType: 'module',
             plugins: [],
         });
         if (!ast) {
-            return null;
+            return false;
         }
-        const unsupportedFeatures = [];
-        // @ts-expect-error Type mismatch due to @babel/types version in @types/babel__traverse
+        let found = false;
         (0, traverse_1.default)(ast, {
             // Detect import.meta usage
             MetaProperty(path) {
                 if (path.node.meta.name === 'import' &&
                     path.node.property.name === 'meta') {
-                    unsupportedFeatures.push({
-                        feature: 'import.meta',
-                        line: path.node.loc?.start.line ?? null,
-                        column: path.node.loc?.start.column ?? null,
-                    });
+                    found = true;
+                    path.stop(); // Stop traversal once found
                 }
             },
-            // Detect top-level await
+        });
+        return found;
+    }
+    catch (_error) {
+        // If we can't parse, assume no import.meta
+        return false;
+    }
+}
+/**
+ * Detect ESM features that require special handling or cannot be transformed
+ * These include:
+ * - Top-level await (can be handled with async IIFE wrapper)
+ *
+ * Note: import.meta is now supported via polyfills and is no longer in the unsupported list
+ *
+ * @param code - The ESM source code to check
+ * @param filename - The filename for error reporting
+ * @returns Object with arrays of features requiring special handling
+ */
+function detectESMFeatures(code, filename) {
+    try {
+        const ast = babel.parse(code, {
+            sourceType: 'module',
+            plugins: [],
+        });
+        if (!ast) {
+            return null;
+        }
+        const topLevelAwait = [];
+        const unsupportedFeatures = [];
+        (0, traverse_1.default)(ast, {
+            // Detect top-level await - can be handled with async IIFE wrapper
             AwaitExpression(path) {
                 // Check if await is at top level (not inside a function)
                 let parent = path.parentPath;
@@ -82,14 +113,14 @@ function detectUnsupportedESMFeatures(code, filename) {
                     parent = parent.parentPath;
                 }
                 if (isTopLevel) {
-                    unsupportedFeatures.push({
+                    topLevelAwait.push({
                         feature: 'top-level await',
                         line: path.node.loc?.start.line ?? null,
                         column: path.node.loc?.start.column ?? null,
                     });
                 }
             },
-            // Detect for-await-of at top level
+            // Detect for-await-of at top level - can be handled with async IIFE wrapper
             ForOfStatement(path) {
                 if (path.node.await) {
                     let parent = path.parentPath;
@@ -106,7 +137,7 @@ function detectUnsupportedESMFeatures(code, filename) {
                         parent = parent.parentPath;
                     }
                     if (isTopLevel) {
-                        unsupportedFeatures.push({
+                        topLevelAwait.push({
                             feature: 'top-level for-await-of',
                             line: path.node.loc?.start.line ?? null,
                             column: path.node.loc?.start.column ?? null,
@@ -115,14 +146,51 @@ function detectUnsupportedESMFeatures(code, filename) {
                 }
             },
         });
-        return unsupportedFeatures;
+        return { topLevelAwait, unsupportedFeatures };
     }
     catch (error) {
         // If we can't parse, return null to let the transform attempt proceed
-        log_1.log.debug(`Could not parse ${filename} to detect unsupported ESM features: ${error instanceof Error ? error.message : String(error)}`);
+        log_1.log.debug(`Could not parse ${filename} to detect ESM features: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }
+/**
+ * Replace esbuild's empty import_meta object with a proper implementation
+ *
+ * When esbuild transforms ESM to CJS, it converts `import.meta` to a `const import_meta = {}`.
+ * This function replaces that empty object with a proper implementation of import.meta properties.
+ *
+ * Shims provided:
+ * - import.meta.url: File URL of the current module
+ * - import.meta.dirname: Directory path of the current module (Node.js 20.11+)
+ * - import.meta.filename: File path of the current module (Node.js 20.11+)
+ *
+ * Based on approach from tsup and esbuild discussions
+ * @see https://github.com/egoist/tsup/blob/main/assets/cjs_shims.js
+ * @see https://github.com/evanw/esbuild/issues/3839
+ *
+ * @param code - The transformed CJS code from esbuild
+ * @returns Code with import_meta properly implemented
+ */
+function replaceImportMetaObject(code) {
+    // esbuild generates: const import_meta = {};
+    // We need to replace this with a proper implementation
+    // Note: We use getters to ensure values are computed at runtime in the correct context
+    const shimImplementation = `const import_meta = {
+  get url() {
+    return require('url').pathToFileURL(__filename).href;
+  },
+  get dirname() {
+    return __dirname;
+  },
+  get filename() {
+    return __filename;
+  }
+};`;
+    // Replace esbuild's empty import_meta object with our implementation
+    // Match: const import_meta = {};
+    return code.replace(/const import_meta\s*=\s*\{\s*\};/, shimImplementation);
+}
 /**
  * Transform ESM code to CommonJS using esbuild
  * This allows ESM modules to be compiled to bytecode via vm.Script
@@ -141,10 +209,13 @@ function transformESMtoCJS(code, filename) {
             isTransformed: false,
         };
     }
-    // First, check for unsupported ESM features that can't be safely transformed
-    const unsupportedFeatures = detectUnsupportedESMFeatures(code, filename);
-    if (unsupportedFeatures && unsupportedFeatures.length > 0) {
-        const featureList = unsupportedFeatures
+    // First, check for ESM features that need special handling
+    const esmFeatures = detectESMFeatures(code, filename);
+    // Handle truly unsupported features (import.meta)
+    if (esmFeatures &&
+        esmFeatures.unsupportedFeatures &&
+        esmFeatures.unsupportedFeatures.length > 0) {
+        const featureList = esmFeatures.unsupportedFeatures
             .map((f) => {
             const location = f.line !== null ? ` at line ${f.line}` : '';
             return `  - ${f.feature}${location}`;
@@ -169,15 +240,100 @@ function transformESMtoCJS(code, filename) {
             isTransformed: false,
         };
     }
+    // Check if we need to wrap in async IIFE for top-level await
+    const hasTopLevelAwait = esmFeatures &&
+        esmFeatures.topLevelAwait &&
+        esmFeatures.topLevelAwait.length > 0;
+    let codeToTransform = code;
+    // If top-level await is detected, we need to wrap in async IIFE
+    // But we must handle imports and exports specially
+    if (hasTopLevelAwait) {
+        try {
+            // Parse the code to check for exports and collect imports
+            const ast = babel.parse(code, {
+                sourceType: 'module',
+                plugins: [],
+            });
+            let hasExports = false;
+            const codeLines = code.split('\n');
+            const importLineIndices = new Set();
+            (0, traverse_1.default)(ast, {
+                ExportNamedDeclaration() {
+                    hasExports = true;
+                },
+                ExportDefaultDeclaration() {
+                    hasExports = true;
+                },
+                ExportAllDeclaration() {
+                    hasExports = true;
+                },
+                ImportDeclaration(path) {
+                    // Track import statements by line number
+                    const { loc } = path.node;
+                    if (loc) {
+                        const { start, end } = loc;
+                        for (let i = start.line; i <= end.line; i += 1) {
+                            importLineIndices.add(i - 1); // Convert to 0-based index
+                        }
+                    }
+                },
+            });
+            if (hasExports) {
+                // If the file has exports, we can't wrap it in an IIFE
+                // because exports need to be synchronous and at the top level.
+                log_1.log.warn(`Module ${filename} has both top-level await and export statements. ` +
+                    `This combination cannot be safely transformed to CommonJS in pkg's ESM transformer. ` +
+                    `The original source code will be used as-is; depending on the package visibility and build configuration, ` +
+                    `bytecode compilation may fail and the module may need to be loaded from source or be skipped.`);
+                return {
+                    code,
+                    isTransformed: false,
+                };
+            }
+            // If there are imports, extract them to keep outside the async IIFE
+            if (importLineIndices.size > 0) {
+                const imports = [];
+                const rest = [];
+                codeLines.forEach((line, index) => {
+                    if (importLineIndices.has(index)) {
+                        imports.push(line);
+                    }
+                    else {
+                        rest.push(line);
+                    }
+                });
+                // Reconstruct: imports at top, then async IIFE wrapping the rest
+                codeToTransform = `${imports.join('\n')}\n${ASYNC_IIFE_WRAPPER.prefix}${rest.join('\n')}${ASYNC_IIFE_WRAPPER.suffix}`;
+                log_1.log.debug(`Wrapping ${filename} in async IIFE with imports extracted to top level`);
+            }
+            else {
+                // No imports, wrap everything
+                codeToTransform =
+                    ASYNC_IIFE_WRAPPER.prefix + code + ASYNC_IIFE_WRAPPER.suffix;
+                log_1.log.debug(`Wrapping ${filename} in async IIFE to support top-level await`);
+            }
+        }
+        catch (parseError) {
+            // If we can't parse, wrap everything and hope for the best
+            codeToTransform =
+                ASYNC_IIFE_WRAPPER.prefix + code + ASYNC_IIFE_WRAPPER.suffix;
+            log_1.log.warn(`Could not parse ${filename} to detect exports/imports (${parseError instanceof Error ? parseError.message : String(parseError)}). ` +
+                `Wrapping entire code in async IIFE - this may fail if the module has export or import statements.`);
+        }
+    }
+    // Check if code uses import.meta before transformation
+    const usesImportMeta = hasImportMeta(code);
     try {
-        const result = esbuild.transformSync(code, {
+        // Build esbuild options
+        const esbuildOptions = {
             loader: 'js',
             format: 'cjs',
-            target: 'node18',
+            target: 'node20',
             sourcemap: false,
             minify: false,
             keepNames: true,
-        });
+        };
+        const result = esbuild.transformSync(codeToTransform, esbuildOptions);
         if (!result || !result.code) {
             log_1.log.warn(`esbuild transform returned no code for ${filename}`);
             return {
@@ -185,8 +341,13 @@ function transformESMtoCJS(code, filename) {
                 isTransformed: false,
             };
         }
+        // Inject import.meta shims after esbuild transformation if needed
+        let finalCode = result.code;
+        if (usesImportMeta) {
+            finalCode = replaceImportMetaObject(result.code);
+        }
         return {
-            code: result.code,
+            code: finalCode,
             isTransformed: true,
         };
     }

package/lib-es5/fabricator.js

@@ -64,19 +64,16 @@ function fabricate(bakes, fabricator, snap, body, cb) {
     }
     let stdout = Buffer.alloc(0);
     function onError(error) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         removeListeners();
         kill();
         cb(new Error(`Failed to make bytecode ${fabricator.nodeRange}-${fabricator.arch} for file ${snap} error (${error.message})`));
     }
     function onClose(code) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         removeListeners();
         kill();
         if (code !== 0) {
             return cb(new Error(`Failed to make bytecode ${fabricator.nodeRange}-${fabricator.arch} for file ${snap}`));
         }
-        // eslint-disable-next-line no-console
         console.log(stdout.toString());
         return cb(new Error(`${cmd} closed unexpectedly`));
     }
@@ -87,7 +84,6 @@ function fabricate(bakes, fabricator, snap, body, cb) {
             if (stdout.length >= 4 + sizeOfBlob) {
                 const blob = Buffer.alloc(sizeOfBlob);
                 stdout.copy(blob, 0, 4, 4 + sizeOfBlob);
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
                 removeListeners();
                 return cb(undefined, blob);
             }

package/lib-es5/follow.js

@@ -114,7 +114,7 @@ function follow(x, opts) {
                 // CJS package - fall through to standard CommonJS resolution
                 // to handle all callbacks properly
             }
-            catch (error) {
+            catch (_error) {
                 // ESM resolution failed - fall through to standard CommonJS resolution
             }
         }

package/lib-es5/help.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const colors_1 = require("./colors");
 function help() {
-    // eslint-disable-next-line no-console
     console.log(`
   ${colors_1.pc.bold('pkg')} [options] <input>
 
@@ -34,7 +33,7 @@ function help() {
   ${colors_1.pc.gray('–')} Makes executable for particular target machine
     ${colors_1.pc.cyan('$ pkg -t node14-win-arm64 index.js')}
   ${colors_1.pc.gray('–')} Makes executables for target machines of your choice
-    ${colors_1.pc.cyan('$ pkg -t node16-linux,node18-linux,node18-win index.js')}
+    ${colors_1.pc.cyan('$ pkg -t node22-linux,node24-linux,node24-win index.js')}
   ${colors_1.pc.gray('–')} Bakes '--expose-gc' and '--max-heap-size=34' into executable
     ${colors_1.pc.cyan('$ pkg --options "expose-gc,max-heap-size=34" index.js')}
   ${colors_1.pc.gray('–')} Consider packageA and packageB to be public

package/lib-es5/index.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable require-atomic-updates */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,7 +29,6 @@ function isConfiguration(file) {
 }
 // http://www.openwall.com/lists/musl/2012/12/08/4
 const { hostArch, hostPlatform, isValidNodeRange, knownArchs, knownPlatforms, toFancyArch, toFancyPlatform, } = pkg_fetch_1.system;
-// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 const hostNodeRange = `node${process.version.match(/^v(\d+)/)[1]}`;
 function parseTargets(items) {
     // [ 'node6-macos-x64', 'node6-linux-x64' ]
@@ -191,7 +189,6 @@ async function exec(argv2) {
     }
     // version
     if (argv.v || argv.version) {
-        // eslint-disable-next-line no-console
         console.log(version);
         return;
     }
@@ -218,7 +215,6 @@ async function exec(argv2) {
             throw (0, log_1.wasReported)(`Invalid compression algorithm ${algo} ( should be None, Brotli or Gzip)`);
     }
     if (doCompress !== compress_type_1.CompressType.None) {
-        // eslint-disable-next-line no-console
         console.log('compression: ', compress_type_1.CompressType[doCompress]);
     }
     // _
@@ -288,7 +284,7 @@ async function exec(argv2) {
         if (!(0, fs_1.existsSync)(config)) {
             throw (0, log_1.wasReported)('Config file does not exist', [config]);
         }
-        // eslint-disable-next-line import/no-dynamic-require, global-require
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
         configJson = require(config); // may be either json or js
         if (!configJson.name &&
             !configJson.files &&

package/lib-es5/packer.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable complexity */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -27,13 +26,22 @@ function hasAnyStore(record) {
 }
 function packer({ records, entrypoint, bytecode, }) {
     const stripes = [];
-    for (const snap in records) {
+    // If the entrypoint was a .mjs file that got transformed, update its extension
+    if (records[entrypoint]?.wasTransformed && entrypoint.endsWith('.mjs')) {
+        entrypoint = `${entrypoint.slice(0, -4)}.js`;
+    }
+    for (let snap in records) {
         if (records[snap]) {
             const record = records[snap];
             const { file } = record;
             if (!hasAnyStore(record)) {
                 continue;
             }
+            // If .mjs file was transformed to CJS, rename it to .js in the snapshot
+            // This prevents Node.js from treating it as an ES module
+            if (record.wasTransformed && snap.endsWith('.mjs')) {
+                snap = `${snap.slice(0, -4)}.js`;
+            }
             (0, assert_1.default)(record[common_1.STORE_STAT], 'packer: no STORE_STAT');
             (0, assert_1.default)(record[common_1.STORE_BLOB] ||
                 record[common_1.STORE_CONTENT] ||

package/lib-es5/resolver.js

@@ -52,7 +52,7 @@ function resolveWithExports(packageName, subpath, packageRoot) {
         }
         return null;
     }
-    catch (error) {
+    catch (_error) {
         log_1.log.debug(`Failed to resolve with exports field: ${packageName}${subpath}`);
         return null;
     }

package/lib-es5/walker.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable require-atomic-updates */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -838,7 +837,7 @@ class Walker {
                         record.body = Buffer.from(JSON.stringify(pkgContent, null, 2), 'utf8');
                     }
                 }
-                catch (error) {
+                catch (_error) {
                     // Ignore JSON parsing errors
                 }
             }
@@ -852,6 +851,10 @@ class Walker {
                         const result = (0, esm_transformer_1.transformESMtoCJS)(record.body.toString('utf8'), record.file);
                         if (result.isTransformed) {
                             record.body = Buffer.from(result.code, 'utf8');
+                            // Mark .mjs files as transformed so packer can rename them to .js
+                            if (record.file.endsWith('.mjs')) {
+                                record.wasTransformed = true;
+                            }
                         }
                     }
                     catch (error) {
@@ -927,7 +930,6 @@ class Walker {
         switch (store) {
             case common_1.STORE_BLOB:
             case common_1.STORE_CONTENT:
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 await this.step_STORE_ANY(record, task.marker, store);
                 break;
             case common_1.STORE_LINKS:
@@ -952,7 +954,7 @@ class Walker {
                 if (this.params.noDictionary?.includes(file)) {
                     continue;
                 }
-                // eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
                 const config = require(path_1.default.join(dd, file));
                 this.dictionary[name] = config;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yao-pkg/pkg",
-  "version": "6.13.0",
+  "version": "6.14.0",
   "description": "Package your Node.js project into an executable",
   "main": "lib-es5/index.js",
   "license": "MIT",
@@ -26,9 +26,9 @@
     "@babel/parser": "^7.23.0",
     "@babel/traverse": "^7.23.0",
     "@babel/types": "^7.23.0",
-    "esbuild": "^0.24.0",
     "@yao-pkg/pkg-fetch": "3.5.32",
-    "into-stream": "^6.0.0",
+    "esbuild": "^0.27.3",
+    "into-stream": "^9.1.0",
     "minimist": "^1.2.6",
     "multistream": "^4.1.0",
     "picocolors": "^1.1.0",
@@ -37,35 +37,36 @@
     "resolve": "^1.22.10",
     "resolve.exports": "^2.0.3",
     "stream-meter": "^1.0.4",
-    "tar": "^7.5.6",
+    "tar": "^7.5.7",
     "tinyglobby": "^0.2.11",
     "unzipper": "^0.12.3"
   },
   "devDependencies": {
-    "@release-it/conventional-changelog": "^7.0.2",
+    "@release-it/conventional-changelog": "^10.0.5",
     "@types/babel__generator": "^7.6.5",
     "@types/babel__traverse": "^7.20.3",
     "@types/minimist": "^1.2.2",
     "@types/multistream": "^4.1.0",
-    "@types/node": "^16.18.113",
+    "@types/node": "^20.0.0",
     "@types/picomatch": "^3.0.1",
     "@types/resolve": "^1.20.2",
     "@types/stream-meter": "^0.0.22",
     "@types/tar": "^6.1.13",
     "@types/unzipper": "^0.10.10",
-    "@typescript-eslint/eslint-plugin": "^6.7.4",
-    "@typescript-eslint/parser": "^6.7.4",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
     "esbuild-register": "^3.6.0",
-    "eslint": "^8.50.0",
+    "eslint": "^9.0.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^17.1.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.28.1",
+    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^17.3.0",
     "json-stable-stringify": "^1.0.1",
-    "lint-staged": "^15.2.10",
+    "lint-staged": "^15.0.0",
     "prettier": "^3.0.3",
-    "release-it": "^16.2.1",
-    "rimraf": "^3.0.2",
+    "release-it": "^19.2.4",
+    "rimraf": "^6.1.2",
     "simple-git-hooks": "^2.11.1",
     "typescript": "^4.7.2"
   },
@@ -79,9 +80,10 @@
     "fix": "npm run lint:style -- -w && npm run lint:code -- --fix",
     "prepare": "npm run build",
     "prepublishOnly": "npm run lint",
-    "test": "npm run build && npm run test:host && npm run test:18 && npm run test:20",
+    "test": "npm run build && npm run test:host && npm run test:20 && npm run test:22 && npm run test:24",
     "test:20": "node test/test.js node20 no-npm",
-    "test:18": "node test/test.js node18 no-npm",
+    "test:22": "node test/test.js node22 no-npm",
+    "test:24": "node test/test.js node24 no-npm",
     "test:host": "node test/test.js host only-npm",
     "bump:fetch": "yarn add @yao-pkg/pkg-fetch --exact",
     "release": "read -p 'GITHUB_TOKEN: ' GITHUB_TOKEN && export GITHUB_TOKEN=$GITHUB_TOKEN && release-it"
@@ -97,6 +99,15 @@
   },
   "packageManager": "yarn@1.22.22",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
+  },
+  "resolutions": {
+    "lodash": "^4.17.23",
+    "@octokit/request-error": "^5.1.1",
+    "@octokit/plugin-paginate-rest": "^9.2.2",
+    "@octokit/request": "^8.4.1",
+    "js-yaml": "^4.1.1",
+    "brace-expansion": "^2.0.2",
+    "tmp": "^0.2.4"
   }
 }

package/prelude/bootstrap.js

@@ -1,9 +1,3 @@
-/* eslint-disable import/no-unresolved */
-/* eslint-disable global-require */
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable prefer-rest-params */
-/* eslint-disable prefer-spread */
-
 /* global EXECPATH_FD */
 /* global PAYLOAD_POSITION */
 /* global PAYLOAD_SIZE */

package/prelude/diagnostic.js

@@ -1,5 +1,3 @@
-/* eslint-disable global-require */
-/* eslint-disable no-console */
 /* global DICT */
 
 'use strict';