Install & Compatibility
Where this runs
tested against v? · npm install
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
muslnode 18–226 runs
build_error
glibcnode 18–226 runs
build_error
Code
Verified usage
Verified import paths — ran on the pinned version, not inferred.
range
✓ const range = require('node-range');
✗ import range from 'node-range';
This package is CommonJS-only and does not provide an ESM export. Direct `import` statements will fail in pure ESM environments.
range
✓ const range = require('node-range');
// Then use range(start, end)
✗ range(1, 11);
The `range` function is not exposed globally. It must be explicitly imported via `require`.
Range function result
✓ const rangeInstance = require('node-range')(1, 11);
✗ const rangeInstance = new (require('node-range'))(1, 11);
The package exports a function directly, which you call with arguments to get a range instance. It is not a class to be instantiated with `new`.
This quickstart demonstrates creating lazy numerical ranges, applying transformations with `map` (lazy and eager), iterating with `forEach` for synchronous operations, and `forEachAsync` for non-blocking iteration using callbacks.
const range = require('node-range');
console.log('--- Lazy Map Example ---');
// Generate a lazy range from 1 to 10 (exclusive of 11), and map each element
// The array is only materialized when needed (e.g., by console.log or when iteration completes)
const mappedArr = range(1, 11).map(function(i) {
return i * 5;
});
console.log('Result of lazy map:', mappedArr);
console.log('\n--- To Array and Map Example ---');
// Convert to an array first, then use standard Array.prototype.map
const toArrayAndMap = range(1, 11).toArray().map(function(i) {
return i * 2;
});
console.log('Result of toArray().map:', toArrayAndMap);
console.log('\n--- Synchronous ForEach Example ---');
// Execute a function for each item in the range without returning an array
range(1, 5).forEach(function(i) {
console.log('forEach sync:', Math.pow(i, 2));
});
console.log('\n--- Asynchronous ForEach (Callback-based) Example ---');
// Execute a function asynchronously for each item (callback-based)
// Note: This is non-blocking but uses older callback patterns
range(1, 3).forEachAsync(function(i) {
console.log('forEachAsync num:', i);
});
console.log('This should come first (demonstrating async nature)');
Debug
Known issues
breakingThe `node-range` package is abandoned and has not been updated since January 2015. It is highly likely to be incompatible with modern Node.js versions (e.g., Node.js v14+), especially regarding ES Modules, and may contain unpatched security vulnerabilities.fixMigrate to a actively maintained lazy sequence or range generation library that supports modern JavaScript and Node.js versions, such as a utility from a functional programming library (e.g., Lodash, Ramda) or a dedicated iterator library.
affects: All versions (0.1.0)
gotchaThis package is CommonJS-only and cannot be directly imported using ES module syntax (`import ... from 'node-range';`) in pure ESM Node.js projects without specific loaders or build tool configurations.fixIn CommonJS modules, use `const range = require('node-range');`. In ES modules, you might need dynamic import (`import('node-range').then(...)`) or a transpilation step, though switching to a modern library is recommended. affects: All versions (0.1.0)
gotchaThe README's claim that `node-range` is "Faster than Array.map" might no longer be true in many scenarios. Modern V8 engine optimizations in Node.js have significantly improved the performance of native array methods, potentially making them competitive or even faster than this older, unmaintained lazy implementation.fixBenchmark performance critically for your specific use case against modern JavaScript alternatives and native array methods before relying on this package's performance claims.
affects: All versions (0.1.0)
gotchaThere are no TypeScript type definitions (`.d.ts` files) available for `node-range`. Using this package in a TypeScript project will result in type errors and a lack of intelligent code completion and type checking.fixConsider writing custom type declarations or, preferably, migrating to a modern, type-safe alternative. Alternatively, disable type checking for this specific import if the project accepts the risk.
affects: All versions (0.1.0)
Errors
Common errors & fixes
ReferenceError: range is not defined
The `range` function is not globally available and must be imported.
fixAdd `const range = require('node-range');` at the top of your CommonJS module. TypeError: require(...) is not a function
This error can occur if `node-range` does not export a function directly, or if the `require` call is incorrectly structured.
fixEnsure you are calling the result of `require('node-range')` as a function: `const range = require('node-range'); const myRange = range(1, 10);` TypeError: range(...).map is not a function
This suggests that the object returned by `range(start, end)` is not the expected range instance with the `.map` method, likely due to an incorrect import or module resolution issue in an incompatible environment.
fixVerify that `require('node-range')` successfully resolves to the intended package and that you are using it in a compatible CommonJS Node.js environment. Consider using `console.log(typeof require('node-range'));` to inspect the export. ERR_REQUIRE_ESM
Attempting to `require()` an ES module from a CommonJS module, or trying to `import` a CommonJS module in a pure ESM context without proper interoperability settings.
fixThis package is CommonJS-only. If you are in an ES module environment, you must dynamically import it using `import('node-range').then(module => { const range = module; ... });` or configure your build system for CJS-ESM interop. However, migration to a modern library is strongly advised. Audit
Dependencies
No dependency data recorded yet.