effect 4.0.0-beta.70 → 4.0.0-beta.71

package/dist/Order.js

@@ -1,51 +1,80 @@
 /**
- * This module provides the `Order` type class for defining total orderings on types.
- * An `Order` is a comparison function that returns `-1` (less than), `0` (equal), or `1` (greater than).
- *
- * Mental model:
- * - An `Order<A>` is a pure function `(a: A, b: A) => Ordering` that compares two values
- * - The result `-1` means the first value is less than the second
- * - The result `0` means the values are equal according to this ordering
- * - The result `1` means the first value is greater than the second
- * - Orders must satisfy total ordering laws: totality (either `x <= y` or `y <= x`), antisymmetry (if `x <= y` and `y <= x` then `x == y`), and transitivity (if `x <= y` and `y <= z` then `x <= z`)
- * - Orders can be composed using {@link combine} and {@link combineAll} to create multi-criteria comparisons
- * - Orders can be transformed using {@link mapInput} to compare values by extracting a comparable property
- * - Built-in orders exist for common types: {@link Number}, {@link String}, {@link Boolean}, {@link BigInt}, {@link Date}
- *
- * Common tasks:
- * - Creating custom orders → {@link make}
- * - Using built-in orders → {@link Number}, {@link String}, {@link Boolean}, {@link BigInt}, {@link Date}
- * - Combining multiple orders → {@link combine}, {@link combineAll}
- * - Transforming orders → {@link mapInput}
- * - Comparing values → {@link isLessThan}, {@link isGreaterThan}, {@link isLessThanOrEqualTo}, {@link isGreaterThanOrEqualTo}
- * - Finding min/max → {@link min}, {@link max}
- * - Clamping values → {@link clamp}, {@link isBetween}
- * - Ordering collections → {@link Array}, {@link Tuple}, {@link Struct}
- *
- * Gotchas:
- * - `Order.Number` treats all `NaN` values as equal and less than any other number
- * - `Order.make` uses reference equality (`===`) as a shortcut: if `self === that`, it returns `0` without calling the comparison function
- * - `Order.Array` compares arrays element-by-element, then by length if all elements are equal; `Order.all` only compares elements up to the shorter array's length
- * - `Order.Tuple` requires a fixed-length tuple with matching order types; `Order.Array` works with variable-length arrays
- * - `Order.min` and `Order.max` return the first argument when values are equal
- *
- * Quickstart:
- *
- * **Example** (Basic Usage)
+ * The `Order` module defines total orderings: pure comparison functions that
+ * decide whether one value is less than, equal to, or greater than another. An
+ * `Order<A>` returns a normalized {@link Ordering} (`-1`, `0`, or `1`), making
+ * it suitable for sorting, finding minimum and maximum values, range checks, and
+ * building ordered data structures.
+ *
+ * **Mental model**
+ *
+ * - An {@link Order} is a comparator with laws: totality, antisymmetry, and
+ *   transitivity. If those laws do not hold, sorting and range operations can
+ *   produce surprising results.
+ * - `-1` means the left value comes before the right value, `0` means they are
+ *   equal for this ordering, and `1` means the left value comes after the right
+ *   value.
+ * - Primitive orders such as {@link Number}, {@link String}, {@link Boolean},
+ *   {@link BigInt}, and {@link Date} are building blocks.
+ * - Use {@link mapInput} to compare larger values by a field or derived key.
+ * - Use {@link combine} or {@link combineAll} for tie-breaking, where the first
+ *   non-zero comparison result wins.
+ *
+ * **Common tasks**
+ *
+ * - Create a custom order from a comparison function with {@link make}.
+ * - Sort or compare using built-in orders such as {@link Number} and
+ *   {@link String}.
+ * - Compare records and tuples with {@link Struct} and {@link Tuple}.
+ * - Compare arrays lexicographically with {@link Array}.
+ * - Convert an order into predicates with {@link isLessThan},
+ *   {@link isGreaterThan}, {@link isLessThanOrEqualTo}, and
+ *   {@link isGreaterThanOrEqualTo}.
+ * - Select boundaries with {@link min}, {@link max}, {@link clamp}, and
+ *   {@link isBetween}.
+ *
+ * **Gotchas**
+ *
+ * - {@link make} returns `0` immediately when `self === that`; the custom
+ *   comparison function is not called for identical references.
+ * - {@link Number} treats all `NaN` values as equal to each other and less than
+ *   every non-`NaN` number.
+ * - {@link Array} compares elements first and length second. {@link Tuple}
+ *   compares a fixed number of positions.
+ * - {@link Struct} compares fields in the key order of the object passed to it,
+ *   so put the highest-priority fields first.
+ * - {@link min} and {@link max} return the first argument when two values
+ *   compare as equal.
+ *
+ * **Example** (Sorting by multiple fields)
  *
  * ```ts
- * import { Order } from "effect"
- *
- * const result = Order.Number(5, 10)
- * console.log(result) // -1 (5 is less than 10)
- *
- * const isLessThan = Order.isLessThan(Order.Number)(5, 10)
- * console.log(isLessThan) // true
+ * import { Array, Order } from "effect"
+ *
+ * interface User {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const byAge = Order.mapInput(Order.Number, (user: User) => user.age)
+ * const byName = Order.mapInput(Order.String, (user: User) => user.name)
+ * const byAgeThenName = Order.combine(byAge, byName)
+ *
+ * const users = [
+ *   { name: "Charlie", age: 30 },
+ *   { name: "Bob", age: 25 },
+ *   { name: "Alice", age: 30 }
+ * ]
+ *
+ * const sorted = Array.sort(users, byAgeThenName)
+ * console.log(sorted.map((user) => user.name))
+ * // ["Bob", "Alice", "Charlie"]
  * ```
  *
- * See also:
- * - {@link Ordering} - The result type of comparisons
- * - {@link Reducer} - For combining orders in collections
+ * **See also**
+ *
+ * - {@link Ordering} for the normalized comparison result type.
+ * - `Equivalence` for equality without less-than or greater-than.
+ * - {@link Reducer} for combining orders with reducer-style APIs.
  *
  * @since 2.0.0
  */
@@ -56,7 +85,7 @@ import * as Reducer from "./Reducer.js";
  *
  * **When to use**
  *
- * - When creating a custom order for a type that doesn't have a built-in order
+ * Use when when creating a custom order for a type that doesn't have a built-in order
  * - When you need fine-grained control over comparison logic
  * - When implementing orders for complex types
  *
@@ -82,8 +111,8 @@ import * as Reducer from "./Reducer.js";
  * console.log(byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 })) // -1
  * ```
  *
- * @see {@link mapInput} - Transform an order by mapping the input type
- * @see {@link combine} - Combine multiple orders
+ * @see {@link mapInput} to transform an order by mapping the input type
+ * @see {@link combine} to combine multiple orders
  * @category constructors
  * @since 2.0.0
  */
@@ -95,7 +124,7 @@ export function make(compare) {
  *
  * **When to use**
  *
- * - When comparing strings alphabetically
+ * Use when when comparing strings alphabetically
  * - When sorting string collections
  * - As a base for creating orders on types containing strings
  *
@@ -116,8 +145,8 @@ export function make(compare) {
  * console.log(Order.String("apple", "apple")) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a string property
- * @see {@link Struct} - Combine with other orders for struct comparison
+ * @see {@link mapInput} to compare objects by a string property
+ * @see {@link Struct} to combine with other orders for struct comparison
  * @category instances
  * @since 4.0.0
  */
@@ -127,7 +156,7 @@ export const String = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * - When comparing numbers for sorting or searching
+ * Use when when comparing numbers for sorting or searching
  * - As a base for creating orders on types containing numbers
  * - When implementing numeric comparisons in data structures
  *
@@ -152,8 +181,8 @@ export const String = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  * console.log(Order.Number(NaN, 1)) // -1
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a number property
- * @see {@link BigInt} - For bigint comparisons
+ * @see {@link mapInput} to compare objects by a number property
+ * @see {@link BigInt} for bigint comparisons
  * @category instances
  * @since 4.0.0
  */
@@ -168,7 +197,7 @@ export const Number = /*#__PURE__*/make((self, that) => {
  *
  * **When to use**
  *
- * - When comparing booleans for sorting or searching
+ * Use when when comparing booleans for sorting or searching
  * - As a base for creating orders on types containing booleans
  * - When implementing boolean-based comparisons
  *
@@ -188,7 +217,7 @@ export const Number = /*#__PURE__*/make((self, that) => {
  * console.log(Order.Boolean(true, true)) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a boolean property
+ * @see {@link mapInput} to compare objects by a boolean property
  * @category instances
  * @since 4.0.0
  */
@@ -198,7 +227,7 @@ export const Boolean = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * - When comparing bigint values for sorting or searching
+ * Use when when comparing bigint values for sorting or searching
  * - As a base for creating orders on types containing bigints
  * - When working with large integers that exceed number precision
  *
@@ -218,8 +247,8 @@ export const Boolean = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  * console.log(Order.BigInt(1n, 1n)) // 0
  * ```
  *
- * @see {@link Number} - For regular number comparisons
- * @see {@link mapInput} - Use this order to compare objects by a bigint property
+ * @see {@link Number} for regular number comparisons
+ * @see {@link mapInput} to compare objects by a bigint property
  * @category instances
  * @since 4.0.0
  */
@@ -229,7 +258,7 @@ export const BigInt = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * - When you need descending order instead of ascending
+ * Use when when you need descending order instead of ascending
  * - When reversing an existing order without modifying the original
  * - When creating orders that compare in the opposite direction
  *
@@ -252,7 +281,7 @@ export const BigInt = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  * console.log(flip(1, 1)) // 0
  * ```
  *
- * @see {@link combine} - Combine orders for multi-criteria comparison
+ * @see {@link combine} to combine orders for multi-criteria comparison
  * @category combinators
  * @since 4.0.0
  */
@@ -265,7 +294,7 @@ export function flip(O) {
  *
  * **When to use**
  *
- * - When you need multi-criteria comparison (e.g., sort by age, then by name)
+ * Use when when you need multi-criteria comparison (e.g., sort by age, then by name)
  * - When creating composite orders from simpler orders
  * - When implementing lexicographic ordering
  *
@@ -299,8 +328,8 @@ export function flip(O) {
  * console.log(byAgeAndName(person1, person3)) // 1 (Alice (30) > Charlie (25))
  * ```
  *
- * @see {@link combineAll} - Combine multiple orders from a collection
- * @see {@link mapInput} - Transform orders to work with different types
+ * @see {@link combineAll} to combine multiple orders from a collection
+ * @see {@link mapInput} to transform orders to work with different types
  * @category combining
  * @since 2.0.0
  */
@@ -316,7 +345,7 @@ export const combine = /*#__PURE__*/dual(2, (self, that) => make((a1, a2) => {
  *
  * **When to use**
  *
- * - When you need an order that doesn't distinguish between values
+ * Use when when you need an order that doesn't distinguish between values
  * - As a default or fallback order when no meaningful comparison exists
  * - When implementing optional ordering where equality is sufficient
  *
@@ -338,7 +367,7 @@ export const combine = /*#__PURE__*/dual(2, (self, that) => make((a1, a2) => {
  * console.log(alwaysEqualOrder(1, 1)) // 0
  * ```
  *
- * @see {@link combine} - Combine with other orders
+ * @see {@link combine} to combine with other orders
  * @category constructors
  * @since 4.0.0
  */
@@ -351,7 +380,7 @@ export function alwaysEqual() {
  *
  * **When to use**
  *
- * - When you have a variable number of orders to combine
+ * Use when when you have a variable number of orders to combine
  * - When combining orders from a collection or array
  * - When implementing dynamic multi-criteria sorting
  *
@@ -385,8 +414,8 @@ export function alwaysEqual() {
  * console.log(combinedOrder(person1, person2)) // -1 (Same age, Alice < Bob)
  * ```
  *
- * @see {@link combine} - Combine two orders
- * @see {@link makeReducer} - Create a reducer for combining orders
+ * @see {@link combine} to combine two orders
+ * @see {@link makeReducer} to create a reducer for combining orders
  * @category combining
  * @since 2.0.0
  */
@@ -408,7 +437,7 @@ export function combineAll(collection) {
  *
  * **When to use**
  *
- * - When you have an order for a property type and want to compare objects by that property
+ * Use when when you have an order for a property type and want to compare objects by that property
  * - When extracting a comparable value from a complex type
  * - When creating orders for types that contain comparable values
  *
@@ -431,8 +460,8 @@ export function combineAll(collection) {
  * console.log(byLength("aa", "bb")) // 0
  * ```
  *
- * @see {@link combine} - Combine mapped orders for multi-criteria comparison
- * @see {@link Struct} - Create orders for structs with multiple fields
+ * @see {@link combine} to combine mapped orders for multi-criteria comparison
+ * @see {@link Struct} to create orders for structs with multiple fields
  * @category mapping
  * @since 2.0.0
  */
@@ -442,7 +471,7 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((b1, b2) => self(
  *
  * **When to use**
  *
- * - When comparing dates for sorting or searching
+ * Use when when comparing dates for sorting or searching
  * - As a base for creating orders on types containing dates
  * - When implementing time-based comparisons
  *
@@ -466,7 +495,7 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((b1, b2) => self(
  * console.log(Order.Date(date1, date1)) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a date property
+ * @see {@link mapInput} to compare objects by a date property
  * @category instances
  * @since 2.0.0
  */
@@ -476,7 +505,7 @@ export const Date = /*#__PURE__*/mapInput(Number, date => date.getTime());
  *
  * **When to use**
  *
- * - When comparing tuples with different types for each position
+ * Use when when comparing tuples with different types for each position
  * - When you need type-safe tuple ordering
  * - When working with fixed-length heterogeneous collections
  *
@@ -500,7 +529,7 @@ export const Date = /*#__PURE__*/mapInput(Number, date => date.getTime());
  * console.log(tupleOrder([1, "a"], [1, "a"])) // 0
  * ```
  *
- * @see {@link Array} - Compare arrays with length consideration
+ * @see {@link Array} to compare arrays with length consideration
  * @category combinators
  * @since 4.0.0
  */
@@ -539,7 +568,7 @@ export {
  *
  * **When to use**
  *
- * - When comparing arrays of the same element type
+ * Use when when comparing arrays of the same element type
  * - When you want shorter arrays to be considered less than longer arrays
  * - When sorting collections of arrays
  *
@@ -564,7 +593,7 @@ export {
  * console.log(arrayOrder([1, 2], [1, 2])) // 0
  * ```
  *
- * @see {@link Tuple} - Type-safe tuple ordering
+ * @see {@link Tuple} for type-safe tuple ordering
  * @category combinators
  * @since 4.0.0
  */
@@ -574,7 +603,7 @@ Array_ as Array };
  *
  * **When to use**
  *
- * - When comparing objects with multiple properties
+ * Use when when comparing objects with multiple properties
  * - When you need multi-field comparison for structs
  * - When creating orders for complex data types
  *
@@ -605,8 +634,8 @@ Array_ as Array };
  * console.log(personOrder(person1, person1)) // 0
  * ```
  *
- * @see {@link combine} - Combine orders manually
- * @see {@link mapInput} - Extract and compare by a single property
+ * @see {@link combine} to combine orders manually
+ * @see {@link mapInput} to extract and compare by a single property
  * @category combinators
  * @since 4.0.0
  */
@@ -627,7 +656,7 @@ export function Struct(fields) {
  *
  * **When to use**
  *
- * - When you need a boolean predicate instead of an ordering result
+ * Use when when you need a boolean predicate instead of an ordering result
  * - When checking if a value is less than another in conditional logic
  * - When implementing range checks or comparisons
  *
@@ -650,8 +679,8 @@ export function Struct(fields) {
  * console.log(isLessThanNumber(1, 1)) // false
  * ```
  *
- * @see {@link isLessThanOrEqualTo} - Non-strict less than or equal
- * @see {@link isGreaterThan} - Strict greater than
+ * @see {@link isLessThanOrEqualTo} for non-strict less than or equal
+ * @see {@link isGreaterThan} for strict greater than
  * @category predicates
  * @since 4.0.0
  */
@@ -661,7 +690,7 @@ export const isLessThan = O => dual(2, (self, that) => O(self, that) === -1);
  *
  * **When to use**
  *
- * - When you need a boolean predicate instead of an ordering result
+ * Use when when you need a boolean predicate instead of an ordering result
  * - When checking if a value is greater than another in conditional logic
  * - When implementing range checks or comparisons
  *
@@ -684,8 +713,8 @@ export const isLessThan = O => dual(2, (self, that) => O(self, that) === -1);
  * console.log(isGreaterThanNumber(1, 1)) // false
  * ```
  *
- * @see {@link isGreaterThanOrEqualTo} - Non-strict greater than or equal
- * @see {@link isLessThan} - Strict less than
+ * @see {@link isGreaterThanOrEqualTo} for non-strict greater than or equal
+ * @see {@link isLessThan} for strict less than
  * @category predicates
  * @since 4.0.0
  */
@@ -695,7 +724,7 @@ export const isGreaterThan = O => dual(2, (self, that) => O(self, that) === 1);
  *
  * **When to use**
  *
- * - When you need a boolean predicate for non-strict comparison
+ * Use when when you need a boolean predicate for non-strict comparison
  * - When checking if a value is within a range (inclusive lower bound)
  * - When implementing inclusive comparisons
  *
@@ -718,8 +747,8 @@ export const isGreaterThan = O => dual(2, (self, that) => O(self, that) === 1);
  * console.log(isLessThanOrEqualToNumber(2, 1)) // false
  * ```
  *
- * @see {@link isLessThan} - Strict less than
- * @see {@link isGreaterThan} - Strict greater than
+ * @see {@link isLessThan} for strict less than
+ * @see {@link isGreaterThan} for strict greater than
  * @category predicates
  * @since 4.0.0
  */
@@ -729,7 +758,7 @@ export const isLessThanOrEqualTo = O => dual(2, (self, that) => O(self, that) !=
  *
  * **When to use**
  *
- * - When you need a boolean predicate for non-strict comparison
+ * Use when when you need a boolean predicate for non-strict comparison
  * - When checking if a value is within a range (inclusive upper bound)
  * - When implementing inclusive comparisons
  *
@@ -752,8 +781,8 @@ export const isLessThanOrEqualTo = O => dual(2, (self, that) => O(self, that) !=
  * console.log(isGreaterThanOrEqualToNumber(1, 2)) // false
  * ```
  *
- * @see {@link isGreaterThan} - Strict greater than
- * @see {@link isLessThanOrEqualTo} - Less than or equal
+ * @see {@link isGreaterThan} for strict greater than
+ * @see {@link isLessThanOrEqualTo} for less than or equal
  * @category predicates
  * @since 4.0.0
  */
@@ -763,7 +792,7 @@ export const isGreaterThanOrEqualTo = O => dual(2, (self, that) => O(self, that)
  *
  * **When to use**
  *
- * - When you need to find the smaller of two values
+ * Use when when you need to find the smaller of two values
  * - When implementing min/max operations
  * - When selecting values based on ordering
  *
@@ -786,8 +815,8 @@ export const isGreaterThanOrEqualTo = O => dual(2, (self, that) => O(self, that)
  * console.log(minNumber(1, 1)) // 1
  * ```
  *
- * @see {@link max} - Maximum of two values
- * @see {@link clamp} - Clamp a value between min and max
+ * @see {@link max} for the maximum of two values
+ * @see {@link clamp} to clamp a value between min and max
  * @category comparisons
  * @since 2.0.0
  */
@@ -797,7 +826,7 @@ export const min = O => dual(2, (self, that) => self === that || O(self, that) <
  *
  * **When to use**
  *
- * - When you need to find the larger of two values
+ * Use when when you need to find the larger of two values
  * - When implementing min/max operations
  * - When selecting values based on ordering
  *
@@ -820,8 +849,8 @@ export const min = O => dual(2, (self, that) => self === that || O(self, that) <
  * console.log(maxNumber(1, 1)) // 1
  * ```
  *
- * @see {@link min} - Minimum of two values
- * @see {@link clamp} - Clamp a value between min and max
+ * @see {@link min} for the minimum of two values
+ * @see {@link clamp} to clamp a value between min and max
  * @category comparisons
  * @since 2.0.0
  */
@@ -831,7 +860,7 @@ export const max = O => dual(2, (self, that) => self === that || O(self, that) >
  *
  * **When to use**
  *
- * - When you need to restrict a value to a specific range
+ * Use when when you need to restrict a value to a specific range
  * - When implementing bounds checking and normalization
  * - When ensuring values stay within valid ranges
  *
@@ -856,9 +885,9 @@ export const max = O => dual(2, (self, that) => self === that || O(self, that) >
  * console.log(clamp(6)) // 5
  * ```
  *
- * @see {@link min} - Minimum of two values
- * @see {@link max} - Maximum of two values
- * @see {@link isBetween} - Check if a value is within a range
+ * @see {@link min} for the minimum of two values
+ * @see {@link max} for the maximum of two values
+ * @see {@link isBetween} to check if a value is within a range
  * @category comparisons
  * @since 2.0.0
  */
@@ -868,7 +897,7 @@ export const clamp = O => dual(2, (self, options) => min(O)(options.maximum, max
  *
  * **When to use**
  *
- * - When validating that a value is within a valid range
+ * Use when when validating that a value is within a valid range
  * - When implementing range checks for bounds validation
  * - When filtering or selecting values within a range
  *
@@ -894,9 +923,9 @@ export const clamp = O => dual(2, (self, options) => min(O)(options.maximum, max
  * console.log(betweenNumber(11, { minimum: 1, maximum: 10 })) // false
  * ```
  *
- * @see {@link clamp} - Clamp a value to a range
- * @see {@link isLessThanOrEqualTo} - Less than or equal check
- * @see {@link isGreaterThanOrEqualTo} - Greater than or equal check
+ * @see {@link clamp} to clamp a value to a range
+ * @see {@link isLessThanOrEqualTo} for less than or equal check
+ * @see {@link isGreaterThanOrEqualTo} for greater than or equal check
  * @category predicates
  * @since 4.0.0
  */
@@ -906,7 +935,7 @@ export const isBetween = O => dual(2, (self, options) => !isLessThan(O)(self, op
  *
  * **When to use**
  *
- * - When you need to combine multiple orders from a collection using reducer patterns
+ * Use when when you need to combine multiple orders from a collection using reducer patterns
  * - When implementing fold operations over collections of orders
  * - When working with reducers that operate on orders
  *
@@ -929,9 +958,9 @@ export const isBetween = O => dual(2, (self, options) => !isLessThan(O)(self, op
  * console.log(combined(1, 2)) // -1 (uses first order)
  * ```
  *
- * @see {@link combine} - Combine two orders
- * @see {@link combineAll} - Combine multiple orders
- * @see {@link Reducer} - Reducer type for collection operations
+ * @see {@link combine} to combine two orders
+ * @see {@link combineAll} to combine multiple orders
+ * @see {@link Reducer} for reducing orders as a collection operation
  * @category utils
  * @since 4.0.0
  */

package/dist/Order.js.map

@@ -1 +1 @@
-{"version":3,"file":"Order.js","names":["dual","Reducer","make","compare","self","that","String","Number","globalThis","isNaN","Boolean","BigInt","flip","O","combine","a1","a2","out","alwaysEqual","combineAll","collection","mapInput","f","b1","b2","Date","date","getTime","Tuple","elements","len","length","i","o","Array_","aLen","bLen","Math","min","Array","Struct","fields","keys","Object","key","isLessThan","isGreaterThan","isLessThanOrEqualTo","isGreaterThanOrEqualTo","max","clamp","options","maximum","minimum","isBetween","makeReducer"],"sources":["../src/Order.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Order.js","names":["dual","Reducer","make","compare","self","that","String","Number","globalThis","isNaN","Boolean","BigInt","flip","O","combine","a1","a2","out","alwaysEqual","combineAll","collection","mapInput","f","b1","b2","Date","date","getTime","Tuple","elements","len","length","i","o","Array_","aLen","bLen","Math","min","Array","Struct","fields","keys","Object","key","isLessThan","isGreaterThan","isLessThanOrEqualTo","isGreaterThanOrEqualTo","max","clamp","options","maximum","minimum","isBetween","makeReducer"],"sources":["../src/Order.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}