portapack 0.2.1 → 0.3.0

package/docs/cli.md

@@ -1,117 +1,233 @@
-# ⚙️ CLI Reference
+# ⚙️ PortaPack CLI Reference
 
-PortaPack provides a powerful command-line interface for bundling HTML files and websites.
+PortaPack provides a powerful command-line interface (CLI) for bundling local HTML files and remote websites into single, portable HTML files.
 
 ## Installation
 
-To use the CLI, install PortaPack globally:
+To use the CLI, install PortaPack globally using npm (or your preferred package manager):
 
 ```bash
 npm install -g portapack
+# or
+# yarn global add portapack
+# or
+# pnpm add -g portapack
 ```
 
 ## Command Syntax
 
-The basic command structure is:
+PortaPack supports two command styles for specifying input:
 
 ```bash
-portapack [options]
+# Positional argument style (recommended)
+portapack <path_or_url> [options]
+
+# Named argument style
+portapack --input <path_or_url> [options]
+# or using shorthand
+portapack -i <path_or_url> [options]
 ```
 
+Both methods work identically - choose whichever you prefer.
+
 ## Options
 
 | Option | Shorthand | Description | Default |
-|--------|----------|------------|---------|
-| `--input <path>` | `-i` | Input file or URL to process | - |
-| `--output <file>` | `-o` | Output file path | `{input}.packed.html` |
-| `--minify [level]` | `-m` | Minification level (0-3) | `2` |
-| `--no-minify` | - | Disable minification | - |
-| `--recursive [depth]` | `-r` | Recursively bundle links up to specified depth | - |
-| `--base-url <url>` | `-b` | Base URL for resolving relative URLs | - |
-| `--dry-run` | `-d` | Show what would be done without writing files | - |
-| `--verbose` | `-v` | Enable verbose logging | - |
-| `--help` | `-h` | Show help information | - |
-| `--version` | - | Show version information | - |
+|--------|-----------|-------------|---------|
+| `<path_or_url>` or `--input <path_or_url>` | `-i` | Required. Input local file path or remote URL (http/https) to process. | - |
+| `--output <file>` | `-o` | Output file path for the bundled HTML. | `{input}.packed.html` |
+| `--minify` | `-m` | Enable all minification (HTML, CSS, JS). | - |
+| `--no-minify` | | Disable all asset minification (HTML, CSS, JS). | `false` |
+| `--no-minify-html` | | Disable only HTML minification. | `false` |
+| `--no-minify-css` | | Disable only CSS minification. | `false` |
+| `--no-minify-js` | | Disable only JavaScript minification. | `false` |
+| `--recursive [depth]` | `-r` | Recursively bundle links up to depth. If depth omitted, defaults to 1. Only applies to remote URLs. | - (disabled) |
+| `--max-depth <n>` | | Set maximum depth for recursive crawling (alternative to `-r <n>`). | - |
+| `--base-url <url>` | `-b` | Base URL for resolving relative URLs found in the input HTML. | Input path/URL |
+| `--embed-assets` | `-e` | Embed external assets (CSS, JS, images, fonts) as data URIs or inline content. | `true` |
+| `--no-embed-assets` | | Keep external assets as links (requires network access when viewing). | `false` |
+| `--timeout <ms>` | `-t` | Network timeout in milliseconds for fetching remote resources. | `30000` (30 seconds) |
+| `--user-agent <string>` | `-U` | Custom User-Agent string for network requests. | Default Node.js agent |
+| `--include <glob>` | | Glob pattern for URLs to include during recursion (can be specified multiple times). | `**` (all) |
+| `--exclude <glob>` | | Glob pattern for URLs to exclude during recursion (can be specified multiple times). | - |
+| `--log-level <level>` | `-l` | Set logging level (debug, info, warn, error, silent). | `info` |
+| `--verbose` | `-v` | Enable verbose logging (shortcut for `--log-level debug`). | `false` |
+| `--config <path>` | `-c` | Path to a configuration file (e.g., `.portapackrc.json`) to load options from. | - |
+| `--dry-run` | `-d` | Perform all steps except writing the output file. Logs intended actions. | `false` |
+| `--help` | `-h` | Show help information and exit. | - |
+| `--version` | | Show PortaPack CLI version number and exit. | - |
 
 ## Examples
 
-### Basic Usage
+### Basic Local File Bundling
 
-Bundle a local HTML file:
+Bundle `index.html` into `bundle.html`:
 
 ```bash
+# Using positional argument style
+portapack ./index.html -o bundle.html
+
+# Using named argument style
 portapack -i ./index.html -o bundle.html
 ```
 
+Use default output name (`index.html.packed.html`):
+
+```bash
+# Using positional argument style
+portapack ./index.html
+
+# Using named argument style
+portapack -i ./index.html
+```
+
 ### Web Page Bundling
 
-Bundle a remote website:
+Bundle a single remote webpage:
 
 ```bash
+# Using positional argument style
+portapack https://example.com -o example-bundle.html
+
+# Using named argument style
 portapack -i https://example.com -o example-bundle.html
 ```
 
 ### Recursive Bundling
 
-Bundle a website and follow its links to a depth of 2:
+Bundle a website, following links 1 level deep:
+
+```bash
+portapack https://example.com -r -o site-bundle-depth1.html
+```
+
+Bundle a website, following links up to 2 levels deep:
+
+```bash
+portapack https://example.com -r 2 -o site-bundle-depth2.html
+```
+
+Alternative using `--max-depth` option:
+
+```bash
+portapack https://example.com --max-depth 2 -o site-bundle-depth2.html
+```
+
+Recursively bundle only blog posts, excluding images:
 
 ```bash
-portapack -i https://example.com -r 2 -o site-bundle.html
+portapack https://example.com -r \
+  --include "/blog/**" \
+  --exclude "**/*.{jpg,png,gif}" \
+  -o blog-bundle.html
+```
+
+### Asset Handling
+
+Bundle without embedding assets (keep external links):
+
+```bash
+portapack ./index.html --no-embed-assets -o linked-assets.html
+```
+
+Default behavior is to embed assets (which you can make explicit):
+
+```bash
+portapack ./index.html --embed-assets -o embedded-assets.html
 ```
 
 ### Minification Control
 
-Apply maximum minification:
+Apply all minification:
+
+```bash
+portapack ./index.html -m -o min-bundle.html
+```
+
+Disable minification completely:
+
+```bash
+portapack ./index.html --no-minify -o unmin-bundle.html
+```
+
+Selectively control minification:
 
 ```bash
-portapack -i ./index.html -m 3 -o min-bundle.html
+# Minify CSS and JS but not HTML
+portapack ./index.html --no-minify-html -o selective-min.html
+
+# Minify HTML and CSS but not JS
+portapack ./index.html --no-minify-js -o no-js-min.html
 ```
 
-Disable minification:
+### Advanced Network Options
+
+Bundle a remote page with a longer timeout and custom user agent:
 
 ```bash
-portapack -i ./index.html --no-minify -o unmin-bundle.html
+portapack https://example.com -t 60000 -U "MyCustomBot/1.0" -o example-custom.html
 ```
 
 ### Base URL for Relative Links
 
-Specify a base URL for resolving relative paths:
+Process a local file as if it were hosted at https://example.com:
 
 ```bash
-portapack -i ./index.html -b https://example.com -o bundle.html
+portapack ./docs/index.html -b https://example.com/docs/ -o bundle.html
+```
+
+### Logging and Debugging
+
+Enable detailed debug logs:
+
+```bash
+portapack ./index.html -v -o bundle-debug.html
+```
+
+Only show errors:
+
+```bash
+portapack ./index.html --log-level error -o bundle-errors-only.html
 ```
 
 ### Dry Run
 
-Preview what would be bundled without creating an output file:
+See what files and assets would be processed without saving:
 
 ```bash
-portapack -i ./index.html --dry-run
+portapack ./index.html --dry-run
 ```
 
-### Verbose Logging
+### Using a Configuration File
 
-Enable detailed logs during bundling:
+Load options from a config file:
 
 ```bash
-portapack -i ./index.html -v -o bundle.html
+portapack -c ./.portapackrc.json
+```
+
+### NPX Usage
+
+Use PortaPack without installing globally:
+
+```bash
+npx portapack ./index.html -o bundle.html
 ```
 
 ## Exit Codes
 
 | Code | Description |
 |------|-------------|
-| `0` | Success |
-| `1` | Error (missing input, invalid URL, processing error, etc.) |
-
-## Environment Variables
+| 0 | Success |
+| 1 | General Error (e.g., invalid options, file IO) |
+| 2 | Input Error (e.g., missing input, invalid URL) |
+| 3 | Network Error (e.g., fetch failed, timeout) |
+| 4 | Processing Error (e.g., parsing failed) |
 
-| Variable | Description |
-|----------|-------------|
-| `NODE_ENV` | Set to `test` during testing to suppress console output |
+(Note: Specific error codes might vary)
 
 ## Related Resources
 
-- [Getting Started](/getting-started)
-- [API Reference](/api/README)
-- [Configuration Guide](/configuration)
+- Getting Started (Link needs validation)
+- API Reference (Link needs validation)
+- Configuration Guide (Link needs validation)

package/jest.config.ts

@@ -5,7 +5,8 @@ const config: Config = {
   /**
    * Use ts-jest with ESM support.
    */
-  preset: 'ts-jest/presets/default-esm',
+  // preset: 'ts-jest/presets/default-esm',
+  preset: 'ts-jest',
 
   /**
    * Node test environment
@@ -20,16 +21,25 @@ const config: Config = {
   /**
    * Tell ts-jest to use ESM transformation
    */
+  // transform: {
+  //   '^.+\\.tsx?$': [
+  //     'ts-jest',
+  //     {
+  //       useESM: true,
+  //       tsconfig: './tsconfig.jest.json'
+  //     }
+  //   ]
+  // },
+
   transform: {
     '^.+\\.tsx?$': [
       'ts-jest',
       {
-        useESM: true,
-        tsconfig: './tsconfig.jest.json'
+        // useESM: false, // Explicitly false or remove this line entirely
+        tsconfig: './tsconfig.jest.json' // Ensure this tsconfig targets CommonJS
       }
     ]
   },
-
   /**
    * Treat `.ts` files as ESM modules.
    */
@@ -68,10 +78,10 @@ const config: Config = {
    */
   coverageThreshold: {
     global: {
-      branches: 60,
-      functions: 60,
-      lines: 60,
-      statements: 60,
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70,
     },
   },
 

package/jest.setup.cjs

@@ -1,211 +1,131 @@
-/**
- * @file jest.setup.cjs
- * @description Jest global setup script executed before test suites run (per file).
- * Responsible for creating temporary directories for test outputs and fixtures,
- * setting up mock data (like the sample project), and cleaning up afterwards.
- * Uses CommonJS syntax as Jest setup files often run in a CJS context.
- */
-
-// Node.js core modules required for setup
-const fs = require('fs/promises'); // Using promises API for async operations
+// jest.setup.cjs
+const fs = require('fs/promises');
 const path = require('path');
 const crypto = require('crypto');
 const os = require('os');
+// const jest = require('@jest/globals'); // REMOVE THIS LINE
 
-// Generate a unique ID for each test execution session.
-// This helps isolate test runs if running concurrently or prevents conflicts
-// if cleanup fails on a previous run.
 const TEST_RUN_ID = crypto.randomBytes(4).toString('hex');
-
-// Helper function for resolving paths relative to this setup file's directory
-// (usually the project root or a specific test config directory)
 const resolve = (...args) => path.resolve(__dirname, ...args);
 
-/**
- * Utility function to ensure a directory exists.
- * Creates the directory recursively if it doesn't exist.
- * Ignores 'EEXIST' error if the directory is already present.
- * @param {string} dir - The absolute path of the directory to ensure.
- * @returns {Promise<void>}
- * @throws {Error} Throws errors other than 'EEXIST' during directory creation.
- */
+// Use the *original* console.log temporarily for setup debugging
+const originalSetupLog = console.log;
+
 const ensureDir = async (dir) => {
     try {
         await fs.mkdir(dir, { recursive: true });
     } catch (e) {
-        // If the error is simply that the directory already exists, ignore it.
         if (e.code !== 'EEXIST') {
-            console.error(`Failed to ensure directory ${dir}:`, e); // Log unexpected errors
-            throw e; // Re-throw other errors
+            originalSetupLog(`[SETUP-ERROR] Failed to ensure directory ${dir}:`, e);
+            throw e;
         }
     }
 };
 
-// Define the base temporary directory using the OS's temp location and the unique run ID.
-// Using os.tmpdir() is generally safer regarding permissions and OS conventions.
 const tempDir = path.join(os.tmpdir(), 'portapack-tests', TEST_RUN_ID);
-
-/**
- * Object containing base paths for various test-related directories.
- * These are constructed relative to the main temporary directory.
- */
+// *** Make sure baseDirs is defined ***
+// (Assuming it was defined correctly before the placeholder comment)
 const baseDirs = {
-    root: resolve(), // Project root (where jest.config / setup file likely is)
-    output: path.join(tempDir, 'test-output'), // General output for test artifacts
-    fixtures: path.join(tempDir, '__fixtures__'), // Base for fixture data (if needed)
-    fixturesOutput: path.join(tempDir, '__fixtures__/output'), // Output specifically related to fixtures
-    sampleProject: path.join(tempDir, 'sample-project') // Directory for the mock HTML project
+    root: resolve(), // Project root
+    output: path.join(tempDir, 'test-output'), // General output
+    fixtures: path.join(tempDir, '__fixtures__'), // Base for fixtures
+    fixturesOutput: path.join(tempDir, '__fixtures__/output'), // Fixture output
+    sampleProject: path.join(tempDir, 'sample-project') // Mock project dir
 };
+// **********************************
 
-/**
- * Jest's global beforeAll hook. Runs once before any tests in a suite file execute.
- * Sets up the necessary directory structure and global variables/mocks for tests.
- */
+
+// --- Use Jest's GLOBAL beforeAll/afterAll/jest ---
+// These are available globally in setup files
 beforeAll(async () => {
-    console.log(`Setting up test environment in: ${tempDir}`); // Log setup start
+    originalSetupLog(`[SETUP] Starting setup in: ${tempDir}`);
 
-    // Create essential output/fixture directories early.
-    // Using Promise.all here is likely safe as they are independent paths.
+    originalSetupLog('[SETUP] Ensuring baseDirs...');
+    // Make sure baseDirs is defined before using it
+    if (!baseDirs || !baseDirs.output || !baseDirs.fixturesOutput) {
+        throw new Error("baseDirs is not properly defined!");
+    }
     await Promise.all([
         ensureDir(baseDirs.output),
         ensureDir(baseDirs.fixturesOutput)
     ]);
+    originalSetupLog('[SETUP] BaseDirs ensured.');
 
-    // Define paths specific to this test run using the TEST_RUN_ID for further isolation.
+    originalSetupLog('[SETUP] Creating runDirs...');
     const runDirs = {
         uniqueOutput: path.join(baseDirs.output, TEST_RUN_ID),
         uniqueFixturesOutput: path.join(baseDirs.fixturesOutput, TEST_RUN_ID)
     };
-
-    // Create the run-specific directories.
     await Promise.all([
         fs.mkdir(runDirs.uniqueOutput, { recursive: true }),
         fs.mkdir(runDirs.uniqueFixturesOutput, { recursive: true })
     ]);
+    originalSetupLog('[SETUP] RunDirs created.');
 
-    // --- Set up global variables accessible within tests ---
-    // This provides a consistent way for tests to access temporary paths.
-    global.__TEST_DIRECTORIES__ = {
-        ...baseDirs,
-        ...runDirs
-    };
-
-    // Helper function for tests to get a path within the unique test output directory.
-    global.getTestFilePath = (relPath) =>
-        path.join(global.__TEST_DIRECTORIES__.uniqueOutput, relPath);
-
-    // Helper function for tests to get a path within the unique fixture output directory.
-    global.getTestFixturePath = (relPath) =>
-        path.join(global.__TEST_DIRECTORIES__.uniqueFixturesOutput, relPath);
+    originalSetupLog('[SETUP] Setting globals...');
+    global.__TEST_DIRECTORIES__ = { ...baseDirs, ...runDirs };
+    global.getTestFilePath = (relPath) => path.join(global.__TEST_DIRECTORIES__.uniqueOutput, relPath);
+    global.getTestFixturePath = (relPath) => path.join(global.__TEST_DIRECTORIES__.uniqueFixturesOutput, relPath);
+    originalSetupLog('[SETUP] Globals set.');
 
-    // --- Create specific mock files needed by certain tests ---
-    // Example: Creating virtual font files for font processing tests.
-    await ensureDir(path.dirname(path.join(tempDir, 'font.woff2'))); // Ensure parent dir exists
+    originalSetupLog('[SETUP] Ensuring mock font dirs...');
+    if (!tempDir) throw new Error("tempDir is not defined before font dir creation!");
+    await ensureDir(path.dirname(path.join(tempDir, 'font.woff2')));
     await ensureDir(path.dirname(path.join(tempDir, 'font.ttf')));
-    // No need to ensureDir for 'missing.ttf' as we only need the path, not the file
+    originalSetupLog('[SETUP] Mock font dirs ensured.');
 
-    // Write mock content to the font files.
+    originalSetupLog('[SETUP] Writing mock font files...');
     await fs.writeFile(path.join(tempDir, 'font.woff2'), 'mock woff2 data');
     await fs.writeFile(path.join(tempDir, 'font.ttf'), 'mock ttf data');
-
-    // Set up a global variable pointing to the temp directory for potential use in mocks.
     global.__MOCK_FILE_PATH__ = tempDir;
+    originalSetupLog('[SETUP] Mock font files written.');
 
-    // --- Create the stub/mock sample HTML project ---
-    // **FIX APPLIED HERE:** Ensure directory exists *before* writing files into it
-    // to prevent ENOENT race conditions.
-
-    console.log(`Ensuring sample project directory exists: ${baseDirs.sampleProject}`);
-    // 1. Ensure the sample project directory exists FIRST
+    originalSetupLog('[SETUP] Ensuring sample project dir...');
+    if (!baseDirs || !baseDirs.sampleProject) throw new Error("baseDirs.sampleProject is not defined!");
     await ensureDir(baseDirs.sampleProject);
+    originalSetupLog('[SETUP] Sample project dir ensured.');
 
-    // 2. THEN write all the files into it using Promise.all for concurrency (safe now).
+    originalSetupLog('[SETUP] Writing sample project files...');
     try {
-        console.log(`Writing sample project files to ${baseDirs.sampleProject}...`);
         await Promise.all([
-            fs.writeFile(
-                path.join(baseDirs.sampleProject, 'index.html'),
-                `<!DOCTYPE html><html><head><link rel="stylesheet" href="styles.css"></head><body><img src="logo.png"/><script src="script.js"></script></body></html>`
-            ),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'styles.css'), 'body { margin: 0; }'),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'script.js'), `console.log('hello');`),
-            fs.writeFile(path.join(baseDirs.sampleProject, 'logo.png'), 'fake image data') // Using string for simplicity
+            fs.writeFile(path.join(baseDirs.sampleProject, 'index.html'), ``),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'styles.css'), '/* Mock CSS */'),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'script.js'), '// Mock JS'),
+            fs.writeFile(path.join(baseDirs.sampleProject, 'logo.png'), 'fake image data')
         ]);
-        console.log(`Successfully wrote sample project files.`);
+        originalSetupLog('[SETUP] Sample project files written.');
     } catch (writeError) {
-        console.error(`Failed to write sample project files to ${baseDirs.sampleProject}:`, writeError);
-        // Depending on setup needs, you might want to stop the tests here.
-        throw writeError; // Re-throw to potentially fail the setup.
+        originalSetupLog('[SETUP-ERROR] Failed to write sample project files:', writeError);
+        throw writeError;
     }
-    // --- End Fix ---
 
-    // --- Mock console methods ---
-    // This helps keep test output clean and allows assertions on console messages.
+    originalSetupLog('[SETUP] Mocking console...');
     const originalLog = console.log;
     const originalWarn = console.warn;
     const originalError = console.error;
+    // Use the GLOBAL `jest` object to access `fn`
+    global.console.log = jest.fn((...args) => { if (process.env.DEBUG) originalLog(...args); });
+    global.console.warn = jest.fn((...args) => { /* ... filtering logic ... */ if (process.env.DEBUG) originalWarn(...args); });
+    global.console.error = jest.fn((...args) => { if (process.env.DEBUG) originalError(...args); });
+    originalSetupLog('[SETUP] Console mocked.');
 
-    // Replace global console methods with Jest mocks.
-    global.console.log = jest.fn((...args) => {
-        // Only log to actual console if DEBUG environment variable is set.
-        if (process.env.DEBUG) {
-            originalLog(...args);
-        }
-    });
-
-    global.console.warn = jest.fn((...args) => {
-        // Optionally filter specific warnings you expect and don't want cluttering output.
-        const msg = args.join(' ');
-        if (
-            msg.includes('Could not fetch asset') ||
-            msg.includes('Error minifying')
-            // Add other expected warning patterns here if needed
-        ) {
-            return; // Suppress specific known warnings
-        }
-        // Log other warnings, potentially only in debug mode.
-        if (process.env.DEBUG) {
-            originalWarn(...args);
-        }
-    });
-
-    global.console.error = jest.fn((...args) => {
-        // Always show errors, especially in debug mode.
-        // Could add filtering if there are known, non-critical errors to ignore.
-        if (process.env.DEBUG) {
-            originalError(...args);
-        }
-        // Potentially log even without DEBUG for visibility during tests
-        // originalError(...args);
-    });
-
-    console.log("Test setup complete."); // Log setup finish
+    originalSetupLog("[SETUP] Test setup complete.");
 });
 
-/**
- * Jest's global afterAll hook. Runs once after all tests in a suite file have completed.
- * Cleans up the temporary directory created for the test run.
- */
 afterAll(async () => {
-    console.log(`Cleaning up test environment in: ${tempDir}`); // Log cleanup start
-    const dirs = global.__TEST_DIRECTORIES__; // Retrieve paths from global scope
-    if (!dirs) {
-        console.warn("Global test directories not found during cleanup.");
-        return;
-    }
-
+    originalSetupLog(`[SETUP] Cleaning up test environment in: ${tempDir}`);
     try {
-        // Recursively remove the entire temporary directory for this test run.
-        // Using force: true helps ignore errors if files are missing (e.g., cleanup already ran partially).
-        await fs.rm(tempDir, { recursive: true, force: true });
-        console.log(`Successfully cleaned up test directory: ${tempDir}`);
+        if (tempDir) {
+            await fs.rm(tempDir, { recursive: true, force: true });
+            originalSetupLog(`[SETUP] Successfully cleaned up: ${tempDir}`);
+        } else {
+            originalSetupLog(`[SETUP-WARN] tempDir variable was not defined during cleanup.`);
+        }
     } catch (e) {
-        // Log errors during cleanup but don't fail the tests typically.
-        // ENOENT means the directory was already gone, which is fine.
         if (e.code !== 'ENOENT') {
-            console.warn(`Could not fully clean test directory ${tempDir}:`, e.message);
+            originalSetupLog(`[SETUP-WARN] Could not fully clean test directory ${tempDir}:`, e.message);
         } else {
-            console.log(`Test directory already removed: ${tempDir}`);
+            originalSetupLog(`[SETUP] Test directory already removed: ${tempDir}`);
         }
     }
 });

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "portapack",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "📦 A tool to bundle and minify HTML and all its dependencies into a single portable file.",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "bin": {
-    "portapack": "./dist/cli/cli-entry.js"
+    "portapack": "./dist/cli/cli-entry.cjs"
   },
   "scripts": {
     "dev": "concurrently --success=all -n BUILD,DOCS,TEST -c green,blue,magenta \"npm run dev:build\" \"npm run dev:docs\" \"npm run dev:test\"",
     "dev:build": "tsup --watch",
     "dev:docs": "concurrently \"npm run docs:api:watch\" \"npm run docs:dev\"",
     "dev:test": "cross-env FORCE_COLOR=1 jest --watch --clearCache --passWithNoTests --watchPathIgnorePatterns=\"<rootDir>/tests/__fixtures__/output\"",
-    "dev:test:debug": "cross-env NODE_OPTIONS=--experimental-vm-modules FORCE_COLOR=1 jest --watch --runTestsByPath",
+    "dev:test:debug": "cross-env FORCE_COLOR=1 jest --watch --runTestsByPath",
     "build": "npm run build:code && npm run docs:api && npm run docs:build",
     "build:code": "tsup",
     "example": "npx tsx examples/main.ts",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
-    "test:ci": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage --ci",
+    "test": "cross-env jest --coverage",
+    "test:ci": "cross-env jest --coverage --ci",
     "test:clear": "jest --clearCache",
     "coverage": "jest --coverage && open coverage/lcov-report/index.html",
     "docs:coverage": "npm run test && mkdir -p docs/test-coverage && cp -r coverage/lcov-report/* docs/test-coverage/",