Bug: entities_1.default is undefined in v8.0.0 (Node.js 26)

[sergiolindau]

Bug: entities_1.default is undefined in v8.0.0 (Node.js 26)

Description

After upgrading from node-html-parser@7.1.0 to node-html-parser@8.0.0, my build process fails at runtime when accessing element attributes.

The error occurs inside the published package code:

node_modules/node-html-parser/dist/nodes/html.js:17
return entities_1.default.decodeHTML(val);

TypeError: Cannot read properties of undefined (reading 'decodeHTML')

Environment

• node-html-parser: 8.0.0
• Node.js: 26.3.0
• OS: Windows 10

Stack Trace

node_modules\node-html-parser\dist\nodes\html.js:17
    return entities_1.default.decodeHTML(val);
                              ^

TypeError: Cannot read properties of undefined (reading 'decodeHTML')
    at decode (...\node-html-parser\dist\nodes\html.js:17:31)
    at get attributes (...\node-html-parser\dist\nodes\html.js:599:30)
    ...

Installed Dependencies

node-html-parser@8.0.0
└── entities@8.0.0

Relevant Compiled Code

The published CommonJS bundle contains:

const entities_1 = __importDefault(require("entities"));

function decode(val) {
    return entities_1.default.decodeHTML(val);
}

However, at runtime entities_1.default is undefined, causing the package to crash when decoding attributes.

Expected Behavior

HTML should be parsed normally, as in v7.1.0.

Actual Behavior

Accessing attributes triggers:

TypeError: Cannot read properties of undefined (reading 'decodeHTML')

Notes

This looks like a CommonJS/ESM interop issue involving the entities package.

Version 7.1.0 works correctly in the same project and environment, while 8.0.0 fails immediately.

[taoqf]

@sergiolindau Sorry for that .Could you please provide some test data to reproduce this issue？

[sergiolindau]

I use this in a build script set to get the latest version of ANTLR:

/**
 * get-antlr.ts: This script gets the latest version of ANTLR.
 */
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'url';
import turndown from 'turndown';

const turndownService = new turndown({ br: '\r\n', emDelimiter: '*' });

import getHtmlParsed from './helper/getHtmlParsed';
import downloadIfNotExist from './helper/downloadIfNotExist';
import { exit } from 'node:process';
import { HTMLElement } from 'node-html-parser';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

let resourceDir: string;

/* Process command line. */
if (process.argv.length === 2) {
    resourceDir = 'res';
} else if (process.argv.length === 3) {
    resourceDir = process.argv[2];
} else {
    console.log('Usage:\n  tsx get-antlr.ts [directory]');
    exit(1);
}

(async () => {
    console.log(`Running ${__filename} ...`);
    console.log('Getting the latest version of ANTLR ...');
    console.log('Output directory:', resourceDir);
    const links = Array.from(((await getHtmlParsed('https://www.antlr.org/download.html')) as unknown as HTMLElement).querySelectorAll('a'));
    let antlrVersion = '';
    const antlrUrl =
        'https://www.antlr.org/' +
        (
            links.filter((link) => {
                const match = /^download\/antlr\-([0-9\.]+)\-complete\.jar$/.exec((link.attributes as any).href);
                if (match) {
                    antlrVersion = match[1];
                    return true;
                } else {
                    return false;
                }
            })[0].attributes as any
        ).href;
    fs.mkdirSync(path.resolve(__dirname, '..', resourceDir), { recursive: true });
    const antlrPath = path.resolve(__dirname, '..', resourceDir, 'antlr-complete.jar');
    const antlrVersionPath = path.resolve(__dirname, '..', resourceDir, 'antlr-version');
    const license = turndownService.turndown(((await getHtmlParsed('https://www.antlr.org/license.html')) as unknown as HTMLElement).querySelector('div#content')!.innerHTML.trim());
    const antlrLicensePath = path.resolve(__dirname, '..', resourceDir, 'antlr-LICENSE.md');
    try {
        fs.writeFileSync(antlrLicensePath, license);
    } catch {}
    let antlrInstalledVersion: string;
    try {
        fs.accessSync(antlrPath, fs.constants.R_OK);
        fs.accessSync(antlrVersionPath, fs.constants.R_OK);
        fs.accessSync(antlrLicensePath, fs.constants.R_OK);
        antlrInstalledVersion = fs.readFileSync(antlrVersionPath, 'utf-8').trim();
    } catch {
        antlrInstalledVersion = '0.0.0';
    }
    if (antlrInstalledVersion !== antlrVersion) {
        try {
            fs.unlinkSync(antlrPath);
            fs.unlinkSync(antlrVersionPath);
        } catch {}
        console.log(`Downloading ANTLR version ${antlrVersion} ...`);
        await downloadIfNotExist(antlrUrl, antlrPath);
        fs.writeFileSync(antlrVersionPath, antlrVersion);
        console.log(`Downloading ANTLR version ${antlrVersion} done.`);
    } else {
        console.log('The last version of ANTLR is installed.');
    }
    console.log('Getting the latest version of ANTLR done.');
    console.log(`Running ${__filename} done.\n\n`);
})();

import http from 'node:http';
import HTMLParser, { HTMLElement, Options } from 'node-html-parser';
import httpGet from './httpGet';

/**
 * Downloads an HTML file and parses it, returning an object of type
 * HTMLElement.
 * @param url
 * @param options
 */
export default async (url: http.RequestOptions | string | URL, options?: Partial<Options>): Promise<HTMLElement | void> => {
    return new Promise((resolve: (value?: HTMLElement | void) => void, reject: (reason?: any) => void) => {
        console.log(`Downloading ${url} ...`);
        httpGet(url, function (response: http.IncomingMessage) {
            let page: string = '';
            response.on('data', (data: string) => {
                page += data;
            });
            response.on('end', () => {
                console.log(`Downloading ${url} done.`);
                console.log(`Parsing ${url} ...`);
                const root = HTMLParser.parse(page, options) as unknown as HTMLElement | void;
                console.log(`Parsing ${url} done.`);
                resolve(root);
            });
            response.on('error', (err: Error) => {
                console.error(`getHtmlParsed: ${err.message}`);
                reject(err.message);
            });
        });
    });
};

import fs from 'node:fs';
import path from 'node:path';
import mkDirIfNotExist from './mkDirIfNotExist';
import httpGet from './httpGet';

/**
 * Downloads the file if it does not exist. Recursively creates the base
 * directories if necessary.
 * @param url
 * @param filePath
 */
export default async function (url: string, filePath: string): Promise<boolean | void> {
    let exist = true;
    try {
        fs.accessSync(filePath, fs.constants.F_OK);
    } catch {
        exist = false;
    }
    return new Promise((resolve: (value?: boolean | void) => void, reject: (reason?: any) => void) => {
        if (exist) {
            resolve(true);
        } else {
            console.log(`Downloading ${url} to ${filePath} ...`);
            const paths = filePath.split(path.sep);
            mkDirIfNotExist(paths.slice(0, paths.length - 1).join(path.sep));
            const file = fs.createWriteStream(filePath);
            httpGet(url, function (response) {
                response.pipe(file);
                file.on('finish', () => {
                    file.close();
                    console.log(`Downloading ${url} to ${filePath} done.`);
                    resolve(false);
                });
                file.on('error', (err) => {
                    console.error(`downloadIfNotExist: ${err.message}`);
                    reject(new EvalError(err.message));
                });
            });
        }
    });
}

/**
 * get-antlr.ts: This script gets the latest version of ANTLR.
 */
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'url';
import turndown from 'turndown';

const turndownService = new turndown({ br: '\r\n', emDelimiter: '*' });

import getHtmlParsed from './helper/getHtmlParsed';
import downloadIfNotExist from './helper/downloadIfNotExist';
import { exit } from 'node:process';
import { HTMLElement } from 'node-html-parser';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

let resourceDir: string;

/* Process command line. */
if (process.argv.length === 2) {
    resourceDir = 'res';
} else if (process.argv.length === 3) {
    resourceDir = process.argv[2];
} else {
    console.log('Usage:\n  tsx get-antlr.ts [directory]');
    exit(1);
}

(async () => {
    console.log(`Running ${__filename} ...`);
    console.log('Getting the latest version of ANTLR ...');
    console.log('Output directory:', resourceDir);
    const links = Array.from(((await getHtmlParsed('https://www.antlr.org/download.html')) as unknown as HTMLElement).querySelectorAll('a'));
    let antlrVersion = '';
    const antlrUrl =
        'https://www.antlr.org/' +
        (
            links.filter((link) => {
                const match = /^download\/antlr\-([0-9\.]+)\-complete\.jar$/.exec((link.attributes as any).href);
                if (match) {
                    antlrVersion = match[1];
                    return true;
                } else {
                    return false;
                }
            })[0].attributes as any
        ).href;
    fs.mkdirSync(path.resolve(__dirname, '..', resourceDir), { recursive: true });
    const antlrPath = path.resolve(__dirname, '..', resourceDir, 'antlr-complete.jar');
    const antlrVersionPath = path.resolve(__dirname, '..', resourceDir, 'antlr-version');
    const license = turndownService.turndown(((await getHtmlParsed('https://www.antlr.org/license.html')) as unknown as HTMLElement).querySelector('div#content')!.innerHTML.trim());
    const antlrLicensePath = path.resolve(__dirname, '..', resourceDir, 'antlr-LICENSE.md');
    try {
        fs.writeFileSync(antlrLicensePath, license);
    } catch {}
    let antlrInstalledVersion: string;
    try {
        fs.accessSync(antlrPath, fs.constants.R_OK);
        fs.accessSync(antlrVersionPath, fs.constants.R_OK);
        fs.accessSync(antlrLicensePath, fs.constants.R_OK);
        antlrInstalledVersion = fs.readFileSync(antlrVersionPath, 'utf-8').trim();
    } catch {
        antlrInstalledVersion = '0.0.0';
    }
    if (antlrInstalledVersion !== antlrVersion) {
        try {
            fs.unlinkSync(antlrPath);
            fs.unlinkSync(antlrVersionPath);
        } catch {}
        console.log(`Downloading ANTLR version ${antlrVersion} ...`);
        await downloadIfNotExist(antlrUrl, antlrPath);
        fs.writeFileSync(antlrVersionPath, antlrVersion);
        console.log(`Downloading ANTLR version ${antlrVersion} done.`);
    } else {
        console.log('The last version of ANTLR is installed.');
    }
    console.log('Getting the latest version of ANTLR done.');
    console.log(`Running ${__filename} done.\n\n`);
})();

Sorry. Without modifications to my build environment, I can't test directly from a pull request. I can only test via npm.

[taoqf]

Thanks, I will see to it.

[taoqf]

@sergiolindau Sorry for that, I completed your missing httpGet, DownloadIfNotExit, mkDirIfNotExit, find the issues at last.
I did a fix by v8.0.1.
Thanks again.

[taoqf]

Try v8.0.1, if the issue still bothers you, let me know, please.

[taoqf]

Btw, config your tsconfig.json maybe also will resole your issue.

{
  "compilerOptions": {
    "allowSyntheticDefaultImports": true,
    ...
  }
}

[sergiolindau]

Thanks!

Your good work is a fundamental tool in my build environment.