range-pie 2.4.0 → 3.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 SkorpionG2000
+Copyright (c) 2026 SkorpionG2000
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,16 +2,17 @@
 
 A TypeScript/JavaScript library that brings Python's range functionality to JavaScript, enhanced with familiar array methods. This lightweight utility provides a seamless way to work with numeric sequences while maintaining JavaScript's functional programming paradigm. Fully typed for TypeScript users while remaining compatible with JavaScript projects.
 
+[![npm version](https://img.shields.io/npm/v/range-pie.svg)](https://www.npmjs.com/package/range-pie)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
 ## Table of Contents
 
 - [Installation](#installation)
 - [Basic Usage](#basic-usage)
-
   - [JavaScript](#javascript)
   - [TypeScript](#typescript)
 
 - [API Reference](#api-reference)
-
   - [Constructor Options](#constructor-options)
   - [Properties](#properties)
   - [at()](#at)
@@ -37,12 +38,10 @@ A TypeScript/JavaScript library that brings Python's range functionality to Java
   - [values()](#values)
 
 - [Advanced Usage](#advanced-usage)
-
   - [Iteration](#iteration)
   - [Proxy Access](#proxy-access)
 
 - [Examples](#examples)
-
   - [Methods chaining](#methods-chaining)
   - [Using as Array-like Object](#using-as-array-like-object)
   - [Example Files](#example-files)
@@ -62,9 +61,9 @@ npm install range-pie
 
 ```javascript
 // CommonJS - Both import styles are supported
-const { PyRange } = require('range-pie');  // Named import style
+const { PyRange } = require("range-pie"); // Named import style
 // OR
-const PyRange = require('range-pie');     // Default import style
+const PyRange = require("range-pie"); // Default import style
 
 // Create a range from 0 to 5
 const range = new PyRange(5);
@@ -87,20 +86,20 @@ console.log([...range4]); // [5, 4, 3]
 
 ```typescript
 // ES Modules - Both import styles are supported
-import { PyRange } from 'range-pie';  // Named import style
+import { PyRange } from "range-pie"; // Named import style
 // OR
-import PyRange from 'range-pie';      // Default import style
+import PyRange from "range-pie"; // Default import style
 
 // Create a range from 0 to 5
 const range = new PyRange(5);
 console.log([...range]); // [0, 1, 2, 3, 4]
 
 // Type-safe operations
-const doubledValues: number[] = range.map(x => x * 2);
+const doubledValues: number[] = range.map((x) => x * 2);
 console.log(doubledValues); // [0, 2, 4, 6, 8]
 
 // Type inference works with generics
-const stringValues: string[] = range.map(x => `Value: ${x}`);
+const stringValues: string[] = range.map((x) => `Value: ${x}`);
 console.log(stringValues); // ['Value: 0', 'Value: 1', 'Value: 2', 'Value: 3', 'Value: 4']
 ```
 
@@ -109,9 +108,9 @@ console.log(stringValues); // ['Value: 0', 'Value: 1', 'Value: 2', 'Value: 3', '
 ### Constructor Options
 
 ```javascript
-new PyRange(stop)               // 0 to stop-1
-new PyRange(start, stop)        // start to stop-1
-new PyRange(start, stop, step)  // start to stop-1 with step
+new PyRange(stop); // 0 to stop-1
+new PyRange(start, stop); // start to stop-1
+new PyRange(start, stop, step); // start to stop-1 with step
 ```
 
 - **PyRange(stop:number)**
@@ -148,21 +147,22 @@ console.log(PyRange(2, -10, -1));
 
 ```javascript
 const range = new PyRange(1, 10, 2);
-console.log(range.start);  // 1
-console.log(range.stop);   // 10
-console.log(range.step);   // 2
+console.log(range.start); // 1
+console.log(range.stop); // 10
+console.log(range.step); // 2
 console.log(range.length); // 5
 ```
 
 ### at()
 
-The 'at' method accepts a number as argument to gets the value at the specified index in a range. Generate a RangeError if the index is out of range.
+The 'at' method accepts a number as argument to get the value at the specified index in a range. Returns `undefined` if the index is out of range, perfectly matching `Array.prototype.at`. Negative indices count backwards from the end of the range.
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.at(0));  // 1
-console.log(range.at(2));  // 3
-console.log(range.at(-1)); // RangeError
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.at(0)); // 1
+console.log(range.at(2)); // 3
+console.log(range.at(-1)); // 4 (negative index wraps from the end)
+console.log(range.at(10)); // undefined (out of bounds)
 ```
 
 ### toString()
@@ -188,8 +188,8 @@ console.log(range.toArray()); // [1, 2, 3]
 It works the same as [**`Array.prototype.map`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
 
 ```javascript
-const range = new PyRange(1, 4);  // [1, 2, 3]
-console.log(range.map(x => x * 2));  // [2, 4, 6]
+const range = new PyRange(1, 4); // [1, 2, 3]
+console.log(range.map((x) => x * 2)); // [2, 4, 6]
 ```
 
 ### filter()
@@ -197,8 +197,8 @@ console.log(range.map(x => x * 2));  // [2, 4, 6]
 It works the same as [**`Array.prototype.filter`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
 
 ```javascript
-const range = new PyRange(1, 6);  // [1, 2, 3, 4, 5]
-console.log(range.filter(x => x % 2 === 0));  // [2, 4]
+const range = new PyRange(1, 6); // [1, 2, 3, 4, 5]
+console.log(range.filter((x) => x % 2 === 0)); // [2, 4]
 ```
 
 ### reduce()
@@ -206,9 +206,9 @@ console.log(range.filter(x => x % 2 === 0));  // [2, 4]
 It works the same as [**`Array.prototype.reduce`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
 
 ```javascript
-const range = new PyRange(1, 4);  // [1, 2, 3]
+const range = new PyRange(1, 4); // [1, 2, 3]
 const sum = range.reduce((acc, curr) => acc + curr, 0);
-console.log(sum);  // 6
+console.log(sum); // 6
 ```
 
 ### some()
@@ -216,9 +216,9 @@ console.log(sum);  // 6
 It works the same as [**`Array.prototype.some`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.some(x => x > 3));  // true
-console.log(range.some(x => x < 0));  // false
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.some((x) => x > 3)); // true
+console.log(range.some((x) => x < 0)); // false
 ```
 
 ### every()
@@ -226,9 +226,9 @@ console.log(range.some(x => x < 0));  // false
 It works the same as [**`Array.prototype.every`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.every(x => x > 0));  // true
-console.log(range.every(x => x > 2));  // false
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.every((x) => x > 0)); // true
+console.log(range.every((x) => x > 2)); // false
 ```
 
 ### find()
@@ -236,9 +236,9 @@ console.log(range.every(x => x > 2));  // false
 It works the same as [**`Array.prototype.find`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.find(x => x > 2));  // 3
-console.log(range.find(x => x > 5));  // undefined
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.find((x) => x > 2)); // 3
+console.log(range.find((x) => x > 5)); // undefined
 ```
 
 ### findIndex()
@@ -246,9 +246,9 @@ console.log(range.find(x => x > 5));  // undefined
 It works the same as [**`Array.prototype.findIndex`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.findIndex(x => x > 2));  // 2
-console.log(range.findIndex(x => x > 5));  // -1
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.findIndex((x) => x > 2)); // 2
+console.log(range.findIndex((x) => x > 5)); // -1
 ```
 
 ### findLastIndex()
@@ -256,9 +256,9 @@ console.log(range.findIndex(x => x > 5));  // -1
 It works the same as [**`Array.prototype.findLastIndex`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findLastIndex)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.findLastIndex(x => x > 2));  // 3
-console.log(range.findLastIndex(x => x > 5));  // -1
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.findLastIndex((x) => x > 2)); // 3
+console.log(range.findLastIndex((x) => x > 5)); // -1
 ```
 
 ### forEach()
@@ -266,8 +266,8 @@ console.log(range.findLastIndex(x => x > 5));  // -1
 It works the same as [**`Array.prototype.forEach`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
 
 ```javascript
-const range = new PyRange(1, 4);  // [1, 2, 3]
-range.forEach(x => console.log(x));  
+const range = new PyRange(1, 4); // [1, 2, 3]
+range.forEach((x) => console.log(x));
 // 1
 // 2
 // 3
@@ -278,9 +278,9 @@ range.forEach(x => console.log(x));
 It works the same as [**`Array.prototype.includes`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.includes(3));  // true
-console.log(range.includes(5));  // false
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.includes(3)); // true
+console.log(range.includes(5)); // false
 ```
 
 ### indexOf()
@@ -288,9 +288,9 @@ console.log(range.includes(5));  // false
 It works the same as [**`Array.prototype.indexOf`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.indexOf(3));    // 2
-console.log(range.indexOf(5));    // -1
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.indexOf(3)); // 2
+console.log(range.indexOf(5)); // -1
 ```
 
 ### lastIndexOf()
@@ -298,9 +298,9 @@ console.log(range.indexOf(5));    // -1
 It works the same as [**`Array.prototype.lastIndexOf`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf)
 
 ```javascript
-const range = new PyRange(1, 5, 1);  // [1, 2, 3, 4]
-console.log(range.lastIndexOf(3));    // 2
-console.log(range.lastIndexOf(5));    // -1
+const range = new PyRange(1, 5, 1); // [1, 2, 3, 4]
+console.log(range.lastIndexOf(3)); // 2
+console.log(range.lastIndexOf(5)); // -1
 ```
 
 ### pop()
@@ -310,9 +310,9 @@ this method removes the last value from the range, shortens the range and
 returns that value.
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log(range.pop());  // 4
-console.log([...range]);   // [1, 2, 3]
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log(range.pop()); // 4
+console.log([...range]); // [1, 2, 3]
 ```
 
 ### slice()
@@ -322,10 +322,10 @@ It returns a new PyRange instance containing elements from the specified indices
 The original range is not modified.
 
 ```javascript
-const range = new PyRange(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+const range = new PyRange(0, 10); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 const sliced = range.slice(2, 5);
 console.log([...sliced]); // [2, 3, 4]
-console.log([...range]);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (unchanged)
+console.log([...range]); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (unchanged)
 
 // Negative indices are supported
 const lastThree = range.slice(-3);
@@ -337,13 +337,13 @@ console.log([...lastThree]); // [7, 8, 9]
 It works the same as [**`Array.prototype.reverse`**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
 
 ```javascript
-const range = new PyRange(1, 5);  // [1, 2, 3, 4]
-console.log([...range]);          // [1, 2, 3, 4]
+const range = new PyRange(1, 5); // [1, 2, 3, 4]
+console.log([...range]); // [1, 2, 3, 4]
 
 const reversed = range.reverse(); // [4, 3, 2, 1]
-console.log([...reversed]);      // [4, 3, 2, 1]
+console.log([...reversed]); // [4, 3, 2, 1]
 
-const rangeWithStep = new PyRange(1, 10, 2);  // [1, 3, 5, 7, 9]
+const rangeWithStep = new PyRange(1, 10, 2); // [1, 3, 5, 7, 9]
 const reversedStep = rangeWithStep.reverse(); // [9, 7, 5, 3, 1]
 console.log([...reversedStep]);
 ```
@@ -354,7 +354,7 @@ It works the same as [**`Array.prototype.entries`**](https://developer.mozilla.o
 It returns an iterator of `[index, value]` pairs.
 
 ```javascript
-const range = new PyRange(1, 4);  // [1, 2, 3]
+const range = new PyRange(1, 4); // [1, 2, 3]
 for (const [index, value] of range.entries()) {
   console.log(index, value);
 }
@@ -369,7 +369,7 @@ It works the same as [**`Array.prototype.keys`**](https://developer.mozilla.org/
 It returns an iterator of the indices of the range.
 
 ```javascript
-const range = new PyRange(3);  // [0, 1, 2]
+const range = new PyRange(3); // [0, 1, 2]
 console.log([...range.keys()]); // [0, 1, 2]
 ```
 
@@ -379,7 +379,7 @@ It works the same as [**`Array.prototype.values`**](https://developer.mozilla.or
 It returns an iterator of the values in the range.
 
 ```javascript
-const range = new PyRange(3);  // [0, 1, 2]
+const range = new PyRange(3); // [0, 1, 2]
 console.log([...range.values()]); // [0, 1, 2]
 ```
 
@@ -392,7 +392,7 @@ const range = new PyRange(3);
 
 // For...of loop
 for (const num of range) {
-    console.log(num); // 0, 1, 2
+  console.log(num); // 0, 1, 2
 }
 
 // Spread operator
@@ -401,7 +401,7 @@ const array = [...range]; // [0, 1, 2]
 
 ### Proxy Access
 
-Proxy access allows access to the array elements using bracket notation, just like a regular array.
+Proxy access allows access to the array elements using bracket notation, just like a regular array. Out-of-bounds access returns `undefined`.
 
 ```javascript
 const range = new PyRange(5);
@@ -409,6 +409,7 @@ const proxy = range.asProxy();
 
 console.log(proxy[0]); // 0
 console.log(proxy[3]); // 3
+console.log(proxy[10]); // undefined
 ```
 
 ### TypeScript Support
@@ -425,13 +426,13 @@ This package is written in TypeScript and provides full type definitions for all
 const range = new PyRange(5);
 
 // TypeScript knows this is a number[]
-const numbers = range.map(x => x * 2);
+const numbers = range.map((x) => x * 2);
 
 // TypeScript knows this is a string[]
-const strings = range.map(x => `Number: ${x}`);
+const strings = range.map((x) => `Number: ${x}`);
 
 // TypeScript knows this is a boolean[]
-const booleans = range.map(x => x % 2 === 0);
+const booleans = range.map((x) => x % 2 === 0);
 ```
 
 ## Examples
@@ -440,9 +441,7 @@ const booleans = range.map(x => x % 2 === 0);
 
 ```javascript
 const range = new PyRange(1, 6);
-const squares = range
-    .filter(x => x % 2 === 0)
-    .map(x => x * x);
+const squares = range.filter((x) => x % 2 === 0).map((x) => x * x);
 console.log(squares); // [4, 16]
 ```
 

package/dist/py-range.d.ts

@@ -6,6 +6,8 @@ declare class PyRange implements Iterable<number> {
     private _stop;
     private _step;
     private _length;
+    private static toIntegerOrInfinity;
+    private static isArrayIndexProperty;
     /**
      * Creates a new PyRange instance.
      * @param {...number} args - The arguments of the range. The possible forms are
@@ -21,7 +23,9 @@ declare class PyRange implements Iterable<number> {
      * @property {number} step - The step of the range.
      * @property {number} length - The length of the range.
      */
-    constructor(...args: number[]);
+    constructor(stop: number);
+    constructor(start: number, stop: number);
+    constructor(start: number, stop: number, step: number);
     /**
      * Gets the length of this range.
      *
@@ -52,11 +56,17 @@ declare class PyRange implements Iterable<number> {
     get step(): number;
     /**
      * Gets the value at the specified index in this range.
-     * @param {number} index - The index of the value to retrieve
-     * @returns {number} The value at the specified index
-     * @throws {RangeError} If the index is out of range
+     *
+     * Negative indices are supported and wrap from the end, matching the
+     * behaviour of `Array.prototype.at()`. For example, `at(-1)` returns the
+     * last element.
+     *
+     * @param {number} index - The index of the value to retrieve. Negative
+     *   indices count from the end of the range.
+     * @returns {number|undefined} The value at the specified index, or
+     *   undefined when the normalised index is out of range.
      */
-    at(index: number): number;
+    at(index: number): number | undefined;
     /**
      * Converts the range to a string.
      * @returns {string} A string of the form `Range(start, stop, step)`.
@@ -71,6 +81,7 @@ declare class PyRange implements Iterable<number> {
      * Validates that the callback is a function.
      * @param {Function} cb - The callback to validate.
      * @throws {TypeError} If the callback is not a function.
+     * @internal
      */
     private static validateCb;
     /**
@@ -92,15 +103,23 @@ declare class PyRange implements Iterable<number> {
     filter(callback: (value: number, index: number, range: PyRange) => boolean): number[];
     /**
      * Reduces the range to a single value.
+     *
+     * Uses rest parameters to reliably distinguish between "no initial value
+     * provided" and "explicit `undefined` passed as initial value", matching
+     * the behaviour of `Array.prototype.reduce()`.
+     *
      * @param {function(T, number, number, PyRange): T} callback - The callback
      * function to apply to every element. The callback should take four
      * arguments: the accumulator, the current value, the index of the current
      * value, and the range object.
      * @param {T} [initialValue] - The initial value of the accumulator.
      * @returns {T} The final value of the accumulator.
+     * @throws {TypeError} If the range is empty and no initial value is provided.
      * @template T
      */
-    reduce<T>(callback: (accumulator: T, value: number, index: number, range: PyRange) => T, initialValue?: T): T;
+    reduce(callback: (accumulator: number, value: number, index: number, range: PyRange) => number): number;
+    reduce(callback: (accumulator: number, value: number, index: number, range: PyRange) => number, initialValue: number): number;
+    reduce<U>(callback: (accumulator: U, value: number, index: number, range: PyRange) => U, initialValue: U): U;
     /**
      * Determines whether at least one element of the range satisfies the
      * provided test.
@@ -149,19 +168,19 @@ declare class PyRange implements Iterable<number> {
      * @param {any} value - The value to search for.
      * @returns {boolean} True if the value is present, false otherwise.
      */
-    includes(value: any): boolean;
+    includes(value: unknown): boolean;
     /**
      * Returns the index of the first occurrence of the specified value, or -1 if it is not present.
      * @param {any} value - The value to search for.
      * @returns {number} The index of the value, or -1 if it is not present.
      */
-    indexOf(value: any): number;
+    indexOf(value: unknown): number;
     /**
      * Returns the index of the last occurrence of the specified value, or -1 if it is not present.
      * @param {any} value - The value to search for.
      * @returns {number} The index of the last occurrence of the value, or -1 if it is not present.
      */
-    lastIndexOf(value: any): number;
+    lastIndexOf(value: unknown): number;
     /**
      * Removes the last element from the range and returns it.
      *
@@ -189,6 +208,10 @@ declare class PyRange implements Iterable<number> {
     slice(begin?: number, end?: number): PyRange;
     /**
      * Reverses the order of the elements in this range, returning a new PyRange object.
+     *
+     * The new range starts at the last actual element of this range and steps
+     * in the opposite direction. The original range is not modified.
+     *
      * @returns {PyRange} A new PyRange object with the elements in reverse order.
      */
     reverse(): PyRange;
@@ -219,17 +242,19 @@ declare class PyRange implements Iterable<number> {
     values(): IterableIterator<number>;
     /**
      * Implements the iterable protocol for this range.
-     * @returns {Iterator<number>} An iterator for this range.
+     * @returns {IterableIterator<number>} An iterator for this range.
      */
-    [Symbol.iterator](): Iterator<number>;
+    [Symbol.iterator](): IterableIterator<number>;
     /**
      * Returns a Proxy for this range, allowing indexed access.
      * This proxy enables accessing range elements via array-like indexing.
      * If the property is a number, it will return the element at that index.
      *
-     * @returns {any} A proxy for the PyRange instance.
+     * @returns {PyRange & { [key: number]: number | undefined }} A proxy for the PyRange instance.
      */
-    asProxy(): any;
+    asProxy(): PyRange & {
+        [key: number]: number | undefined;
+    };
 }
 export { PyRange };
 export default PyRange;

package/dist/py-range.js

@@ -5,21 +5,22 @@ exports.PyRange = void 0;
  * A class that simulates Python's range function, combined with several useful JavaScript array methods.
  */
 class PyRange {
-    /**
-     * Creates a new PyRange instance.
-     * @param {...number} args - The arguments of the range. The possible forms are
-     *   - `PyRange(stop)`
-     *   - `PyRange(start, stop)`
-     *   - `PyRange(start, stop, step)`
-     * @throws {TypeError} If any of the arguments is not a number.
-     * @throws {TypeError} If any of the arguments is not an integer.
-     * @throws {Error} If the step is zero.
-     * @throws {Error} If the arguments count is not between 1 and 3.
-     * @property {number} start - The start of the range, inclusive.
-     * @property {number} stop - The stop of the range, exclusive.
-     * @property {number} step - The step of the range.
-     * @property {number} length - The length of the range.
-     */
+    _start;
+    _stop;
+    _step;
+    _length;
+    static toIntegerOrInfinity(value) {
+        const numeric = +value;
+        return Number.isNaN(numeric) ? 0 : Math.trunc(numeric);
+    }
+    static isArrayIndexProperty(prop) {
+        const index = Number(prop);
+        return (prop !== "" &&
+            Number.isInteger(index) &&
+            index >= 0 &&
+            index < 2 ** 32 - 1 &&
+            String(index) === prop);
+    }
     constructor(...args) {
         if (!args.every((arg) => typeof arg === "number")) {
             throw new TypeError("All arguments must be numbers");
@@ -83,15 +84,23 @@ class PyRange {
     }
     /**
      * Gets the value at the specified index in this range.
-     * @param {number} index - The index of the value to retrieve
-     * @returns {number} The value at the specified index
-     * @throws {RangeError} If the index is out of range
+     *
+     * Negative indices are supported and wrap from the end, matching the
+     * behaviour of `Array.prototype.at()`. For example, `at(-1)` returns the
+     * last element.
+     *
+     * @param {number} index - The index of the value to retrieve. Negative
+     *   indices count from the end of the range.
+     * @returns {number|undefined} The value at the specified index, or
+     *   undefined when the normalised index is out of range.
      */
     at(index) {
-        if (index < 0 || index >= this._length) {
-            throw new RangeError("Index out of range");
+        const relativeIndex = PyRange.toIntegerOrInfinity(index);
+        const normalised = relativeIndex < 0 ? this._length + relativeIndex : relativeIndex;
+        if (normalised < 0 || normalised >= this._length) {
+            return undefined;
         }
-        return this._start + index * this._step;
+        return this._start + normalised * this._step;
     }
     /**
      * Converts the range to a string.
@@ -111,6 +120,7 @@ class PyRange {
      * Validates that the callback is a function.
      * @param {Function} cb - The callback to validate.
      * @throws {TypeError} If the callback is not a function.
+     * @internal
      */
     static validateCb(cb) {
         if (typeof cb !== "function") {
@@ -151,25 +161,16 @@ class PyRange {
         }
         return result;
     }
-    /**
-     * Reduces the range to a single value.
-     * @param {function(T, number, number, PyRange): T} callback - The callback
-     * function to apply to every element. The callback should take four
-     * arguments: the accumulator, the current value, the index of the current
-     * value, and the range object.
-     * @param {T} [initialValue] - The initial value of the accumulator.
-     * @returns {T} The final value of the accumulator.
-     * @template T
-     */
-    reduce(callback, initialValue) {
+    reduce(callback, ...args) {
         PyRange.validateCb(callback);
-        if (this._length === 0 && initialValue === undefined) {
+        const hasInitial = args.length > 0;
+        if (this._length === 0 && !hasInitial) {
             throw new TypeError("Reduce of empty range with no initial value");
         }
         let accumulator;
         let startIndex;
-        if (initialValue !== undefined) {
-            accumulator = initialValue;
+        if (hasInitial) {
+            accumulator = args[0];
             startIndex = 0;
         }
         else {
@@ -373,13 +374,22 @@ class PyRange {
     }
     /**
      * Reverses the order of the elements in this range, returning a new PyRange object.
+     *
+     * The new range starts at the last actual element of this range and steps
+     * in the opposite direction. The original range is not modified.
+     *
      * @returns {PyRange} A new PyRange object with the elements in reverse order.
      */
     reverse() {
-        const result = new PyRange(this._stop, this._start, -this._step);
-        // Force the length to be the same as the original range
-        result._length = this._length;
-        return result;
+        if (this._length === 0) {
+            // Return an empty range with the same step direction — nothing to reverse
+            return new PyRange(this._start, this._start, this._step);
+        }
+        // The new start is the last actual element (not _stop which is exclusive)
+        const newStart = this.at(this._length - 1);
+        // The new stop is one step past the first element in the new direction
+        const newStop = this._start - this._step;
+        return new PyRange(newStart, newStop, -this._step);
     }
     /**
      * Returns an iterator of `[index, value]` pairs for each element in the range.
@@ -418,7 +428,7 @@ class PyRange {
     }
     /**
      * Implements the iterable protocol for this range.
-     * @returns {Iterator<number>} An iterator for this range.
+     * @returns {IterableIterator<number>} An iterator for this range.
      */
     [Symbol.iterator]() {
         let index = 0;
@@ -436,6 +446,9 @@ class PyRange {
                     return { value, done: false };
                 }
             },
+            [Symbol.iterator]() {
+                return this;
+            },
         };
     }
     /**
@@ -443,18 +456,22 @@ class PyRange {
      * This proxy enables accessing range elements via array-like indexing.
      * If the property is a number, it will return the element at that index.
      *
-     * @returns {any} A proxy for the PyRange instance.
+     * @returns {PyRange & { [key: number]: number | undefined }} A proxy for the PyRange instance.
      */
     asProxy() {
         return new Proxy(this, {
-            get(target, prop) {
+            get(target, prop, receiver) {
                 if (typeof prop === "symbol") {
-                    return target[prop];
+                    return Reflect.get(target, prop, receiver);
                 }
-                if (!isNaN(Number(prop))) {
-                    return target.at(parseInt(String(prop), 10));
+                if (PyRange.isArrayIndexProperty(prop)) {
+                    const idx = Number(prop);
+                    // Match Array behaviour: out-of-bounds returns undefined, not throw
+                    if (idx >= target.length)
+                        return undefined;
+                    return target.at(idx);
                 }
-                return target[prop];
+                return Reflect.get(target, prop, receiver);
             },
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "range-pie",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "A TypeScript class that simulates Python's range function, combined with several useful JavaScript array methods.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -22,22 +22,27 @@
   ],
   "scripts": {
     "build": "tsc",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
     "build:prod": "tsc -p tsconfig.prod.json",
     "build:watch": "tsc --watch",
+    "prepare": "husky",
     "prepublishOnly": "npm run build:prod && npm run test",
     "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "lint": "eslint . --ext .ts,.js",
     "lint:fix": "eslint . --ext .ts,.js --fix",
-    "test:watch": "jest --watch",
     "clean": "rimraf dist",
-    "format": "prettier --write \"src/**/*.{ts,js}\" \"test/**/*.{ts,js}\" \"examples/**/*.{ts,js}\" \"types/**/*.{ts,js,json}\" \"*.{js,json}\"",
-    "format:check": "prettier --check \"src/**/*.{ts,js}\" \"test/**/*.{ts,js}\" \"examples/**/*.{ts,js}\" \"types/**/*.{ts,js,json}\" \"*.{js,json}\"",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "example:basic": "node examples/basic-usage.js",
     "example:array": "node examples/array-methods.js",
     "example:advanced": "node examples/advanced-usage.js",
     "example:ts": "ts-node examples/typescript-usage.ts",
     "example:methods": "for file in examples/methods/*.ts; do echo \"\\n=== Running $file ===\"; ts-node \"$file\"; done",
-    "knip": "knip"
+    "knip": "knip",
+    "lint-staged": "lint-staged",
+    "precommit": "npm run typecheck && npm run lint-staged"
   },
   "keywords": [
     "range",
@@ -57,18 +62,23 @@
     "url": "git+https://github.com/SkorpionG/range-pie.git"
   },
   "devDependencies": {
-    "@eslint/js": "^9.28.0",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^24.0.3",
-    "eslint": "^9.28.0",
-    "globals": "^16.2.0",
-    "jest": "^29.7.0",
-    "knip": "^5.61.2",
-    "prettier": "^3.5.3",
-    "rimraf": "^5.0.0",
-    "ts-jest": "^29.1.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.33.1"
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.0.1",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
+    "husky": "^9.1.7",
+    "jest": "^30.4.2",
+    "knip": "^6.23.0",
+    "lint-staged": "^17.0.8",
+    "prettier": "^3.9.1",
+    "rimraf": "^6.1.3",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.62.0"
+  },
+  "overrides": {
+    "js-yaml": "^4.1.2"
   }
 }