effect 4.0.0-beta.69 → 4.0.0-beta.70

package/dist/Combiner.d.ts

@@ -62,17 +62,17 @@
  */
 import type * as Order from "./Order.ts";
 /**
- * Represents a strategy for combining two values of the same type `A`.
- *
- * A `Combiner` contains a single `combine` method that takes two values and
+ * Represents a strategy for combining two values of the same type `A`. A
+ * `Combiner` contains a single `combine` method that takes two values and
  * returns a merged result. It does not include an identity/empty value; use
  * `Reducer` when you need one.
  *
- * When to use:
- * - You need to describe how two values of the same type merge.
- * - You want to pass a reusable combining strategy to library functions like
- *   `Struct.makeCombiner` or `Option.makeCombinerFailFast`.
- * - You are building a `Reducer` and need to define the combining step first.
+ * **When to use**
+ *
+ * Use `Combiner` when you need to describe how two values of the same type
+ * merge, pass a reusable combining strategy to library functions like
+ * `Struct.makeCombiner` or `Option.makeCombinerFailFast`, or define the
+ * combining step for a `Reducer`.
  *
  * **Example** (number addition combiner)
  *
@@ -86,7 +86,6 @@ import type * as Order from "./Order.ts";
  * ```
  *
  * @see {@link make} – create a `Combiner` from a function
- *
  * @category models
  * @since 4.0.0
  */
@@ -99,9 +98,12 @@ export interface Combiner<A> {
 /**
  * Creates a `Combiner` from a binary function.
  *
- * When to use:
- * - You have a custom combining operation that is not covered by the built-in
- *   constructors (`min`, `max`, `first`, `last`, `constant`).
+ * **When to use**
+ *
+ * Use this when you have a custom combining operation that is not covered by
+ * the built-in constructors (`min`, `max`, `first`, `last`, `constant`).
+ *
+ * **Details**
  *
  * The returned combiner's `combine` method delegates to the provided function.
  * Any purity, associativity, or mutation behavior comes from that function.
@@ -118,7 +120,6 @@ export interface Combiner<A> {
  * ```
  *
  * @see {@link Combiner} – the interface this creates
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -126,15 +127,16 @@ export declare function make<A>(combine: (self: A, that: A) => A): Combiner<A>;
 /**
  * Reverses the argument order of a combiner's `combine` method.
  *
- * When to use:
- * - You need the "right" value to act as the accumulator side.
- * - You want to reverse the natural direction of a non-commutative combiner
- *   (e.g. string concatenation).
+ * **When to use**
+ *
+ * Use this when the "right" value should act as the accumulator side, or when
+ * you want to reverse the natural direction of a non-commutative combiner such
+ * as string concatenation.
  *
- * Behavior:
- * - Returns a new `Combiner` where `combine(self, that)` calls the original
- *   combiner as `combine(that, self)`.
- * - Does not mutate the input combiner.
+ * **Details**
+ *
+ * Returns a new `Combiner` where `combine(self, that)` calls the original
+ * combiner as `combine(that, self)`. The input combiner is not mutated.
  *
  * **Example** (reversing string concatenation)
  *
@@ -148,7 +150,6 @@ export declare function make<A>(combine: (self: A, that: A) => A): Combiner<A>;
  * ```
  *
  * @see {@link make}
- *
  * @category combinators
  * @since 4.0.0
  */
@@ -157,14 +158,15 @@ export declare function flip<A>(combiner: Combiner<A>): Combiner<A>;
  * Creates a `Combiner` that returns the smaller of two values according to
  * the provided `Order`.
  *
- * When to use:
- * - You want to accumulate the minimum value across a collection.
- * - You are building a `Reducer` that tracks the running minimum.
+ * **When to use**
+ *
+ * Use this when you want to accumulate the minimum value across a collection or
+ * build a `Reducer` that tracks the running minimum.
+ *
+ * **Details**
  *
- * Behavior:
- * - Compares using the given `Order`. When values are equal, returns `that`
- *   (the second argument).
- * - Pure – does not mutate either argument.
+ * The combiner compares values using the given `Order`. When values are equal,
+ * it returns `that` (the second argument). It does not mutate either argument.
  *
  * **Example** (minimum of two numbers)
  *
@@ -181,7 +183,6 @@ export declare function flip<A>(combiner: Combiner<A>): Combiner<A>;
  * ```
  *
  * @see {@link max}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -190,14 +191,15 @@ export declare function min<A>(order: Order.Order<A>): Combiner<A>;
  * Creates a `Combiner` that returns the larger of two values according to
  * the provided `Order`.
  *
- * When to use:
- * - You want to accumulate the maximum value across a collection.
- * - You are building a `Reducer` that tracks the running maximum.
+ * **When to use**
+ *
+ * Use this when you want to accumulate the maximum value across a collection or
+ * build a `Reducer` that tracks the running maximum.
+ *
+ * **Details**
  *
- * Behavior:
- * - Compares using the given `Order`. When values are equal, returns `that`
- *   (the second argument).
- * - Pure – does not mutate either argument.
+ * The combiner compares values using the given `Order`. When values are equal,
+ * it returns `that` (the second argument). It does not mutate either argument.
  *
  * **Example** (maximum of two numbers)
  *
@@ -214,7 +216,6 @@ export declare function min<A>(order: Order.Order<A>): Combiner<A>;
  * ```
  *
  * @see {@link min}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -222,14 +223,15 @@ export declare function max<A>(order: Order.Order<A>): Combiner<A>;
 /**
  * Creates a `Combiner` that always returns the first (left) argument.
  *
- * When to use:
- * - You want "first write wins" semantics when merging values.
- * - You need a combiner but the combining logic should be a no-op that keeps
- *   the existing value.
+ * **When to use**
+ *
+ * Use this when you want "first write wins" semantics while merging values, or
+ * when the combining logic should keep the existing value.
  *
- * Behavior:
- * - `combine(self, that)` returns `self`, ignoring `that`.
- * - Pure – the second argument is discarded, not mutated.
+ * **Details**
+ *
+ * `combine(self, that)` returns `self` and ignores `that`. The second argument
+ * is discarded, not mutated.
  *
  * **Example** (keeping the first value)
  *
@@ -243,7 +245,6 @@ export declare function max<A>(order: Order.Order<A>): Combiner<A>;
  * ```
  *
  * @see {@link last}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -251,13 +252,15 @@ export declare function first<A>(): Combiner<A>;
 /**
  * Creates a `Combiner` that always returns the last (right) argument.
  *
- * When to use:
- * - You want "last write wins" semantics when merging values.
- * - You need a combiner that replaces the accumulator with each new value.
+ * **When to use**
  *
- * Behavior:
- * - `combine(self, that)` returns `that`, ignoring `self`.
- * - Pure – the first argument is discarded, not mutated.
+ * Use this when you want "last write wins" semantics while merging values, or
+ * when each new value should replace the accumulator.
+ *
+ * **Details**
+ *
+ * `combine(self, that)` returns `that` and ignores `self`. The first argument
+ * is discarded, not mutated.
  *
  * **Example** (keeping the last value)
  *
@@ -271,7 +274,6 @@ export declare function first<A>(): Combiner<A>;
  * ```
  *
  * @see {@link first}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -280,14 +282,16 @@ export declare function last<A>(): Combiner<A>;
  * Creates a `Combiner` that ignores both arguments and always returns the
  * given constant value.
  *
- * When to use:
- * - You need a combiner that produces a fixed result regardless of input.
- * - You are providing a combiner to a generic API but the combined value is
- *   predetermined.
+ * **When to use**
  *
- * Behavior:
- * - `combine(self, that)` returns the constant `a`, ignoring both arguments.
- * - Pure – no mutation occurs.
+ * Use this when a combiner should produce a fixed result regardless of input,
+ * or when a generic API needs a combiner but the combined value is
+ * predetermined.
+ *
+ * **Details**
+ *
+ * `combine(self, that)` returns the constant `a` and ignores both arguments.
+ * No mutation occurs.
  *
  * **Example** (always returning zero)
  *
@@ -302,7 +306,6 @@ export declare function last<A>(): Combiner<A>;
  *
  * @see {@link first}
  * @see {@link last}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -311,16 +314,18 @@ export declare function constant<A>(a: A): Combiner<A>;
  * Wraps a `Combiner` so that a separator value is inserted between every
  * pair of combined elements.
  *
- * When to use:
- * - You are building delimited strings (CSV, paths, etc.) by repeated
- *   combination.
- * - You need to inject a fixed separator between accumulated values.
+ * **When to use**
  *
- * Behavior:
- * - `intercalate(middle)(combiner).combine(self, that)` is equivalent to
- *   `combiner.combine(self, combiner.combine(middle, that))`.
- * - Curried: first provide the separator, then the base combiner.
- * - Does not mutate the input combiner; returns a new one.
+ * Use this when you are building delimited strings (CSV, paths, etc.) by
+ * repeated combination, or when you need to inject a fixed separator between
+ * accumulated values.
+ *
+ * **Details**
+ *
+ * `intercalate(middle)(combiner).combine(self, that)` is equivalent to
+ * `combiner.combine(self, combiner.combine(middle, that))`. This function is
+ * curried: first provide the separator, then the base combiner. It returns a
+ * new combiner and does not mutate the input combiner.
  *
  * **Example** (joining strings with a separator)
  *
@@ -334,7 +339,6 @@ export declare function constant<A>(a: A): Combiner<A>;
  * ```
  *
  * @see {@link make}
- *
  * @category combinators
  * @since 4.0.0
  */

package/dist/Combiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Combiner.d.ts","sourceRoot":"","sources":["../src/Combiner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAEtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,IAC9B,UAAU,QAAQ,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAC,CAE5C"}
+{"version":3,"file":"Combiner.d.ts","sourceRoot":"","sources":["../src/Combiner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAEtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,IAC9B,UAAU,QAAQ,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAC,CAE5C"}

package/dist/Combiner.js

@@ -1,9 +1,12 @@
 /**
  * Creates a `Combiner` from a binary function.
  *
- * When to use:
- * - You have a custom combining operation that is not covered by the built-in
- *   constructors (`min`, `max`, `first`, `last`, `constant`).
+ * **When to use**
+ *
+ * Use this when you have a custom combining operation that is not covered by
+ * the built-in constructors (`min`, `max`, `first`, `last`, `constant`).
+ *
+ * **Details**
  *
  * The returned combiner's `combine` method delegates to the provided function.
  * Any purity, associativity, or mutation behavior comes from that function.
@@ -20,7 +23,6 @@
  * ```
  *
  * @see {@link Combiner} – the interface this creates
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -32,15 +34,16 @@ export function make(combine) {
 /**
  * Reverses the argument order of a combiner's `combine` method.
  *
- * When to use:
- * - You need the "right" value to act as the accumulator side.
- * - You want to reverse the natural direction of a non-commutative combiner
- *   (e.g. string concatenation).
+ * **When to use**
  *
- * Behavior:
- * - Returns a new `Combiner` where `combine(self, that)` calls the original
- *   combiner as `combine(that, self)`.
- * - Does not mutate the input combiner.
+ * Use this when the "right" value should act as the accumulator side, or when
+ * you want to reverse the natural direction of a non-commutative combiner such
+ * as string concatenation.
+ *
+ * **Details**
+ *
+ * Returns a new `Combiner` where `combine(self, that)` calls the original
+ * combiner as `combine(that, self)`. The input combiner is not mutated.
  *
  * **Example** (reversing string concatenation)
  *
@@ -54,7 +57,6 @@ export function make(combine) {
  * ```
  *
  * @see {@link make}
- *
  * @category combinators
  * @since 4.0.0
  */
@@ -65,14 +67,15 @@ export function flip(combiner) {
  * Creates a `Combiner` that returns the smaller of two values according to
  * the provided `Order`.
  *
- * When to use:
- * - You want to accumulate the minimum value across a collection.
- * - You are building a `Reducer` that tracks the running minimum.
+ * **When to use**
  *
- * Behavior:
- * - Compares using the given `Order`. When values are equal, returns `that`
- *   (the second argument).
- * - Pure – does not mutate either argument.
+ * Use this when you want to accumulate the minimum value across a collection or
+ * build a `Reducer` that tracks the running minimum.
+ *
+ * **Details**
+ *
+ * The combiner compares values using the given `Order`. When values are equal,
+ * it returns `that` (the second argument). It does not mutate either argument.
  *
  * **Example** (minimum of two numbers)
  *
@@ -89,7 +92,6 @@ export function flip(combiner) {
  * ```
  *
  * @see {@link max}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -100,14 +102,15 @@ export function min(order) {
  * Creates a `Combiner` that returns the larger of two values according to
  * the provided `Order`.
  *
- * When to use:
- * - You want to accumulate the maximum value across a collection.
- * - You are building a `Reducer` that tracks the running maximum.
+ * **When to use**
  *
- * Behavior:
- * - Compares using the given `Order`. When values are equal, returns `that`
- *   (the second argument).
- * - Pure – does not mutate either argument.
+ * Use this when you want to accumulate the maximum value across a collection or
+ * build a `Reducer` that tracks the running maximum.
+ *
+ * **Details**
+ *
+ * The combiner compares values using the given `Order`. When values are equal,
+ * it returns `that` (the second argument). It does not mutate either argument.
  *
  * **Example** (maximum of two numbers)
  *
@@ -124,7 +127,6 @@ export function min(order) {
  * ```
  *
  * @see {@link min}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -134,14 +136,15 @@ export function max(order) {
 /**
  * Creates a `Combiner` that always returns the first (left) argument.
  *
- * When to use:
- * - You want "first write wins" semantics when merging values.
- * - You need a combiner but the combining logic should be a no-op that keeps
- *   the existing value.
+ * **When to use**
  *
- * Behavior:
- * - `combine(self, that)` returns `self`, ignoring `that`.
- * - Pure – the second argument is discarded, not mutated.
+ * Use this when you want "first write wins" semantics while merging values, or
+ * when the combining logic should keep the existing value.
+ *
+ * **Details**
+ *
+ * `combine(self, that)` returns `self` and ignores `that`. The second argument
+ * is discarded, not mutated.
  *
  * **Example** (keeping the first value)
  *
@@ -155,7 +158,6 @@ export function max(order) {
  * ```
  *
  * @see {@link last}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -165,13 +167,15 @@ export function first() {
 /**
  * Creates a `Combiner` that always returns the last (right) argument.
  *
- * When to use:
- * - You want "last write wins" semantics when merging values.
- * - You need a combiner that replaces the accumulator with each new value.
+ * **When to use**
  *
- * Behavior:
- * - `combine(self, that)` returns `that`, ignoring `self`.
- * - Pure – the first argument is discarded, not mutated.
+ * Use this when you want "last write wins" semantics while merging values, or
+ * when each new value should replace the accumulator.
+ *
+ * **Details**
+ *
+ * `combine(self, that)` returns `that` and ignores `self`. The first argument
+ * is discarded, not mutated.
  *
  * **Example** (keeping the last value)
  *
@@ -185,7 +189,6 @@ export function first() {
  * ```
  *
  * @see {@link first}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -196,14 +199,16 @@ export function last() {
  * Creates a `Combiner` that ignores both arguments and always returns the
  * given constant value.
  *
- * When to use:
- * - You need a combiner that produces a fixed result regardless of input.
- * - You are providing a combiner to a generic API but the combined value is
- *   predetermined.
+ * **When to use**
  *
- * Behavior:
- * - `combine(self, that)` returns the constant `a`, ignoring both arguments.
- * - Pure – no mutation occurs.
+ * Use this when a combiner should produce a fixed result regardless of input,
+ * or when a generic API needs a combiner but the combined value is
+ * predetermined.
+ *
+ * **Details**
+ *
+ * `combine(self, that)` returns the constant `a` and ignores both arguments.
+ * No mutation occurs.
  *
  * **Example** (always returning zero)
  *
@@ -218,7 +223,6 @@ export function last() {
  *
  * @see {@link first}
  * @see {@link last}
- *
  * @category constructors
  * @since 4.0.0
  */
@@ -229,16 +233,18 @@ export function constant(a) {
  * Wraps a `Combiner` so that a separator value is inserted between every
  * pair of combined elements.
  *
- * When to use:
- * - You are building delimited strings (CSV, paths, etc.) by repeated
- *   combination.
- * - You need to inject a fixed separator between accumulated values.
+ * **When to use**
  *
- * Behavior:
- * - `intercalate(middle)(combiner).combine(self, that)` is equivalent to
- *   `combiner.combine(self, combiner.combine(middle, that))`.
- * - Curried: first provide the separator, then the base combiner.
- * - Does not mutate the input combiner; returns a new one.
+ * Use this when you are building delimited strings (CSV, paths, etc.) by
+ * repeated combination, or when you need to inject a fixed separator between
+ * accumulated values.
+ *
+ * **Details**
+ *
+ * `intercalate(middle)(combiner).combine(self, that)` is equivalent to
+ * `combiner.combine(self, combiner.combine(middle, that))`. This function is
+ * curried: first provide the separator, then the base combiner. It returns a
+ * new combiner and does not mutate the input combiner.
  *
  * **Example** (joining strings with a separator)
  *
@@ -252,7 +258,6 @@ export function constant(a) {
  * ```
  *
  * @see {@link make}
- *
  * @category combinators
  * @since 4.0.0
  */

package/dist/Combiner.js.map

@@ -1 +1 @@
-{"version":3,"file":"Combiner.js","names":["make","combine","flip","combiner","self","that","min","order","max","first","_","last","constant","a","intercalate","middle"],"sources":["../src/Combiner.ts"],"sourcesContent":[null],"mappings":"AAoGA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAM,SAAUC,IAAIA,CAAIC,QAAqB;EAC3C,OAAOH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACI,IAAI,EAAED,IAAI,CAAC,CAAC;AAC3D;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUE,GAAGA,CAAIC,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACrE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUG,GAAGA,CAAID,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACpE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUI,KAAKA,CAAA;EACnB,OAAOT,IAAI,CAAC,CAACI,IAAI,EAAEM,CAAC,KAAKN,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,SAAUC,WAAWA,CAAIC,MAAS;EACtC,OAAQZ,QAAqB,IAC3BH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACG,IAAI,EAAED,QAAQ,CAACF,OAAO,CAACc,MAAM,EAAEV,IAAI,CAAC,CAAC,CAAC;AAChF","ignoreList":[]}
+{"version":3,"file":"Combiner.js","names":["make","combine","flip","combiner","self","that","min","order","max","first","_","last","constant","a","intercalate","middle"],"sources":["../src/Combiner.ts"],"sourcesContent":[null],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAM,SAAUC,IAAIA,CAAIC,QAAqB;EAC3C,OAAOH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACI,IAAI,EAAED,IAAI,CAAC,CAAC;AAC3D;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUE,GAAGA,CAAIC,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACrE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUG,GAAGA,CAAID,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACpE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUI,KAAKA,CAAA;EACnB,OAAOT,IAAI,CAAC,CAACI,IAAI,EAAEM,CAAC,KAAKN,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUC,WAAWA,CAAIC,MAAS;EACtC,OAAQZ,QAAqB,IAC3BH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACG,IAAI,EAAED,QAAQ,CAACF,OAAO,CAACc,MAAM,EAAEV,IAAI,CAAC,CAAC,CAAC;AAChF","ignoreList":[]}