Strip Comments and Literals from JavaScript

3.1.0 · active · verified Sun Apr 19

strip-literal is a JavaScript utility library designed to remove comments and string literals from code while preserving character positions. This is achieved by replacing the stripped content with an equivalent number of spaces, which is crucial for maintaining source map integrity. The library is currently on version 3.1.0 and is actively maintained, with a recent focus on performance improvements. Key differentiators include its reliance on `js-tokens` for robust parsing and its commitment to preserving code structure for tools like linters or code transformers. The project has undergone significant breaking changes, notably transitioning to an ESM-only module in v3.0.0 and switching its internal parsing engine from `acorn` to `js-tokens` in v2.0.0. Releases are fairly regular, addressing bugs and introducing optimizations.

Common errors

```
ReferenceError: require is not defined in ES module scope
```
cause Attempting to use CommonJS `require()` syntax for `strip-literal` in a JavaScript module (ESM) environment after upgrading to v3.0.0.

fix Change your import statement from `const { stripLiteral } = require('strip-literal')` to `import { stripLiteral } from 'strip-literal'`.
```
TypeError: Cannot read properties of undefined (reading 'stripLiteral')
```
cause Trying to import `stripLiteral` as a default import (e.g., `import stripLiteral from 'strip-literal'`) when it is exported as a named export.

fix Use named import syntax: `import { stripLiteral } from 'strip-literal'`.

Warnings

breaking Starting with v3.0.0, `strip-literal` is an ES module (ESM) only. CommonJS `require()` calls will no longer work in Node.js environments configured for ESM.
Fix: Update your import statements from `const { stripLiteral } = require('strip-literal')` to `import { stripLiteral } from 'strip-literal'` and ensure your project is configured for ESM (e.g., `"type": "module"` in `package.json`).
breaking Version 2.0.0 changed the underlying parsing engine from `acorn` to `js-tokens`. While the primary API (`stripLiteral`) remained the same, this internal change could lead to subtle differences in how edge cases or malformed code are handled, potentially causing unexpected outputs for certain inputs.
Fix: Thoroughly re-test your code transformation pipelines if upgrading from v1.x to v2.x to ensure the new parser behaves as expected for all your input scenarios.
gotcha The `stripLiteral` function replaces stripped comments and string literals with spaces of the same length, rather than completely removing them. This behavior is intentional to preserve original character positions, which is critical for source map generation and tools relying on accurate file offsets.
Fix: Be aware that the output code will contain whitespace where comments/literals once were. If you require truly 'removed' content (e.g., for minification), `strip-literal` might need to be part of a larger processing pipeline or a different tool might be more suitable.

Install

npm install strip-literal npm
yarn add strip-literal yarn
pnpm add strip-literal pnpm

Imports

stripLiteral
wrong:
```
const { stripLiteral } = require('strip-literal')
```
correct:
```
import { stripLiteral } from 'strip-literal'
```
The default package type became 'module' in v3.0.0, making CommonJS 'require' syntax incompatible in Node.js ESM environments.
stripLiteral
```
import type { StripLiteralOptions } from 'strip-literal'
```
TypeScript types are included, allowing for type-safe usage and options definition.
stripLiteral
wrong:
```
import stripLiteral from 'strip-literal'
```
correct:
```
import * as stripLiteralExports from 'strip-literal'
```
The primary export is a named export, `stripLiteral`, not a default export.

Quickstart

Demonstrates how to import and use `stripLiteral` to process JavaScript code, showcasing its behavior with various string and comment types while preserving whitespace for source map compatibility.

import { stripLiteral } from 'strip-literal';

// Example 1: Basic string literal stripping
const code1 = `const foo = 'hello world';\nconsole.log(foo);`;
const stripped1 = stripLiteral(code1);
console.log('Stripped 1:\n', stripped1);
// Expected: const foo = '           ';\nconsole.log(foo);

// Example 2: Template literal with interpolation and comments
const code2 = `
  const name = `Alice`; // This is a comment
  const greeting = `Hello, ${name}!`; /* multi-line
  comment */
  console.log(greeting);
`;
const stripped2 = stripLiteral(code2);
console.log('\nStripped 2:\n', stripped2);
/*
Expected Output:

  const name = `     `;             
  const greeting = `Hello, ${name}!`;            
  console.log(greeting);
*/

// Example 3: Stripping only specific types of literals (e.g., just comments)
// Note: The library strips all comments and string literals by default.
// For more granular control, you'd typically need a more advanced parser.
const code3 = `// Only comments please\nconst x = 1; /* another comment */`;
const stripped3 = stripLiteral(code3);
console.log('\nStripped 3:\n', stripped3);
// Expected:                  \nconst x = 1;

view raw JSON →