is-expression

Common errors

• SyntaxError: Unexpected token (1:0) at Parser.pp.raise (acorn/dist/acorn.js:XXX:YY) ...

  cause Attempting to validate a string that is not a valid JavaScript expression or contains syntax not allowed by the default Acorn parsing options.
  fix Ensure the input string is a true JavaScript expression. If you require specific parsing allowances (e.g., comments, non-standard syntax), pass appropriate `options` like `{ lineComment: true }` or Acorn-specific parser options. If the error is about a keyword like 'var' or 'const', remember these are statements/declarations, not expressions.

• ReferenceError: isExpression is not defined

  cause The `isExpression` function was not correctly imported or required.
  fix For CommonJS, use `const isExpression = require('is-expression');`. For ES Modules, use `import { isExpression } from 'is-expression';`. Ensure your environment supports the chosen module system.

Warnings

• breaking Version 4.0.0 upgraded the underlying Acorn parser from 4.0.2 to 7.1.1. This change significantly updates the default parsing mode to ES2019, meaning many constructs previously considered invalid expressions will now parse successfully as valid ES2019 expressions.
  Fix: Review existing uses of `is-expression` after upgrading to v4.0.0. If you relied on certain syntax being invalid for older JavaScript versions, you may need to introduce custom parsing options via `options` or implement additional validation logic.
• gotcha By default, `isExpression` does not allow line comments within the string being validated. An expression like `a + b // comment` will be considered invalid.
  Fix: If line comments are expected and should be treated as part of a valid expression, you must explicitly pass `{ lineComment: true }` in the options object to `isExpression`.
• gotcha The `isExpression` function defaults to non-strict mode parsing. This can lead to certain keywords or syntax (e.g., `public`) being accepted as valid expressions, which might be invalid in strict-mode contexts.
  Fix: For stricter validation consistent with modern JavaScript modules or strict-mode code, always provide `{ strict: true }` in the options object to `isExpression`.

Install

• npm install is-expression npm
• yarn add is-expression yarn
• pnpm add is-expression pnpm

Imports

• isExpression
  wrong:

  import isExpression from 'is-expression'

  correct:

  import { isExpression } from 'is-expression'

  The primary function is a named export, not a default export.
• isExpression

  const isExpression = require('is-expression')

  CommonJS require style is fully supported and shown in documentation examples.
• isExpression

  import * as isExpressionModule from 'is-expression'; isExpressionModule.isExpression('foo')

  While functional, direct named import is generally preferred for clarity.

Quickstart

This quickstart demonstrates basic expression validation using `isExpression` and how to leverage `throw`, `strict`, and `lineComment` options to control parsing behavior and error handling.

import { isExpression } from 'is-expression';

// Basic validation
console.log(isExpression('myVar')); // => true
console.log(isExpression('var'));   // => false (keyword, not expression)
console.log(isExpression('["an", "array"].indexOf("index")')); // => true

// Using options: throw on error
try {
  isExpression('const foo', { throw: true }); // 'const' is a declaration, not an expression
} catch (error) {
  console.error('Caught expected error:', error.message); // SyntaxError: Unexpected token 'const' (1:0)
}

// Using options: strict mode
console.log(isExpression('public')); // => true (in non-strict mode)
console.log(isExpression('public', { strict: true })); // => false (in strict mode, 'public' is a reserved keyword)

// Using options: allowing comments
console.log(isExpression('abc // my comment')); // => false (comments not allowed by default)
console.log(isExpression('abc // my comment', { lineComment: true })); // => true