bigmathex 0.0.1-security → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 krystalreeves85
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,117 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=bigmathex for more information.
+# bigmathex
+
+A lightweight, high-precision **big number** utility for JavaScript and Node.js.
+Designed for financial calculations, blockchain integrations, and any environment where native JavaScript numbers are not enough.
+
+## ✨ Features
+
+- 🔢 Arbitrary-precision math using BigInt
+- ⚡ Zero dependencies — fast & secure
+- 🧮 Easy-to-use math functions (`add`, `sub`, `mul`, `div`, `pow`, etc.)
+- 🧱 Type-safe and stable
+- 🔒 Suitable for cryptography, blockchain, finance, token math
+- 📦 Works in Node.js and bundlers (Vite, Webpack, etc.)
+
+## 📦 Installation
+
+The library is the single JavaScript file *big.js* or the ES module *big.mjs*.
+
+### [Node.js](http://nodejs.org)
+
+```bash
+$ npm install bigmathex
+```
+
+CommonJS:
+
+```javascript
+const Big = require('bigmathex');
+```
+
+ES module:
+
+```javascript
+import Big from 'bigmathex';
+```
+
+## 🚀 Usage
+
+*In the code examples below, semicolons and `toString` calls are not shown.*
+
+The library exports a single constructor function, `Big`.
+
+A Big number is created from a primitive number, string, or other Big number.
+
+```javascript
+x = new Big(123.4567)
+y = Big('123456.7e-3')                 // 'new' is optional
+z = new Big(x)
+x.eq(y) && x.eq(z) && y.eq(z)          // true
+```
+
+In Big strict mode, creating a Big number from a primitive number is disallowed.
+
+```javascript
+Big.strict = true
+x = new Big(1)                         // TypeError: [bigmathex] Invalid number
+y = new Big('1.0000000000000001')
+y.toNumber()                           // Error: [bigmathex] Imprecise conversion
+```
+
+A Big number is immutable in the sense that it is not changed by its methods.
+
+```javascript
+0.3 - 0.1                              // 0.19999999999999998
+x = new Big(0.3)
+x.minus(0.1)                           // "0.2"
+x                                      // "0.3"
+```
+
+The methods that return a Big number can be chained.
+
+```javascript
+x.div(y).plus(z).times(9).minus('1.234567801234567e+8').plus(976.54321).div('2598.11772')
+x.sqrt().div(y).pow(3).gt(y.mod(z))    // true
+```
+
+Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods.
+
+```javascript
+x = new Big(255.5)
+x.toExponential(5)                     // "2.55500e+2"
+x.toFixed(5)                           // "255.50000"
+x.toPrecision(5)                       // "255.50"
+```
+
+The arithmetic methods always return the exact result except `div`, `sqrt` and `pow`
+(with negative exponent), as these methods involve division.
+
+The maximum number of decimal places and the rounding mode used to round the results of these methods is determined by the value of the `DP` and `RM` properties of the `Big` number constructor.
+
+```javascript
+Big.DP = 10
+Big.RM = Big.roundHalfUp
+
+x = new Big(2);
+y = new Big(3);
+z = x.div(y)                           // "0.6666666667"
+z.sqrt()                               // "0.8164965809"
+z.pow(-3)                              // "3.3749999995"
+z.times(z)                             // "0.44444444448888888889"
+z.times(z).round(10)                   // "0.4444444445"
+```
+
+The value of a Big number is stored in a decimal floating point format in terms of a coefficient, exponent and sign.
+
+```javascript
+x = new Big(-123.456);
+x.c                                    // [1,2,3,4,5,6]    coefficient (i.e. significand)
+x.e                                    // 2                exponent
+x.s                                    // -1               sign
+```
+
+For advanced usage, multiple Big number constructors can be created, each with an independent configuration.
+
+## 📄 Licence
+
+[MIT](LICENCE.md)