@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Number-BvkRkfc-.mjs

@@ -0,0 +1,137 @@
+import { bn as dual } from "./Option-DkxSnBhp.mjs";
+import { c as isGreaterThanOrEqualTo$1, i as Number$1, p as max$1 } from "./Order-C1JC991I.mjs";
+globalThis.Number;
+/**
+* Order instance for `number` values.
+*
+* **When to use**
+*
+* Use when you need to sort or compare numbers through APIs that accept an
+* ordering instance.
+*
+* **Example** (Comparing numbers)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.Order(1, 2) // => -1
+* Number.Order(2, 1) // => 1
+* Number.Order(1, 1) // => 0
+* ```
+*
+* @stability stable
+* @category instances
+* @since 2.0.0
+*/
+const Order = Number$1;
+/**
+* Returns a function that checks if a given `number` is greater than or equal to the provided one.
+*
+* **When to use**
+*
+* Use to test whether one number is greater than or equal to another.
+*
+* **Example** (Checking greater-than-or-equal comparisons)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.isGreaterThanOrEqualTo(2, 3) // => false
+* Number.isGreaterThanOrEqualTo(3, 3) // => true
+* Number.isGreaterThanOrEqualTo(4, 3) // => true
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isGreaterThanOrEqualTo = /*#__PURE__*/ isGreaterThanOrEqualTo$1(Order);
+/**
+* Returns the maximum between two `number`s.
+*
+* **When to use**
+*
+* Use to select the larger of two numbers.
+*
+* **Example** (Finding the maximum)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.max(2, 3) // => 3
+* ```
+*
+* @see {@link min} for selecting the smaller value
+*
+* @stability stable
+* @category math
+* @since 2.0.0
+*/
+const max = /*#__PURE__*/ max$1(Order);
+/**
+* Returns the remainder left over when one operand is divided by a second operand, always taking the sign of the dividend.
+*
+* **When to use**
+*
+* Use to compute a numeric remainder while preserving decimal precision better
+* than direct JavaScript `%` for decimal operands.
+*
+* **Example** (Calculating remainders)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.remainder(2, 2) // => 0
+* Number.remainder(3, 2) // => 1
+* Number.remainder(-4, 2) // => -0
+* ```
+*
+* @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`
+*
+* @stability stable
+* @category math
+* @since 2.0.0
+*/
+const remainder = /*#__PURE__*/ dual(2, (self, divisor) => {
+	if (!globalThis.Number.isFinite(self) || !globalThis.Number.isFinite(divisor) || divisor === 0) return NaN;
+	if (globalThis.Number.isInteger(self) && globalThis.Number.isInteger(divisor)) return self % divisor;
+	const [selfCoefficient, selfExponent] = toScientificInteger(self);
+	const [divisorCoefficient, divisorExponent] = toScientificInteger(divisor);
+	const exponent = Math.min(selfExponent, divisorExponent);
+	const out = selfCoefficient * BigInt(10) ** BigInt(selfExponent - exponent) % (divisorCoefficient * BigInt(10) ** BigInt(divisorExponent - exponent));
+	if (out === BigInt(0)) return self < 0 || Object.is(self, -0) ? -0 : 0;
+	const remainder = globalThis.Number(`${out}e${exponent}`);
+	return remainder === 0 ? Math.sign(self) * globalThis.Number.MIN_VALUE : remainder;
+});
+function toScientificInteger(n) {
+	if (globalThis.Number.isInteger(n)) return [BigInt(n), 0];
+	const scientific = Math.abs(n).toExponential();
+	const eIndex = scientific.indexOf("e");
+	const digits = scientific.slice(0, eIndex).replace(".", "");
+	return [BigInt(digits) * (n < 0 ? -BigInt(1) : BigInt(1)), globalThis.Number(scientific.slice(eIndex + 1)) - digits.length + 1];
+}
+/**
+* Returns the number rounded with the given precision.
+*
+* **When to use**
+*
+* Use to round a number to a fixed number of decimal places.
+*
+* **Example** (Rounding with precision)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.round(1.1234, 2) // => 1.12
+* Number.round(1.567, 2) // => 1.57
+* ```
+*
+* @stability stable
+* @category math
+* @since 3.8.0
+*/
+const round = /*#__PURE__*/ dual(2, (self, precision) => {
+	const factor = Math.pow(10, precision);
+	return Math.round(self * factor) / factor;
+});
+export { round as i, max as n, remainder as r, isGreaterThanOrEqualTo as t };