Module parse failed: Unexpected token
  • 27-Apr-2023
Lightrun Team
Author Lightrun Team
Module parse failed: Unexpected token

Module parse failed: Unexpected token

Lightrun Team
Lightrun Team

Explanation of the problem

During the production build process, an error occurred due to module parsing failure with an unexpected token (3:55). The file was processed with the babel-loader, which is a module bundler designed to transpile JavaScript files using Babel. However, it appears that an additional loader may be required to handle the output of these loaders.

The error message indicates that the problem lies between the ‘from’ keyword and the path “/data_b/work/gitlab-runner/builds/622b053b/…” and that there is no whitespace between them. This error has not occurred during development, only during the production build, suggesting that it may be related to differences in the environment or configuration between the two modes.

import _regeneratorRuntime from"/data_b/work/gitlab-runner/builds/622b053b/0/lala/test/node_modules/babel-preset-react-app/node_modules/@babel/runtime/regenerator";
import _objectSpread from"/data_b/work/gitlab-runner/builds/622b053b/...

It appears that the error may be related to the Babel-generated code. Specifically, the syntax of the code between lines 3:55 may be causing the module parsing failure. Further investigation is required to determine the exact cause of the issue and identify a solution to fix it.


Troubleshooting with the Lightrun Developer Observability Platform


Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for Module parse failed: Unexpected token

The error message “Module parse failed: Unexpected token” typically occurs when there is an issue with Babel’s module parsing process. One possible solution is to change the compact option of Babel to false. This is a short-term fix that may resolve the problem, but it is not a permanent solution. The compact option is a flag that determines whether or not Babel should output compact code. Changing this option can be done in the webpack configuration file, specifically at the line number 438. This solution may work for some cases, but it is important to note that it does not address the root cause of the issue.

  test: /\.(js|mjs|jsx|ts|tsx)$/,
  include: paths.appSrc,
  loader: require.resolve('babel-loader'),
  options: {
    customize: require.resolve(

    // The 'false' value here means to use the default Babel settings
    // for compact mode, which is to omit whitespace and comments.
    compact: false,
    plugins: [
          loaderMap: {
            svg: {
              ReactComponent: '@svgr/webpack?-svgo,+titleProp,+ref![path]',
    cacheDirectory: true,
    cacheCompression: isEnvProduction,
    // See #6846 for context on why cacheCompression is disabled
    compact: isEnvProduction,
  // ...

Another possible cause of the “Unexpected token” error is the incompatibility of some dependencies with Babel/core version 7.15.0. When upgrading to this version, some plugins and presets may become incompatible, leading to module parsing failures. Identifying the specific dependency causing the issue can be challenging, as the error message does not provide much information. One possible solution that has worked for some users is to upgrade all Babel plugins and presets to their latest versions. This can be done by running the command “npm update @babel/core @babel/preset-env @babel/preset-react” in the terminal. However, this solution may not be effective for all cases, and further investigation may be required.

npm update @babel/core @babel/preset-env @babel/preset-react

Other popular problems with Creating a react app

Problem: Limited Configuration Options

The first issue with create-react-app is its limited configuration options. While create-react-app provides a great starting point for building a React application, it can be challenging to customize it beyond its initial configuration. This limitation can cause issues for developers who need to add additional libraries or modify the default configuration.


One solution is to eject the app and modify the configuration files directly. However, this option should be used with caution as ejecting is a one-way operation, and it can be difficult to manage the configuration changes. Another option is to use a tool like react-app-rewired to modify the configuration without ejecting. React-app-rewired allows developers to modify the webpack configuration and babel configuration files, among others. By using this tool, developers can customize their create-react-app configuration while still maintaining the ability to update to new versions of create-react-app.

Problem: Large Bundle Size

The second issue with create-react-app is that it can generate a large bundle size. A large bundle size can slow down the application’s performance, especially for users on slower internet connections or mobile devices. This issue can be especially problematic for larger applications.


To reduce the bundle size, developers can use tools like code splitting and tree shaking. Code splitting involves breaking up the code into smaller chunks that can be loaded on-demand instead of all at once. Tree shaking is a technique that removes unused code from the final bundle. Additionally, developers can use libraries like Loadable Components to split the code more efficiently.

Problem: Lack of Server-Side Rendering

The third issue with create-react-app is the lack of built-in support for server-side rendering. Server-side rendering can improve the application’s performance, especially for users on slow connections or with slower devices. It can also help with SEO and provide a better user experience.


To add server-side rendering, developers can use tools like Next.js or Gatsby. Next.js is a framework that allows developers to build server-rendered React applications easily. Gatsby is a static site generator that allows developers to build static websites with React components. Both tools provide an easy way to add server-side rendering to a React application while maintaining compatibility with create-react-app.


A brief introduction of creating a react app

Create-react-app is a command-line interface tool that allows developers to quickly and easily create React applications without the need for configuration. It is a popular choice for developers who want to start building React applications quickly and efficiently. Create-react-app provides a pre-configured development environment with all the necessary tools and libraries to get started with React. It includes a development server, a hot-reloading feature, and many other features that make it easy to develop and test React applications.

Create-react-app uses webpack and babel under the hood to handle the bundling and transpiling of the application’s code. It also includes a pre-configured webpack configuration that is optimized for performance and code splitting. By default, create-react-app supports CSS modules and Sass, and it provides a simple way to add additional CSS preprocessors if needed. Create-react-app is maintained by Facebook and has a large community of contributors who regularly update and improve the tool. It is also compatible with many popular React libraries and tools, making it easy to integrate with other tools and services.

Most popular use cases for creating a react app

  1. Rapid Development: Create-react-app is designed to help developers quickly and efficiently create React applications without the need for manual configuration. By running a single command, developers can create a new React application with a pre-configured development environment that includes a server, hot-reloading, and many other features that make it easy to start building React applications. With Create-react-app, developers can focus on writing their code instead of spending time setting up the development environment.
  2. Customization: While Create-react-app provides a pre-configured development environment, it is also highly customizable. Developers can easily modify the configuration to suit their specific needs by using configuration files, such as .env, .babelrc, and webpack.config.js. This allows developers to add additional features, such as support for CSS preprocessors or custom webpack plugins, to their React applications.

Here is an example of how to add support for SASS in Create-react-app:

npm install node-sass

After installing the node-sass package, create a new .scss file in the src directory, and import it in your JavaScript file. Create-react-app will automatically handle the compilation and bundling of the SASS file.

  1. Integration with other tools and services: Create-react-app is compatible with many popular React libraries and tools, making it easy to integrate with other tools and services. For example, developers can easily add support for TypeScript by installing the @types/react package and updating their code to use TypeScript syntax. Create-react-app also works well with popular testing frameworks, such as Jest and Enzyme, making it easy to write and run tests for React applications.



It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.