ECMAScript/TypeScript Import and Export Parser

Common errors

• SyntaxError: Unexpected token

  cause The input source string contains invalid JavaScript/TypeScript syntax or is poorly formatted, which causes the underlying parser to fail.
  fix Validate and format your source code using a tool like ESLint or Prettier before passing it to `parseImportsExports`. Ensure all import/export statements are syntactically correct.

• TypeError: parseImportsExports is not a function

  cause This typically occurs when trying to use CommonJS `require` to import the module or attempting to destructure a non-existent export, especially in an ESM-first project.
  fix Use `import { parseImportsExports } from 'parse-imports-exports';` in modern Node.js and browser environments that support ES modules. If using CommonJS, ensure your project setup correctly transpiles or resolves ESM imports.

• Could not parse import/exports with acorn: $error

  cause This error message indicates an issue with the underlying parser (Acorn, or similar) failing to interpret a specific import or export statement due to invalid syntax or an unexpected token.
  fix Review the specific import/export statement causing the error. Ensure it adheres strictly to ECMAScript/TypeScript syntax, including correct use of keywords, module specifiers, and proper termination.

Warnings

• gotcha This package requires input code to be syntactically correct and well-formatted. It is not designed to validate or lint code with errors, but to parse valid module declarations.
  Fix: Ensure the source string passed to `parseImportsExports` is valid JavaScript/TypeScript, potentially pre-processed by a linter or formatter like Prettier.
• breaking As the package is in an early `0.x.x` version series, its API (including the structure of the returned `ImportExportResult` object) is subject to non-backward-compatible changes in minor releases.
  Fix: Refer to the official GitHub repository for the latest API documentation and breaking change notes before upgrading. Consider pinning to exact minor versions to avoid unexpected changes.
• gotcha The parser works specifically for `import` and `export` declarations and `require()` calls. It does not provide a full Abstract Syntax Tree (AST) for the entire file, nor does it handle all possible JavaScript/TypeScript syntax errors beyond its scope.
  Fix: Use a dedicated full AST parser (e.g., Acorn, Babel, TypeScript compiler API) if you require comprehensive code analysis or error detection beyond module declarations.

Install

• npm install parse-imports-exports npm
• yarn add parse-imports-exports yarn
• pnpm add parse-imports-exports pnpm

Imports

• parseImportsExports
  wrong:

  const parseImportsExports = require('parse-imports-exports');

  correct:

  import { parseImportsExports } from 'parse-imports-exports';

  While the library can parse CommonJS `require` statements, it is itself an ESM-first package shipping TypeScript types, so ESM `import` is the idiomatic usage.
• ImportExportResult
  wrong:

  import { ImportExportResult } from 'parse-imports-exports';

  correct:

  import type { ImportExportResult } from 'parse-imports-exports';

  This is a type definition for the parsed output structure. Use `import type` to avoid bundling unnecessary runtime code in environments that support it.
• All symbols at once

  import { parseImportsExports, ImportExportResult } from 'parse-imports-exports';

  Multiple named exports can be imported in a single statement.

Quickstart

Demonstrates how to use `parseImportsExports` to analyze a TypeScript/ECMAScript source string and extract a detailed breakdown of all import, export, and re-export declarations, including dynamic imports and CommonJS `require` statements.

import { parseImportsExports } from 'parse-imports-exports';

const source = `
/**
 * Imports.
 */
import {foo as baz, type Bar} from 'Qux';
import Foo, * as foo from 'Qux';
const dynamicQux = await import('Qux');
const commonJSQux = require('Qux');
import type {Foo as Baz, Bar} from 'Qux';

/**
 * Reexports.
 */
export {foo as baz, type Bar} from 'Qux';
export * as foo from 'Qux';
export * from 'Qux';

/**
 * Exports.
 */
export default 42;
export const myVar = 2;
export type T = number;
`;

const importsExports = parseImportsExports(source);

console.log(JSON.stringify(importsExports, null, 2));
/*
Example output (indices may vary):
{
  "namedImports": {
    "Qux": [
      {
        "start": 42,
        "end": 83,
        "names": {
          "baz": {
            "by": "foo"
          }
        },
        "types": {
          "Bar": {}
        }
      }
    ]
  },
  "namespaceImports": {
    "Qux": [
      {
        "start": 85,
        "end": 117,
        "namespace": "foo",
        "default": "Foo"
      }
    ]
  },
  "dynamicImports": {
    "Qux": [
      {
        "start": 129,
        "end": 165
      }
    ]
  },
  "requires": {
    "Qux": [
      {
        "start": 177,
        "end": 206
      }
    ]
  },
  "typeNamedImports": {
    "Qux": [
      {
        "start": 218,
        "end": 251,
        "names": {
          "Baz": {
            "by": "Foo"
          }
        },
        "types": {
          "Bar": {}
        }
      }
    ]
  },
  "namedReexports": {
    "Qux": [
      {
        "start": 279,
        "end": 320,
        "names": {
          "baz": {
            "by": "foo"
          }
        },
        "types": {
          "Bar": {}
        }
      }
    ]
  },
  "namespaceReexports": {
    "Qux": [
      {
        "start": 322,
        "end": 349,
        "namespace": "foo"
      }
    ]
  },
  "wildcardReexports": {
    "Qux": [
      {
        "start": 351,
        "end": 371
      }
    ]
  },
  "defaultExports": [
    {
      "start": 399,
      "end": 415
    }
  ],
  "namedExports": [
    {
      "start": 427,
      "end": 443,
      "names": {
        "myVar": {}
      }
    }
  ],
  "typeExports": [
    {
      "start": 455,
      "end": 471,
      "names": {
        "T": {}
      }
    }
  ]
}
*/