@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Duration-EH9Vy4U6.mjs

@@ -0,0 +1,791 @@
+import { Bt as hash, Ct as NodeInspectSymbol, Kt as symbol, Lt as symbol$1, On as pipeArguments, Sn as identity, Wt as structure, bn as dual, in as isNumber, qt as hasProperty } from "./Option-DkxSnBhp.mjs";
+import { d as make$1, m as min$1, p as max$1, u as isLessThanOrEqualTo$1 } from "./Order-C1JC991I.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Duration.js
+const TypeId = "~effect/Duration";
+const bigint0 = /*#__PURE__*/ BigInt(0);
+const bigint1 = /*#__PURE__*/ BigInt(1);
+const bigint2 = /*#__PURE__*/ BigInt(2);
+const bigint10 = /*#__PURE__*/ BigInt(10);
+const bigint24 = /*#__PURE__*/ BigInt(24);
+const bigint60 = /*#__PURE__*/ BigInt(60);
+const bigint1e3 = /*#__PURE__*/ BigInt(1e3);
+const bigint1e6 = /*#__PURE__*/ BigInt(1e6);
+const bigint1e9 = /*#__PURE__*/ BigInt(1e9);
+const bigintNanosPerMinute = /*#__PURE__*/ BigInt(6e10);
+const bigintNanosPerHour = /*#__PURE__*/ BigInt(36e11);
+const bigintNanosPerDay = /*#__PURE__*/ BigInt(864e11);
+const bigintNanosPerWeek = /*#__PURE__*/ BigInt(6048e11);
+const roundTiesAwayFromZero = (input) => BigInt(Math.sign(input) * Math.round(Math.abs(input)));
+const roundMillisToNanos = (millis) => Number.isInteger(millis) ? BigInt(millis) * bigint1e6 : roundTiesAwayFromZero(millis * 1e6);
+const fromNanosNumber = (nanos) => make(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos);
+const nanosToUnit = (nanos, divisor) => {
+	const value = Number(nanos);
+	if (Number.isFinite(value)) return value / divisor;
+	const scale = BigInt(divisor);
+	return Number(nanos / scale) + Number(nanos % scale) / divisor;
+};
+const parseNanos = (input, scale) => {
+	const decimalIndex = input.indexOf(".");
+	if (decimalIndex === -1) return BigInt(input) * scale;
+	const isNegative = input[0] === "-";
+	const fractional = input.slice(decimalIndex + 1);
+	const fractionalScale = bigint10 ** BigInt(fractional.length);
+	const scaled = (BigInt(input.slice(isNegative ? 1 : 0, decimalIndex)) * fractionalScale + BigInt(fractional)) * scale;
+	return divideTiesAwayFromZero(isNegative ? -scaled : scaled, fractionalScale);
+};
+const divideTiesAwayFromZero = (numerator, denominator) => {
+	const absolute = numerator < bigint0 ? -numerator : numerator;
+	const rounded = absolute / denominator + (absolute % denominator * bigint2 >= denominator ? bigint1 : bigint0);
+	return numerator < bigint0 ? -rounded : rounded;
+};
+const fromMillisString = (input, scale) => {
+	const millis = Number(input) * scale;
+	if (!Number.isFinite(millis)) return make(millis);
+	const nanos = parseNanos(input, BigInt(scale) * bigint1e6);
+	return make(Number.isInteger(millis) && BigInt(millis) * bigint1e6 === nanos ? millis : nanos);
+};
+const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;
+/**
+* Decodes a `Duration.Input` into a `Duration`.
+*
+* **When to use**
+*
+* Use when the input has already been validated or comes from a trusted source
+* and throwing is acceptable for invalid duration syntax.
+*
+* **Gotchas**
+*
+* If the input is not a valid `Duration.Input`, it throws an error.
+*
+* **Example** (Decoding duration inputs)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.fromInputUnsafe(1000) // => Duration.millis(1000)
+* Duration.fromInputUnsafe("5 seconds") // => Duration.seconds(5)
+* Duration.fromInputUnsafe("Infinity") // => Duration.infinity
+* Duration.fromInputUnsafe([2, 500_000_000]) // => Duration.nanos(2_500_000_000n)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromInputUnsafe = (input) => {
+	switch (typeof input) {
+		case "number": return millis(input);
+		case "bigint": return nanos(input);
+		case "string": {
+			if (input === "Infinity") return infinity;
+			if (input === "-Infinity") return negativeInfinity;
+			const match = DURATION_REGEXP.exec(input);
+			if (!match) break;
+			const [_, valueStr, unit] = match;
+			if (unit === "nano" || unit === "nanos") return nanos(parseNanos(valueStr, bigint1));
+			if (unit === "micro" || unit === "micros") return nanos(parseNanos(valueStr, bigint1e3));
+			switch (unit) {
+				case "milli":
+				case "millis": return fromMillisString(valueStr, 1);
+				case "second":
+				case "seconds": return fromMillisString(valueStr, 1e3);
+				case "minute":
+				case "minutes": return fromMillisString(valueStr, 6e4);
+				case "hour":
+				case "hours": return fromMillisString(valueStr, 36e5);
+				case "day":
+				case "days": return fromMillisString(valueStr, 864e5);
+				case "week":
+				case "weeks": return fromMillisString(valueStr, 6048e5);
+			}
+			break;
+		}
+		case "object": {
+			if (input === null) break;
+			if (TypeId in input) return input;
+			if (Array.isArray(input)) {
+				if (input.length !== 2 || !input.every(isNumber)) return invalid(input);
+				if (Number.isNaN(input[0]) || Number.isNaN(input[1])) return zero;
+				if (input[0] === -Infinity || input[1] === -Infinity) return negativeInfinity;
+				if (input[0] === Infinity || input[1] === Infinity) return infinity;
+				const nanos = input[0] * 1e9 + input[1];
+				return Number.isFinite(nanos) && Number.isInteger(input[0]) && Number.isInteger(input[1]) ? make(BigInt(input[0]) * bigint1e9 + BigInt(input[1])) : fromNanosNumber(nanos);
+			}
+			const obj = input;
+			let millis = 0;
+			if (obj.weeks) millis += obj.weeks * 6048e5;
+			if (obj.days) millis += obj.days * 864e5;
+			if (obj.hours) millis += obj.hours * 36e5;
+			if (obj.minutes) millis += obj.minutes * 6e4;
+			if (obj.seconds) millis += obj.seconds * 1e3;
+			if (obj.milliseconds) millis += obj.milliseconds;
+			if (!obj.microseconds && !obj.nanoseconds) {
+				if (!Number.isFinite(millis)) return make(millis);
+				const exact = sumObjectNanos(obj);
+				return exact === void 0 || BigInt(millis) * bigint1e6 === exact ? make(millis) : make(exact);
+			}
+			const nanos = millis * 1e6 + (obj.microseconds ?? 0) * 1e3 + (obj.nanoseconds ?? 0);
+			const exact = Number.isFinite(nanos) ? sumObjectNanos(obj) : void 0;
+			return exact === void 0 ? fromNanosNumber(nanos) : make(exact);
+		}
+	}
+	return invalid(input);
+};
+const isIntegerOrUnset = (n) => !n || Number.isInteger(n);
+const sumObjectNanos = (obj) => {
+	if (!isIntegerOrUnset(obj.weeks) || !isIntegerOrUnset(obj.days) || !isIntegerOrUnset(obj.hours) || !isIntegerOrUnset(obj.minutes) || !isIntegerOrUnset(obj.seconds) || !isIntegerOrUnset(obj.milliseconds) || !isIntegerOrUnset(obj.microseconds) || !isIntegerOrUnset(obj.nanoseconds)) return void 0;
+	let nanos = bigint0;
+	if (obj.weeks) nanos += BigInt(obj.weeks) * bigintNanosPerWeek;
+	if (obj.days) nanos += BigInt(obj.days) * bigintNanosPerDay;
+	if (obj.hours) nanos += BigInt(obj.hours) * bigintNanosPerHour;
+	if (obj.minutes) nanos += BigInt(obj.minutes) * bigintNanosPerMinute;
+	if (obj.seconds) nanos += BigInt(obj.seconds) * bigint1e9;
+	if (obj.milliseconds) nanos += BigInt(obj.milliseconds) * bigint1e6;
+	if (obj.microseconds) nanos += BigInt(obj.microseconds) * bigint1e3;
+	if (obj.nanoseconds) nanos += BigInt(obj.nanoseconds);
+	return nanos;
+};
+const invalid = (input) => {
+	throw new Error(`Invalid Input: ${input}`);
+};
+const zeroDurationValue = {
+	_tag: "Millis",
+	millis: 0
+};
+const infinityDurationValue = { _tag: "Infinity" };
+const negativeInfinityDurationValue = { _tag: "NegativeInfinity" };
+const DurationProto = {
+	[TypeId]: TypeId,
+	[symbol]() {
+		switch (this.value._tag) {
+			case "Millis": return hash(roundMillisToNanos(this.value.millis));
+			case "Nanos": return hash(this.value.nanos);
+			default: return structure(this.value);
+		}
+	},
+	[symbol$1](that) {
+		return isDuration(that) && equals(this, that);
+	},
+	toString() {
+		switch (this.value._tag) {
+			case "Infinity": return "Infinity";
+			case "NegativeInfinity": return "-Infinity";
+			case "Nanos": return `${this.value.nanos} nanos`;
+			case "Millis": return `${this.value.millis} millis`;
+		}
+	},
+	toJSON() {
+		switch (this.value._tag) {
+			case "Millis": return {
+				_id: "Duration",
+				_tag: "Millis",
+				millis: this.value.millis
+			};
+			case "Nanos": return {
+				_id: "Duration",
+				_tag: "Nanos",
+				nanos: String(this.value.nanos)
+			};
+			case "Infinity": return {
+				_id: "Duration",
+				_tag: "Infinity"
+			};
+			case "NegativeInfinity": return {
+				_id: "Duration",
+				_tag: "NegativeInfinity"
+			};
+		}
+	},
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const make = (input) => {
+	const duration = Object.create(DurationProto);
+	if (typeof input === "number") {
+		if (isNaN(input) || input === 0 || Object.is(input, -0)) duration.value = zeroDurationValue;
+		else if (!Number.isFinite(input)) duration.value = input > 0 ? infinityDurationValue : negativeInfinityDurationValue;
+		else if (!Number.isInteger(input)) duration.value = {
+			_tag: "Nanos",
+			nanos: roundMillisToNanos(input)
+		};
+		else duration.value = {
+			_tag: "Millis",
+			millis: input
+		};
+	} else if (input === bigint0) duration.value = zeroDurationValue;
+	else duration.value = {
+		_tag: "Nanos",
+		nanos: input
+	};
+	return duration;
+};
+/**
+* Checks whether a value is a Duration.
+*
+* **Example** (Checking for durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.isDuration(Duration.seconds(1)) // => true
+* Duration.isDuration(1000) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isDuration = (u) => hasProperty(u, TypeId);
+/**
+* Checks whether a Duration is finite (not infinite).
+*
+* **Example** (Checking finite durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.isFinite(Duration.seconds(5)) // => true
+* Duration.isFinite(Duration.infinity) // => false
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const isFinite = (self) => self.value._tag !== "Infinity" && self.value._tag !== "NegativeInfinity";
+/**
+* Checks whether a Duration is zero.
+*
+* **Example** (Checking for zero durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.isZero(Duration.zero) // => true
+* Duration.isZero(Duration.seconds(1)) // => false
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 3.5.0
+*/
+const isZero = (self) => {
+	switch (self.value._tag) {
+		case "Millis": return self.value.millis === 0;
+		case "Nanos": return self.value.nanos === bigint0;
+		case "Infinity":
+		case "NegativeInfinity": return false;
+	}
+};
+/**
+* Returns `true` if the duration is negative (strictly less than zero).
+*
+* **Example** (Checking for negative durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.isNegative(Duration.seconds(-5)) // => true
+* Duration.isNegative(Duration.zero) // => false
+* Duration.isNegative(Duration.negativeInfinity) // => true
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isNegative = (self) => {
+	switch (self.value._tag) {
+		case "Millis": return self.value.millis < 0;
+		case "Nanos": return self.value.nanos < bigint0;
+		case "NegativeInfinity": return true;
+		case "Infinity": return false;
+	}
+};
+/**
+* Returns the absolute value of the duration.
+*
+* **Example** (Taking absolute duration values)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.abs(Duration.seconds(-5)) // => Duration.seconds(5)
+* Duration.abs(Duration.negativeInfinity) // => Duration.infinity
+* ```
+*
+* @stability stable
+* @category math
+* @since 4.0.0
+*/
+const abs = (self) => {
+	switch (self.value._tag) {
+		case "Infinity":
+		case "NegativeInfinity": return infinity;
+		case "Millis": return self.value.millis < 0 ? make(-self.value.millis) : self;
+		case "Nanos": return self.value.nanos < bigint0 ? make(-self.value.nanos) : self;
+	}
+};
+/**
+* A Duration representing zero time.
+*
+* **Example** (Referencing the zero duration)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.zero) // => 0
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const zero = /*#__PURE__*/ make(0);
+/**
+* A Duration representing infinite time.
+*
+* **Example** (Referencing infinite duration)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.infinity) // => Infinity
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const infinity = /*#__PURE__*/ make(Infinity);
+/**
+* A Duration representing negative infinite time.
+*
+* **Example** (Referencing negative infinite duration)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.negativeInfinity) // => -Infinity
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const negativeInfinity = /*#__PURE__*/ make(-Infinity);
+/**
+* Creates a Duration from nanoseconds.
+*
+* **Example** (Creating durations from nanoseconds)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.nanos(500_000_000n) // => Duration.nanos(500_000_000n)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const nanos = (nanos) => make(nanos);
+/**
+* Creates a Duration from milliseconds.
+*
+* **Example** (Creating durations from milliseconds)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.millis(1000)) // => 1000
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const millis = (millis) => make(millis);
+/**
+* Creates a Duration from seconds.
+*
+* **Example** (Creating durations from seconds)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.seconds(30)) // => 30_000
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const seconds = (seconds) => make(seconds * 1e3);
+/**
+* Converts a Duration to milliseconds.
+*
+* **Example** (Converting durations to milliseconds)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.seconds(5)) // => 5000
+* Duration.toMillis(Duration.minutes(2)) // => 120_000
+* ```
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const toMillis = (self) => match(fromInputUnsafe(self), {
+	onMillis: identity,
+	onNanos: (nanos) => nanosToUnit(nanos, 1e6),
+	onInfinity: () => Infinity,
+	onNegativeInfinity: () => -Infinity
+});
+/**
+* Converts a Duration to seconds.
+*
+* **Example** (Converting durations to seconds)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toSeconds(Duration.millis(5000)) // => 5
+* Duration.toSeconds(Duration.minutes(2)) // => 120
+* ```
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const toSeconds = (self) => match(fromInputUnsafe(self), {
+	onMillis: (millis) => millis / 1e3,
+	onNanos: (nanos) => nanosToUnit(nanos, 1e9),
+	onInfinity: () => Infinity,
+	onNegativeInfinity: () => -Infinity
+});
+/**
+* Gets the duration in nanoseconds as a bigint.
+*
+* **When to use**
+*
+* Use when the duration is known to be finite and you need the nanosecond value
+* as a `bigint`.
+*
+* **Details**
+*
+* Millisecond-backed fractional durations are rounded to the nearest
+* nanosecond, with ties away from zero.
+*
+* **Gotchas**
+*
+* If the duration is infinite, it throws an error.
+*
+* **Example** (Reading nanoseconds unsafely)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toNanosUnsafe(Duration.seconds(2)) // => 2_000_000_000n
+*
+* // Duration.toNanosUnsafe(Duration.infinity)
+* // throws Error: "Cannot convert infinite duration to nanos"
+* ```
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const toNanosUnsafe = (input) => {
+	const self = fromInputUnsafe(input);
+	switch (self.value._tag) {
+		case "Infinity":
+		case "NegativeInfinity": throw new Error("Cannot convert infinite duration to nanos");
+		case "Nanos": return self.value.nanos;
+		case "Millis": return roundMillisToNanos(self.value.millis);
+	}
+};
+/**
+* Pattern matches on the representation of a `Duration`.
+*
+* **Details**
+*
+* Provide handlers for millisecond-backed values, nanosecond-backed values,
+* and positive infinity. Use `onNegativeInfinity` to handle negative infinity
+* separately; otherwise negative infinity is handled by `onInfinity`.
+*
+* **Example** (Pattern matching on duration representations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.match(Duration.seconds(5), {
+*   onMillis: (millis) => `${millis} milliseconds`,
+*   onNanos: (nanos) => `${nanos} nanoseconds`,
+*   onInfinity: () => "infinite"
+* }) // => "5000 milliseconds"
+* ```
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match = /*#__PURE__*/ dual(2, (self, options) => {
+	switch (self.value._tag) {
+		case "Millis": return options.onMillis(self.value.millis);
+		case "Nanos": return options.onNanos(self.value.nanos);
+		case "Infinity": return options.onInfinity();
+		case "NegativeInfinity": return (options.onNegativeInfinity ?? options.onInfinity)();
+	}
+});
+/**
+* Pattern matches on two `Duration`s, providing handlers that receive both values.
+*
+* **Example** (Pattern matching on duration pairs)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.matchPair(Duration.seconds(3), Duration.seconds(2), {
+*   onMillis: (a, b) => a + b,
+*   onNanos: (a, b) => Number(a + b),
+*   onInfinity: () => Infinity
+* }) // => 5000
+* ```
+*
+* @stability stable
+* @category pattern matching
+* @since 4.0.0
+*/
+const matchPair = /*#__PURE__*/ dual(3, (self, that, options) => {
+	if (self.value._tag === "Infinity" || self.value._tag === "NegativeInfinity" || that.value._tag === "Infinity" || that.value._tag === "NegativeInfinity") return options.onInfinity(self, that);
+	if (self.value._tag === "Millis") return that.value._tag === "Millis" ? options.onMillis(self.value.millis, that.value.millis) : options.onNanos(toNanosUnsafe(self), that.value.nanos);
+	else return options.onNanos(self.value.nanos, toNanosUnsafe(that));
+});
+/**
+* Provides an `Order` instance for comparing `Duration` values.
+*
+* **Details**
+*
+* `NegativeInfinity` < any finite value < `Infinity`.
+*
+* **Example** (Sorting durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* const durations = [
+*   Duration.seconds(3),
+*   Duration.seconds(1),
+*   Duration.seconds(2)
+* ]
+* durations.sort((a, b) => Duration.Order(a, b)).map(Duration.toSeconds) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category instances
+* @since 2.0.0
+*/
+const Order = /*#__PURE__*/ make$1((self, that) => matchPair(self, that, {
+	onMillis: (self, that) => self < that ? -1 : self > that ? 1 : 0,
+	onNanos: (self, that) => self < that ? -1 : self > that ? 1 : 0,
+	onInfinity: (self, that) => {
+		if (self.value._tag === that.value._tag) return 0;
+		if (self.value._tag === "Infinity") return 1;
+		if (self.value._tag === "NegativeInfinity") return -1;
+		if (that.value._tag === "Infinity") return -1;
+		return 1;
+	}
+}));
+/**
+* Provides an `Equivalence` instance for comparing `Duration` values.
+*
+* **Example** (Comparing durations for equivalence)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.Equivalence(Duration.seconds(5), Duration.millis(5000)) // => true
+* ```
+*
+* @stability stable
+* @category instances
+* @since 2.0.0
+*/
+const Equivalence = (self, that) => matchPair(self, that, {
+	onMillis: (self, that) => self === that,
+	onNanos: (self, that) => self === that,
+	onInfinity: (self, that) => self.value._tag === that.value._tag
+});
+/**
+* Returns the smaller of two Durations.
+*
+* **Example** (Selecting the shorter duration)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.min(Duration.seconds(5), Duration.seconds(3)) // => Duration.seconds(3)
+* ```
+*
+* @stability stable
+* @category ordering
+* @since 2.0.0
+*/
+const min = /*#__PURE__*/ min$1(Order);
+/**
+* Returns the larger of two Durations.
+*
+* **Example** (Selecting the longer duration)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.max(Duration.seconds(5), Duration.seconds(3)) // => Duration.seconds(5)
+* ```
+*
+* @stability stable
+* @category ordering
+* @since 2.0.0
+*/
+const max = /*#__PURE__*/ max$1(Order);
+/**
+* Checks whether the first Duration is less than or equal to the second.
+*
+* **Example** (Comparing durations with less than or equal)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.isLessThanOrEqualTo(
+*   Duration.seconds(5),
+*   Duration.seconds(5)
+* ) // => true
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isLessThanOrEqualTo = /*#__PURE__*/ isLessThanOrEqualTo$1(Order);
+/**
+* Checks whether two Durations are equal.
+*
+* **Example** (Checking duration equality)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.equals(Duration.seconds(5), Duration.millis(5000)) // => true
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const equals = /*#__PURE__*/ dual(2, (self, that) => Equivalence(self, that));
+/**
+* Decomposes a `Duration` into normalized signed components.
+*
+* **Details**
+*
+* Finite durations are returned as `{ days, hours, minutes, seconds, millis,
+* nanos }`. Infinite durations return every component as `Infinity` or
+* `-Infinity`.
+*
+* **Example** (Decomposing durations into parts)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* // Create a complex duration by adding multiple parts
+* const duration = Duration.sum(
+*   Duration.sum(
+*     Duration.sum(Duration.days(1), Duration.hours(2)),
+*     Duration.sum(Duration.minutes(30), Duration.seconds(45))
+*   ),
+*   Duration.millis(123)
+* )
+* Duration.parts(duration) // => ({ days: 1, hours: 2, minutes: 30, seconds: 45, millis: 123, nanos: 0 })
+*
+* const complex = Duration.sum(Duration.hours(25), Duration.minutes(90))
+* Duration.parts(complex) // => ({ days: 1, hours: 2, minutes: 30, seconds: 0, millis: 0, nanos: 0 })
+* ```
+*
+* @stability stable
+* @category converting
+* @since 3.8.0
+*/
+const parts = (self) => {
+	if (self.value._tag === "Infinity") return {
+		days: Infinity,
+		hours: Infinity,
+		minutes: Infinity,
+		seconds: Infinity,
+		millis: Infinity,
+		nanos: Infinity
+	};
+	if (self.value._tag === "NegativeInfinity") return {
+		days: -Infinity,
+		hours: -Infinity,
+		minutes: -Infinity,
+		seconds: -Infinity,
+		millis: -Infinity,
+		nanos: -Infinity
+	};
+	const n = toNanosUnsafe(self);
+	const neg = n < bigint0;
+	const a = neg ? -n : n;
+	const ms = a / bigint1e6;
+	const sec = ms / bigint1e3;
+	const min = sec / bigint60;
+	const hr = min / bigint60;
+	const d = hr / bigint24;
+	const sign = neg ? -1 : 1;
+	return {
+		days: sign * Number(d),
+		hours: sign * Number(hr % bigint24),
+		minutes: sign * Number(min % bigint60),
+		seconds: sign * Number(sec % bigint60),
+		millis: sign * Number(ms % bigint1e3),
+		nanos: sign * Number(a % bigint1e6)
+	};
+};
+/**
+* Converts a `Duration` to a human readable string.
+*
+* **Example** (Formatting durations)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.format(Duration.millis(1000)) // => "1s"
+* Duration.format(Duration.millis(1001)) // => "1s 1ms"
+* ```
+*
+* @stability stable
+* @category converting
+* @since 2.0.0
+*/
+const format = (self) => {
+	if (self.value._tag === "Infinity") return "Infinity";
+	if (self.value._tag === "NegativeInfinity") return "-Infinity";
+	if (isZero(self)) return "0";
+	if (isNegative(self)) return "-" + format(abs(self));
+	const fragments = parts(self);
+	const pieces = [];
+	if (fragments.days !== 0) pieces.push(`${fragments.days}d`);
+	if (fragments.hours !== 0) pieces.push(`${fragments.hours}h`);
+	if (fragments.minutes !== 0) pieces.push(`${fragments.minutes}m`);
+	if (fragments.seconds !== 0) pieces.push(`${fragments.seconds}s`);
+	if (fragments.millis !== 0) pieces.push(`${fragments.millis}ms`);
+	if (fragments.nanos !== 0) pieces.push(`${fragments.nanos}ns`);
+	return pieces.join(" ");
+};
+export { isFinite as a, max as c, nanos as d, negativeInfinity as f, zero as g, toSeconds as h, isDuration as i, millis as l, toMillis as m, fromInputUnsafe as n, isLessThanOrEqualTo as o, seconds as p, infinity as r, isZero as s, format as t, min as u };