arrow-resilience-kit 0.9.3 → 0.10.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sorin Albu-Irimies
+
+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

@@ -0,0 +1,240 @@
+# arrow-resilience-kit
+
+Resilience patterns for JavaScript and TypeScript: **retry with backoff** (honoring `Retry-After`), **circuit breakers**, **bulkheads**, **rate limiters**, **time limits**, **hedged requests**, **failover**, **retry budgets**, **adaptive concurrency** and a **TTL/LRU cache**.
+
+It is the JS build of the Kotlin Multiplatform library [arrow-resilience-kit](https://github.com/sorinirimies/arrow-resilience-kit), built on [Arrow](https://arrow-kt.io): the same, well-tested implementation that runs on the JVM, Android, iOS and native, exposed through a Promise-based API with generated TypeScript types.
+
+- **Promise-based**: every operation takes an `async` function and returns a `Promise`.
+- **Typed**: ships its own `.d.ts`; no `@types` package needed.
+- **ES modules and CommonJS**: `import` and `require()` both work, with named exports.
+- **No runtime dependencies**.
+- **Cancellable**: operations that wait take an `AbortSignal`, like `fetch`.
+- **Your errors, unchanged**: a rejection carries the exact error your function threw.
+- **Silent**: logs nothing unless you ask it to.
+
+```bash
+npm install arrow-resilience-kit
+```
+
+## Quick start
+
+```ts
+import { CircuitBreaker, Retry } from "arrow-resilience-kit";
+
+// Retry transient failures, waiting what the server asks for on 429.
+const user = await Retry.withBackoff(() => fetchJson("https://api.example.com/user"), {
+    retries: 3,
+    shouldRetry: (e) => e.status === 429 || e.status >= 500,
+    delayMillis: (e) => e.retryAfterMillis, // undefined = exponential backoff
+});
+
+// Stop calling a service that keeps failing; try again after 30 s.
+const breaker = await CircuitBreaker.create(5, 30_000);
+const orders = await breaker.execute(() => fetchJson("https://orders.example.com/latest"));
+```
+
+Every `create(...)` is `async` and takes positional arguments, all optional (see the signatures below). Durations are plain milliseconds.
+
+## Patterns
+
+### Retry
+
+`Retry.withBackoff(block, options?)` is the general-purpose retry for network calls:
+
+```ts
+import { Retry } from "arrow-resilience-kit";
+
+const controller = new AbortController();
+const data = await Retry.withBackoff(() => fetchJson(url), {
+    retries: 5,                 // retries after the first attempt (default 3)
+    baseMillis: 200,            // first backoff (default 100), multiplied by `factor` (default 2)
+    maxDelayMillis: 10_000,     // cap for the computed backoff
+    jitter: 0.1,                // ±10 % randomization of the computed backoff
+    shouldRetry: (e, retry) => e.status === 429 || e.status >= 500,
+    delayMillis: (e, retry) => e.retryAfterMillis, // exact wait for this error, no jitter or cap
+    onRetry: (e, retry, delayMillis) => console.debug(`retry ${retry} in ${delayMillis} ms`),
+    signal: controller.signal,  // abort to stop waiting and reject with signal.reason
+});
+```
+
+Simpler variants: `Retry.withExponentialBackoff(block, retries?, baseMillis?, factor?, signal?)`, `Retry.withConstantDelay(block, retries?, delayMillis?, signal?)`, `Retry.orDefault(block, fallback, retries?, baseMillis?, factor?)` and `Retry.ifMatches(block, shouldRetry, retries?, delayMillis?)`.
+
+### Circuit breaker
+
+Fails fast while a dependency is down instead of piling up slow, failing calls.
+
+```ts
+import { CircuitBreaker, SlidingWindowCircuitBreaker } from "arrow-resilience-kit";
+
+// Opens after 5 consecutive failures; after 30 s lets 1 trial call through.
+const breaker = await CircuitBreaker.create(5, 30_000, 1, 1);
+breaker.onStateChange((from, to) => console.info(`circuit ${from} -> ${to}`));
+
+const result = await breaker.executeOrFallback(
+    async () => cachedValue,      // used while the circuit is open
+    () => fetchJson(url),
+);
+
+// Opens when 50 % of the last 20 calls failed (once at least 10 were made).
+const windowed = await SlidingWindowCircuitBreaker.create(20, 10, 0.5, 30_000);
+await windowed.execute(() => fetchJson(url));
+```
+
+### Bulkhead
+
+Limits how many calls run at once, so one slow dependency can't take every connection.
+
+```ts
+import { Bulkhead } from "arrow-resilience-kit";
+
+// 10 concurrent calls, 50 waiting, wait at most 2 s for a slot.
+const bulkhead = await Bulkhead.create(10, 50, 2_000);
+const report = await bulkhead.execute(() => fetchJson(url));
+```
+
+### Rate limiter
+
+```ts
+import { RateLimiter, SlidingWindowRateLimiter } from "arrow-resilience-kit";
+
+// Token bucket: 5 calls per second, bursts of up to 10.
+const limiter = await RateLimiter.create(5, 10);
+await limiter.execute(() => fetchJson(url)); // waits for a token
+
+// At most 100 calls in any 60 s window.
+const window = await SlidingWindowRateLimiter.create(100, 60_000);
+const maybe = await window.tryExecute(() => fetchJson(url)); // null when over the limit
+```
+
+### Time limiter
+
+```ts
+import { TimeLimiter } from "arrow-resilience-kit";
+
+const limiter = await TimeLimiter.create(5_000);               // default timeout
+const fast = await limiter.execute(1_000, () => fetchJson(url)); // per-call timeout
+const orNull = await limiter.executeOrNull(undefined, () => fetchJson(url));
+```
+
+### Hedged requests
+
+Starts a backup request when the first one is slow, and takes whichever answers first.
+
+```ts
+import { hedge } from "arrow-resilience-kit";
+
+// A second attempt after 200 ms, at most 2 extra attempts.
+const fastest = await hedge(() => fetchJson(url), 200, 2);
+```
+
+### Failover
+
+Tries providers in order, skipping one that keeps failing.
+
+```ts
+import { Failover, FailoverProviderSpec } from "arrow-resilience-kit";
+
+const source = await Failover.create([
+    new FailoverProviderSpec("primary", () => fetchJson("https://primary.example.com/data")),
+    new FailoverProviderSpec("replica", () => fetchJson("https://replica.example.com/data")),
+]);
+const value = await source.execute();
+```
+
+### Retry budget
+
+Caps retries across all calls to a dependency (a ratio of successful calls), so retries can't amplify an outage.
+
+```ts
+import { RetryBudget } from "arrow-resilience-kit";
+
+const budget = await RetryBudget.create(10, 0.2); // up to 10 tokens, +0.2 per success
+const reply = await budget.retry(() => fetchJson(url), 3, 100, 2_000);
+```
+
+### Adaptive limiter
+
+Adjusts its concurrency limit to observed latency: grows while calls are fast, shrinks when they slow down.
+
+```ts
+import { AdaptiveLimiter } from "arrow-resilience-kit";
+
+const adaptive = await AdaptiveLimiter.create(10, 1, 100, 1, 0.5, 250);
+await adaptive.execute(() => fetchJson(url));
+```
+
+### Cache
+
+String-keyed cache with LRU (or LFU/FIFO) eviction and an optional TTL.
+
+```ts
+import { Cache } from "arrow-resilience-kit";
+
+const cache = await Cache.create<User>(1_000, 60_000, "LRU");
+const cached = await cache.getOrPut("user:42", () => fetchJson("https://api.example.com/users/42"));
+```
+
+## Errors
+
+A rejected promise carries **exactly the error your function rejected with**, so `instanceof` and custom fields keep working:
+
+```ts
+try {
+    await breaker.execute(() => fetchJson(url));
+} catch (e) {
+    if (e instanceof HttpError && e.status === 404) {
+        // not found, as thrown by fetchJson
+    }
+}
+```
+
+Errors raised by the library itself (circuit open, bulkhead full, timeout, retry budget exhausted, ...) are `Error`s with a descriptive message.
+
+## Cancellation
+
+`execute(...)` on the circuit breakers, bulkhead, rate limiters, adaptive limiter, time limiter and failover, plus `RetryBudget.retry(...)`, `hedge(...)` and the `Retry` functions accept an `AbortSignal` (the last argument, or the `signal` option of `Retry.withBackoff`). Aborting cancels whatever the library is waiting for (a retry delay, a permit, a timeout) and rejects with `signal.reason`, the same contract as `fetch(url, { signal })`. To also stop the work inside your function, pass the signal into it:
+
+```ts
+const controller = new AbortController();
+const pending = breaker.execute(() => fetch(url, { signal: controller.signal }), controller.signal);
+controller.abort();
+```
+
+## Async context
+
+On Node.js 20.16+ and Bun, your callbacks run in the async context of the call that passed them, so `AsyncLocalStorage` values (request ids, tracing spans) belong to the right caller even when many calls run concurrently.
+
+## Logging
+
+Nothing is logged by default. Turn logging on, or route it into your own logger:
+
+```ts
+import { Logging } from "arrow-resilience-kit";
+
+Logging.setLevel("WARN"); // OFF (default), ERROR, WARN, INFO, DEBUG, TRACE
+Logging.setHandler((level, message, error) => console.log(`[${level}] ${message}`, error ?? ""));
+Logging.setHandler(null); // back to the console
+```
+
+## Statistics
+
+Most patterns report what they did, for metrics and dashboards:
+
+```ts
+const stats = await bulkhead.statistics();
+console.log(stats.totalCalls, stats.rejectedCalls);
+```
+
+## Size
+
+About 1.3 MB of JavaScript before bundling (the Kotlin standard library and coroutines are compiled in), plus source maps; no dependencies. Declared free of side effects, so bundlers can drop it when unused.
+
+## Links
+
+- [Source, Kotlin/JVM/iOS documentation and design notes](https://github.com/sorinirimies/arrow-resilience-kit)
+- [Changelog](https://github.com/sorinirimies/arrow-resilience-kit/blob/main/CHANGELOG.md)
+- [Issues](https://github.com/sorinirimies/arrow-resilience-kit/issues)
+
+## License
+
+MIT

package/arrow-arrow-atomic.js

@@ -13,32 +13,32 @@
   'use strict';
   //region block: imports
   var AtomicReference = kotlin_kotlin.$_$.j3;
-  var protoOf = kotlin_kotlin.$_$.r5;
-  var initMetadataForClass = kotlin_kotlin.$_$.f5;
+  var protoOf = kotlin_kotlin.$_$.s5;
+  var initMetadataForClass = kotlin_kotlin.$_$.g5;
   //endregion
   //region block: pre-declaration
   initMetadataForClass(Atomic, 'Atomic');
   //endregion
   function set_value(_this__u8e3s4, value) {
-    _this__u8e3s4.set_inogor_k$(value);
+    _this__u8e3s4.df(value);
   }
   function get_value(_this__u8e3s4) {
-    return _this__u8e3s4.get_26vq_k$();
+    return _this__u8e3s4.ef();
   }
   function Atomic(initialValue) {
-    this.inner_1 = new AtomicReference(initialValue);
+    this.cf_1 = new AtomicReference(initialValue);
   }
-  protoOf(Atomic).get_26vq_k$ = function () {
-    return this.inner_1.load_1zbae_k$();
+  protoOf(Atomic).ef = function () {
+    return this.cf_1.c6();
   };
-  protoOf(Atomic).set_inogor_k$ = function (value) {
-    this.inner_1.store_2l8a0y_k$(value);
+  protoOf(Atomic).df = function (value) {
+    this.cf_1.d6(value);
   };
-  protoOf(Atomic).getAndSet_6mmyt0_k$ = function (value) {
-    return this.inner_1.exchange_fma250_k$(value);
+  protoOf(Atomic).ff = function (value) {
+    return this.cf_1.e6(value);
   };
-  protoOf(Atomic).compareAndSet_10iwom_k$ = function (expected, new_0) {
-    return this.inner_1.compareAndSet_l3595a_k$(expected, new_0);
+  protoOf(Atomic).gf = function (expected, new_0) {
+    return this.cf_1.f6(expected, new_0);
   };
   //region block: exports
   _.$_$ = _.$_$ || {};

package/arrow-arrow-atomic.js.map

@@ -1 +1 @@
-{"version":3,"sourceRoot":"../../../../../../../../../../../Users/runner/work/arrow/arrow/arrow-libs/core/arrow-atomic/src/","sources":["NATIVE_IMPLEMENTATIONS.kt","commonMain/kotlin/arrow/atomic/Atomic.kt","nonJvmMain/kotlin/arrow/atomic/Atomic.kt"],"sourcesContent":[null,null,null],"ignoreList":[0],"x_google_ignoreList":[0],"names":["<set-value>","<this>","value","<get-value>","<init>","initialValue","get","set","getAndSet","compareAndSet","expected","new"],"mappings":";;;;;;;;;;;;;;;;;;;;;EC6CEA,mBAFaC,a,EAETC,KAAJF,EAAW;A,IACT,4BAAI,KAAJ,C;EACF,C;EAHAG,mBADaF,aACbE,EAAQ;A,IAAK,OAAL,2B;EAAI,C;ECrCuBC,gBAAYC,YAAZD,EAAA;A,IACf,mCAAkB,YAAlB,C;EADe,C;gCAGrBE,UAAAA,EAAe;A,IAAY,OAAZ,IAAM,CAAN,OAAM,gB;EAAK,C;kCAC1BC,UAAQL,KAARK,EAAkB;A,IAAE,IAAM,CAAN,OAAM,iBAAM,KAAN,C;EAAa,C;wCACvCC,UAAcN,KAAdM,EAA6B;A,IAAqB,OAArB,IAAM,CAAN,OAAM,oBAAS,KAAT,C;EAAc,C;4CAMjDC,UAAkBC,Q,EAAaC,KAA/BF,EAAkD;A,IAAkC,OAAlC,IAAM,CAAN,OAAM,yBAAc,QAAd,EAAwB,KAAxB,C;EAA2B,C;;;;;;;;;"}
+{"version":3,"sourceRoot":"../../../../../../../../../../../Users/runner/work/arrow/arrow/arrow-libs/core/arrow-atomic/src/","sources":["NATIVE_IMPLEMENTATIONS.kt","commonMain/kotlin/arrow/atomic/Atomic.kt","nonJvmMain/kotlin/arrow/atomic/Atomic.kt"],"sourcesContent":[null,null,null],"ignoreList":[0],"x_google_ignoreList":[0],"names":["<set-value>","<this>","value","<get-value>","<init>","initialValue","get","set","getAndSet","compareAndSet","expected","new"],"mappings":";;;;;;;;;;;;;;;;;;;;;EC6CEA,mBAFaC,a,EAETC,KAAJF,EAAW;A,IACT,iBAAI,KAAJ,C;EACF,C;EAHAG,mBADaF,aACbE,EAAQ;A,IAAK,OAAL,kB;EAAI,C;ECrCuBC,gBAAYC,YAAZD,EAAA;A,IACf,gCAAkB,YAAlB,C;EADe,C;uBAGrBE,UAAAA,EAAe;A,IAAY,OAAZ,IAAM,CAAN,IAAM,K;EAAK,C;uBAC1BC,UAAQL,KAARK,EAAkB;A,IAAE,IAAM,CAAN,IAAM,IAAM,KAAN,C;EAAa,C;uBACvCC,UAAcN,KAAdM,EAA6B;A,IAAqB,OAArB,IAAM,CAAN,IAAM,IAAS,KAAT,C;EAAc,C;uBAMjDC,UAAkBC,Q,EAAaC,KAA/BF,EAAkD;A,IAAkC,OAAlC,IAAM,CAAN,IAAM,IAAc,QAAd,EAAwB,KAAxB,C;EAA2B,C;;;;;;;;;"}

package/arrow-arrow-core.js

@@ -12,14 +12,14 @@
 }(function (_, kotlin_kotlin) {
   'use strict';
   //region block: imports
-  var noWhenBranchMatchedException = kotlin_kotlin.$_$.b7;
-  var protoOf = kotlin_kotlin.$_$.r5;
-  var initMetadataForCompanion = kotlin_kotlin.$_$.g5;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.d7;
+  var protoOf = kotlin_kotlin.$_$.s5;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.h5;
   var Unit_instance = kotlin_kotlin.$_$.b1;
-  var toString = kotlin_kotlin.$_$.e7;
-  var hashCode = kotlin_kotlin.$_$.e5;
-  var equals = kotlin_kotlin.$_$.z4;
-  var initMetadataForClass = kotlin_kotlin.$_$.f5;
+  var toString = kotlin_kotlin.$_$.g7;
+  var hashCode = kotlin_kotlin.$_$.f5;
+  var equals = kotlin_kotlin.$_$.a5;
+  var initMetadataForClass = kotlin_kotlin.$_$.g5;
   var VOID = kotlin_kotlin.$_$.a;
   //endregion
   //region block: pre-declaration
@@ -35,11 +35,11 @@
     var tmp;
     if (_this__u8e3s4 instanceof Right) {
       // Inline function 'arrow.core.identity' call
-      tmp = _this__u8e3s4.value_1;
+      tmp = _this__u8e3s4.if_1;
     } else {
       if (_this__u8e3s4 instanceof Left) {
         // Inline function 'arrow.core.identity' call
-        tmp = _this__u8e3s4.value_1;
+        tmp = _this__u8e3s4.hf_1;
       } else {
         noWhenBranchMatchedException();
       }
@@ -54,7 +54,7 @@
   }
   function Companion_0() {
     Companion_instance_0 = this;
-    this.unit_1 = new Right(Unit_instance);
+    this.jf_1 = new Right(Unit_instance);
   }
   var Companion_instance_0;
   function Companion_getInstance_0() {
@@ -66,40 +66,40 @@
   }
   function Left(value) {
     Either.call(this);
-    this.value_1 = value;
+    this.hf_1 = value;
   }
   protoOf(Left).toString = function () {
-    return 'Either.Left(' + toString(this.value_1) + ')';
+    return 'Either.Left(' + toString(this.hf_1) + ')';
   };
   protoOf(Left).hashCode = function () {
-    return this.value_1 == null ? 0 : hashCode(this.value_1);
+    return this.hf_1 == null ? 0 : hashCode(this.hf_1);
   };
   protoOf(Left).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Left))
       return false;
-    if (!equals(this.value_1, other.value_1))
+    if (!equals(this.hf_1, other.hf_1))
       return false;
     return true;
   };
   function Right(value) {
     Companion_getInstance_0();
     Either.call(this);
-    this.value_1 = value;
+    this.if_1 = value;
   }
   protoOf(Right).toString = function () {
-    return 'Either.Right(' + toString(this.value_1) + ')';
+    return 'Either.Right(' + toString(this.if_1) + ')';
   };
   protoOf(Right).hashCode = function () {
-    return this.value_1 == null ? 0 : hashCode(this.value_1);
+    return this.if_1 == null ? 0 : hashCode(this.if_1);
   };
   protoOf(Right).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Right))
       return false;
-    if (!equals(this.value_1, other.value_1))
+    if (!equals(this.if_1, other.if_1))
       return false;
     return true;
   };
@@ -115,11 +115,11 @@
     // Inline function 'arrow.core.Either.fold' call
     var tmp;
     if (this instanceof Right) {
-      var it = this.value_1;
+      var it = this.if_1;
       tmp = 'Either.Right(' + toString(it) + ')';
     } else {
       if (this instanceof Left) {
-        var it_0 = this.value_1;
+        var it_0 = this.hf_1;
         tmp = 'Either.Left(' + toString(it_0) + ')';
       } else {
         noWhenBranchMatchedException();

package/arrow-arrow-core.js.map

@@ -1 +1 @@
-{"version":3,"sources":["NATIVE_IMPLEMENTATIONS.kt","../../../../../../../../../../../Users/runner/work/arrow/arrow/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Either.kt"],"sourcesContent":[null,null],"ignoreList":[0],"x_google_ignoreList":[0],"names":["merge","<this>","<init>","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EC88COA,eAAQC,aAARD,EACL;A;QD/8CF,G;IC2lBM,IAo3BJ,aAp3BI,kB;;YAo3BJ,a,CAp3BwB,O;;MACpB,IAm3BJ,aAn3BI,iB;;cAm3BJ,a,CAn3BsB,O;;QAFb,8B;;;IAq3BmB,OAr3BnB,G;EAq3BkB,C;EA1pBzBE,mBAAAA,EAAA;A,EAAA,C;;EDrzBJ,+BAAA,EAAA;AAAA;AAAA,GAAA;A,EC8zBIA,qBAAAA,EAAA;A;IAE6C,sC;EAF7C,C;;ED9zBJ,iCAAA,EAAA;AAAA,sCAAA;AAAA;;AAAA;AAAA;AAAA,GAAA;A,ECkzBgCA,cAAY,KAAZA,EAAA;A,IAA9B,iB;IAA0C,oB;EAAZ,C;2BACnBC,UAAAA,EAAyB;A,IAAqB,OAApB,cAAoB,YAAP,IAAO,CAAP,OAAO,IAAF,G;EAAC,C;2BDnzB1D,UAAA,EAAA;AAAA,IAAA,OAAA,IAAA,CAAA,OAAA,IAAA,IAAA,GAAA,CAAA,GAAA,SAAA,IAAA,CAAA,OAAA,CAAA;AAAA,EAAA,CAAA;yBAAA,UAAA,KAAA,EAAA;AAAA,IAAA,IAAA,IAAA,KAAA,KAAA,CAAA;AAAA,MAAA,OAAA,IAAA;IAAA,MAAA,KAAA,kBAAA;AAAA,MAAA,OAAA,KAAA;IAAA,IAAA,CAAA,OAAA,IAAA,CAAA,OAAA,EAAA,KAAA,CAAA,OAAA,CAAA,CAAA;AAAA,MAAA,OAAA,KAAA;IAAA,OAAA,IAAA;AAAA,EAAA,CAAA;A,EC2zBiCD,eAAY,KAAZA,EAAA;A,IAA/B,yB;IAAA,iB;IAA2C,oB;EAAZ,C;4BACpBC,UAAAA,EAAyB;A,IAAsB,OAArB,eAAqB,YAAP,IAAO,CAAP,OAAO,IAAF,G;EAAC,C;4BD5zB3D,UAAA,EAAA;AAAA,IAAA,OAAA,IAAA,CAAA,OAAA,IAAA,IAAA,GAAA,CAAA,GAAA,SAAA,IAAA,CAAA,OAAA,CAAA;AAAA,EAAA,CAAA;0BAAA,UAAA,KAAA,EAAA;AAAA,IAAA,IAAA,IAAA,KAAA,KAAA,CAAA;AAAA,MAAA,OAAA,IAAA;IAAA,MAAA,KAAA,mBAAA;AAAA,MAAA,OAAA,KAAA;IAAA,IAAA,CAAA,OAAA,IAAA,CAAA,OAAA,EAAA,KAAA,CAAA,OAAA,CAAA,CAAA;AAAA,MAAA,OAAA,KAAA;IAAA,OAAA,IAAA;AAAA,EAAA,CAAA;A,EC40BED,qBAAAA,EAAA;A,EAAA,C;;ED50BF,iCAAA,EAAA;AAAA;AAAA,GAAA;A,ECueAA,gBAAAA,EAAA;A,EAAA,C;6BA6VWC,UAAAA,EAAyB;A;QDp0BpC,G;IC2lBM,IAyO8B,IAzO9B,kB;UD3lBN,KCo0BoC,IDp0BpC,CC2lB0B,O;YA2OnB,eAAD,YAAe,EAAf,IAAiB,G;;MA1OjB,IAwO8B,IAxO9B,iB;YD5lBN,OCo0BoC,IDp0BpC,CC4lBwB,O;cAyOjB,cAAD,YAAc,IAAd,IAAgB,G;;QA3OX,8B;;;IA6OR,OA7OQ,G;EA6OT,C;;;;;;;;;;;;;"}
+{"version":3,"sources":["NATIVE_IMPLEMENTATIONS.kt","../../../../../../../../../../../Users/runner/work/arrow/arrow/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Either.kt"],"sourcesContent":[null,null],"ignoreList":[0],"x_google_ignoreList":[0],"names":["merge","<this>","<init>","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EC88COA,eAAQC,aAARD,EACL;A;QD/8CF,G;IC2lBM,IAo3BJ,aAp3BI,kB;;YAo3BJ,a,CAp3BwB,I;;MACpB,IAm3BJ,aAn3BI,iB;;cAm3BJ,a,CAn3BsB,I;;QAFb,8B;;;IAq3BmB,OAr3BnB,G;EAq3BkB,C;EA1pBzBE,mBAAAA,EAAA;A,EAAA,C;;EDrzBJ,+BAAA,EAAA;AAAA;AAAA,GAAA;A,EC8zBIA,qBAAAA,EAAA;A;IAE6C,oC;EAF7C,C;;ED9zBJ,iCAAA,EAAA;AAAA,sCAAA;AAAA;;AAAA;AAAA;AAAA,GAAA;A,ECkzBgCA,cAAY,KAAZA,EAAA;A,IAA9B,iB;IAA0C,iB;EAAZ,C;2BACnBC,UAAAA,EAAyB;A,IAAqB,OAApB,cAAoB,YAAP,IAAO,CAAP,IAAO,IAAF,G;EAAC,C;2BDnzB1D,UAAA,EAAA;AAAA,IAAA,OAAA,IAAA,CAAA,IAAA,IAAA,IAAA,GAAA,CAAA,GAAA,SAAA,IAAA,CAAA,IAAA,CAAA;AAAA,EAAA,CAAA;yBAAA,UAAA,KAAA,EAAA;AAAA,IAAA,IAAA,IAAA,KAAA,KAAA,CAAA;AAAA,MAAA,OAAA,IAAA;IAAA,MAAA,KAAA,kBAAA;AAAA,MAAA,OAAA,KAAA;IAAA,IAAA,CAAA,OAAA,IAAA,CAAA,IAAA,EAAA,KAAA,CAAA,IAAA,CAAA,CAAA;AAAA,MAAA,OAAA,KAAA;IAAA,OAAA,IAAA;AAAA,EAAA,CAAA;A,EC2zBiCD,eAAY,KAAZA,EAAA;A,IAA/B,yB;IAAA,iB;IAA2C,iB;EAAZ,C;4BACpBC,UAAAA,EAAyB;A,IAAsB,OAArB,eAAqB,YAAP,IAAO,CAAP,IAAO,IAAF,G;EAAC,C;4BD5zB3D,UAAA,EAAA;AAAA,IAAA,OAAA,IAAA,CAAA,IAAA,IAAA,IAAA,GAAA,CAAA,GAAA,SAAA,IAAA,CAAA,IAAA,CAAA;AAAA,EAAA,CAAA;0BAAA,UAAA,KAAA,EAAA;AAAA,IAAA,IAAA,IAAA,KAAA,KAAA,CAAA;AAAA,MAAA,OAAA,IAAA;IAAA,MAAA,KAAA,mBAAA;AAAA,MAAA,OAAA,KAAA;IAAA,IAAA,CAAA,OAAA,IAAA,CAAA,IAAA,EAAA,KAAA,CAAA,IAAA,CAAA,CAAA;AAAA,MAAA,OAAA,KAAA;IAAA,OAAA,IAAA;AAAA,EAAA,CAAA;A,EC40BED,qBAAAA,EAAA;A,EAAA,C;;ED50BF,iCAAA,EAAA;AAAA;AAAA,GAAA;A,ECueAA,gBAAAA,EAAA;A,EAAA,C;6BA6VWC,UAAAA,EAAyB;A;QDp0BpC,G;IC2lBM,IAyO8B,IAzO9B,kB;UD3lBN,KCo0BoC,IDp0BpC,CC2lB0B,I;YA2OnB,eAAD,YAAe,EAAf,IAAiB,G;;MA1OjB,IAwO8B,IAxO9B,iB;YD5lBN,OCo0BoC,IDp0BpC,CC4lBwB,I;cAyOjB,cAAD,YAAc,IAAd,IAAgB,G;;QA3OX,8B;;;IA6OR,OA7OQ,G;EA6OT,C;;;;;;;;;;;;;"}