@tstdl/base 0.93.139 → 0.93.141

package/utils/README.md

@@ -0,0 +1,322 @@
+# @tstdl/base/utils
+
+A comprehensive, modular, and tree-shakeable utility library for TypeScript, providing a rich set of tools for common programming tasks. It features extensive support for asynchronous iterables, object manipulation, cryptography, streams, and robust type safety.
+
+## Table of Contents
+
+- [✨ Features](#-features)
+- [Core Concepts](#core-concepts)
+- [🚀 Basic Usage](#-basic-usage)
+- [🔧 Advanced Topics](#-advanced-topics)
+  - [Async Iterable Pipelines](#async-iterable-pipelines)
+  - [Parallel Processing](#parallel-processing)
+  - [Deep Object Merging & Decycling](#deep-object-merging--decycling)
+  - [Resilient Operations (Backoff & Retry)](#resilient-operations-backoff--retry)
+  - [Cryptography Wrappers](#cryptography-wrappers)
+  - [Stream Utilities](#stream-utilities)
+- [📚 API](#-api)
+
+## ✨ Features
+
+- **Async Iterable Helpers**: A complete suite of functional operators (`map`, `filter`, `reduce`, `batch`, etc.) for `AsyncIterable`, enabling powerful streaming data pipelines.
+- **Parallel Processing**: Utilities to process async iterables concurrently (`parallelMap`, `parallelForEach`).
+- **Object Manipulation**: Advanced helpers for deep merging, circular reference handling (`decycle`/`recycle`), and type-safe property path access.
+- **Cryptography**: Simplified, promise-based wrappers around the Web Crypto API for encryption, hashing, and signing.
+- **Resilience Patterns**: Built-in `backoffLoop` and `retryAsync` for handling unstable operations with exponential backoff and jitter.
+- **Stream Utilities**: Tools to convert between Streams, Iterables, and Buffers, including `readBinaryStream` and `toBytesStream`.
+- **Type Safety**: Extensive collection of type guards (`isString`, `isDefined`) and assertion functions (`assertDefinedPass`) to narrow types at runtime.
+- **Zero Dependencies**: Lightweight and self-contained.
+
+## Core Concepts
+
+### Iterable-First Design
+
+The library prioritizes `Iterable` and `AsyncIterable` interfaces. This allows for memory-efficient, lazy evaluation of data sequences. Instead of loading large datasets into arrays, you can process them item-by-item as they flow through a pipeline.
+
+### Tree-Shakeability
+
+Every utility is exported in a way that allows modern bundlers to strip out unused code. You can import everything from the root `@tstdl/base/utils`, and only what you use will end up in your production build.
+
+### Type Guards & Assertions
+
+We provide pairs of functions for type checking:
+
+- **Guards** (`isString`): Return a boolean and narrow the type in TypeScript.
+- **Assertions** (`assertString`): Throw an `AssertionError` if the check fails, asserting the type.
+- **Pass-through Assertions** (`assertStringPass`): Assert the type and return the value, allowing for inline checks.
+
+## 🚀 Basic Usage
+
+Import the utilities you need directly from the package root.
+
+```typescript
+import { isDefined, timeout, mapAsync, toArrayAsync, randomString } from '@tstdl/base/utils';
+
+async function main() {
+  // 1. Simple Type Guard
+  const value: string | undefined = 'Hello';
+  if (isDefined(value)) {
+    console.log(value.toUpperCase()); // value is typed as string here
+  }
+
+  // 2. Async Iterable Helper
+  async function* numberGenerator() {
+    yield 1;
+    yield 2;
+    yield 3;
+  }
+
+  const doubled = await toArrayAsync(
+    mapAsync(numberGenerator(), async (num) => {
+      await timeout(100); // Wait 100ms
+      return num * 2;
+    }),
+  );
+  console.log(doubled); // [2, 4, 6]
+}
+```
+
+## 🔧 Advanced Topics
+
+### Async Iterable Pipelines
+
+Chain multiple operations to process data streams efficiently. This is similar to RxJS or LINQ but built on standard `AsyncIterable`.
+
+```typescript
+import { range, filterAsync, mapAsync, batchAsync, toArrayAsync } from '@tstdl/base/utils';
+
+// Create a pipeline
+const pipeline = batchAsync(
+  mapAsync(
+    filterAsync(
+      // Source: Sync iterable converted to async automatically
+      range(1, 100),
+      (x) => x % 2 === 0, // Keep evens
+    ),
+    async (x) => x * 10, // Multiply by 10
+  ),
+  5, // Batch into arrays of 5 items
+);
+
+// Execute the pipeline
+const batches = await toArrayAsync(pipeline);
+// Result: [[20, 40, 60, 80, 100], [120, ...], ...]
+```
+
+### Parallel Processing
+
+When processing items involves IO (like network requests), processing them sequentially is slow. Use `parallelMap` or `parallelForEach` to control concurrency.
+
+```typescript
+import { parallelMap, toArrayAsync } from '@tstdl/base/utils';
+
+const userIds = [1, 2, 3, 4, 5];
+
+const users = await toArrayAsync(
+  parallelMap(
+    userIds,
+    3, // Concurrency: Process 3 items at a time
+    true, // Keep Order: Ensure output order matches input order
+    async (id) => {
+      const response = await fetch(`/users/${id}`);
+      return response.json();
+    },
+  ),
+);
+```
+
+### Deep Object Merging & Decycling
+
+Handle complex objects with circular references or deep structures.
+
+```typescript
+import { mergeDeep, decycle, recycle } from '@tstdl/base/utils';
+
+// Deep Merge
+const defaultSettings = { theme: { color: 'blue', font: 'arial' } };
+const userSettings = { theme: { color: 'red' } };
+
+const settings = mergeDeep(defaultSettings, userSettings);
+// { theme: { color: 'red', font: 'arial' } }
+
+// Circular References
+const a: any = { name: 'A' };
+const b: any = { name: 'B', parent: a };
+a.child = b;
+
+// JSON.stringify(a) would throw. Use decycle:
+const safe = decycle(a);
+const json = JSON.stringify(safe);
+
+// Restore later
+const restored = recycle(JSON.parse(json));
+```
+
+### Resilient Operations (Backoff & Retry)
+
+Handle transient failures and hanging requests using `backoffLoop` and `retryWithBackoff`.
+
+#### backoffLoop
+
+Manual control over a retry loop.
+
+```typescript
+import { backoffLoop } from '@tstdl/base/utils';
+
+await backoffLoop(
+  async (controller) => {
+    try {
+      await fetch('https://api.example.com/unstable');
+      controller.break(); // Success, exit loop
+    } catch (error) {
+      console.warn('Request failed, retrying...');
+      controller.backoff(); // Wait (exponentially increasing delay) then retry
+    }
+  },
+  {
+    strategy: 'exponential',
+    initialDelay: 500,
+    maximumDelay: 5000,
+    jitter: 0.1,
+  },
+);
+```
+
+#### retryWithBackoff
+
+A higher-order utility that combines retries, exponential backoff, jitter, and timeouts. It also automatically respects `Retry-After` headers for HTTP errors.
+
+```typescript
+import { retryWithBackoff } from '@tstdl/base/utils';
+
+const result = await retryWithBackoff(
+  async (signal) => {
+    // signal is set if the attempt times out or is cancelled
+    return await fetch('https://api.example.com/data', { signal: signal.asAbortSignal() });
+  },
+  {
+    timeout: 5000, // Timeout for EACH attempt
+    retry: {
+      shouldRetry: (error, attempt) => attempt < 3 && isTransientError(error),
+      backoff: { strategy: 'exponential', initialDelay: 1000 },
+    },
+  },
+);
+```
+
+### Cryptography Wrappers
+
+Simplified, promise-based access to modern crypto standards.
+
+```typescript
+import { digest, generatePbkdf2Key, encrypt, decrypt, encodeBase64 } from '@tstdl/base/utils';
+
+// Hashing
+const hash = await digest('SHA-256', 'Hello World');
+console.log(await hash.toHex());
+
+// Encryption
+const key = await generatePbkdf2Key(true);
+const encrypted = encrypt('AES-GCM', key, 'Secret Message');
+console.log(await encrypted.toBase64());
+```
+
+### Stream Utilities
+
+Bridge the gap between Node.js Streams, Web Streams, and Iterables.
+
+```typescript
+import { readBinaryStream, toBytesStream } from '@tstdl/base/utils';
+
+// Read a Web ReadableStream into a single Uint8Array
+const response = await fetch('https://example.com/image.png');
+const buffer = await readBinaryStream(response.body!);
+
+// Convert a stream of arbitrary chunks to a byte stream
+const byteStream = toBytesStream(someObjectStream);
+```
+
+## 📚 API
+
+### Async Iterable Helpers
+
+| Function                            | Description                                               |
+| :---------------------------------- | :-------------------------------------------------------- |
+| `mapAsync`                          | Transform items asynchronously.                           |
+| `filterAsync`                       | Filter items asynchronously.                              |
+| `reduceAsync`                       | Reduce items to a single value.                           |
+| `batchAsync`                        | Group items into arrays of a specific size.               |
+| `bufferAsync`                       | Buffer items to handle backpressure or bursts.            |
+| `takeAsync` / `skipAsync`           | Take or skip a specific number of items.                  |
+| `takeWhileAsync` / `takeUntilAsync` | Take items based on a predicate or signal.                |
+| `distinctAsync`                     | Filter out duplicate items.                               |
+| `groupAsync`                        | Group items by a key selector.                            |
+| `toArrayAsync`                      | Consume the iterable and return an array.                 |
+| `firstAsync` / `lastAsync`          | Get the first or last item.                               |
+| `drainAsync`                        | Consume the iterable completely without returning values. |
+
+### Parallel Processing
+
+| Function          | Description                                        |
+| :---------------- | :------------------------------------------------- |
+| `parallelMap`     | Map items with specified concurrency.              |
+| `parallelFilter`  | Filter items with specified concurrency.           |
+| `parallelForEach` | Execute a function for each item with concurrency. |
+| `parallelGroup`   | Group items with concurrency.                      |
+
+### Object Utilities
+
+| Function                        | Description                                                      |
+| :------------------------------ | :--------------------------------------------------------------- |
+| `mergeDeep`                     | Deeply merge objects with array handling options.                |
+| `decycle` / `recycle`           | Handle circular references for serialization.                    |
+| `pick` / `omit`                 | Create new objects with selected/omitted keys.                   |
+| `mapObject` / `mapObjectValues` | Map keys or values of an object.                                 |
+| `filterObject`                  | Filter object properties by value or key.                        |
+| `getPropertyNameProxy`          | Type-safe way to get property paths (e.g., `user.profile.name`). |
+| `lazyProperty`                  | Define a property that initializes on first access.              |
+
+### Type Guards & Assertions
+
+| Function                      | Description                                             |
+| :---------------------------- | :------------------------------------------------------ |
+| `isDefined` / `assertDefined` | Check for `null` or `undefined`.                        |
+| `isString` / `assertString`   | Check for string type.                                  |
+| `isNumber` / `assertNumber`   | Check for number type (excluding NaN).                  |
+| `isArray` / `assertArray`     | Check for array.                                        |
+| `isObject` / `assertObject`   | Check for non-null object.                              |
+| `assert`                      | Generic assertion function.                             |
+| `assert*Pass`                 | Assert and return the value (e.g., `assertStringPass`). |
+
+### Timing & Async
+
+| Function            | Description                               |
+| :------------------ | :---------------------------------------- |
+| `timeout`           | Promise-based delay.                      |
+| `cancelableTimeout` | Delay that can be cancelled via a signal. |
+| `withTimeout`       | Race a promise against a timeout.         |
+| `backoffLoop`       | Run a loop with backoff logic.            |
+| `retryWithBackoff`  | Higher-order retry utility with backoff.  |
+| `asyncHook`         | Create an async event hook registry.      |
+| `Timer`             | High-resolution timer for benchmarking.   |
+
+### Cryptography & Encoding
+
+| Function                        | Description                             |
+| :------------------------------ | :-------------------------------------- |
+| `encrypt` / `decrypt`           | AES encryption wrappers.                |
+| `digest`                        | SHA hashing wrapper.                    |
+| `sign` / `verify`               | Digital signatures (HMAC, ECDSA, etc.). |
+| `encodeBase64` / `decodeBase64` | Base64 encoding utilities.              |
+| `encodeHex` / `decodeHex`       | Hex encoding utilities.                 |
+| `encodeUtf8` / `decodeText`     | String/Buffer encoding utilities.       |
+
+### Miscellaneous
+
+| Function                         | Description                               |
+| :------------------------------- | :---------------------------------------- |
+| `randomString` / `randomInt`     | Random value generation.                  |
+| `formatDuration` / `formatBytes` | Formatting utilities.                     |
+| `tryIgnore`                      | Try a function, return fallback on error. |
+| `buildUrl`                       | Construct URLs with query parameters.     |
+| `memoize`                        | Function memoization.                     |

package/utils/async-iterable-helpers/observable-iterable.d.ts

@@ -1,2 +1,2 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export declare function observableAsyncIterable<T>(observable: Observable<T>): AsyncIterableIterator<T>;

package/utils/async-iterable-helpers/observable-iterable.js

@@ -1,30 +1,26 @@
+import { firstValueFrom, merge } from 'rxjs';
 import { CancellationToken } from '../../cancellation/token.js';
-import { merge, take } from 'rxjs';
 import { ObservableArray } from '../../collections/observable/observable-array.js';
 export async function* observableAsyncIterable(observable) {
     const buffer = new ObservableArray();
     const completeToken = new CancellationToken();
     const errorToken = new CancellationToken();
-    let error;
     const subscription = observable.subscribe({
         next: (value) => buffer.add(value),
         complete: () => completeToken.set(),
-        error: (_error) => {
-            error = _error;
-            errorToken.set();
-        }
+        error: (error) => errorToken.set(error),
     });
     try {
         while (buffer.length > 0 || !completeToken.isSet) {
             if (buffer.length == 0) {
-                await merge(buffer.add$, completeToken.set$, errorToken.set$).pipe(take(1)).toPromise();
+                await firstValueFrom(merge(buffer.add$, completeToken, errorToken));
             }
             while (buffer.length > 0) {
                 const item = buffer.removeFirst();
                 yield item;
             }
             if (errorToken.isSet) {
-                throw error;
+                throw errorToken.reason;
             }
         }
     }

package/utils/async-iterable-helpers/take-until.js

@@ -1,4 +1,4 @@
-import { firstValueFrom, map, race } from 'rxjs';
+import { firstValueFrom, from, map, race } from 'rxjs';
 import { isAsyncIterable } from './is-async-iterable.js';
 export function takeUntilAsync(iterable, cancellationSignal) {
     return isAsyncIterable(iterable)
@@ -20,7 +20,7 @@ async function* sync(iterable, cancellationSignal) {
 }
 async function* async(iterable, cancellationSignal) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const cancel$ = cancellationSignal.set$.pipe(map(() => ({ done: true, value: undefined }))); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    const cancel$ = from(cancellationSignal).pipe(map(() => ({ done: true, value: undefined })));
     try {
         while (true) {
             const result = await firstValueFrom(race([iterator.next(), cancel$]));
@@ -31,10 +31,10 @@ async function* async(iterable, cancellationSignal) {
         }
     }
     catch (error) {
-        (iterator.throw ?? iterator.return)?.(error);
+        await (iterator.throw ?? iterator.return)?.(error);
     }
     finally {
-        iterator.return?.();
+        await iterator.return?.();
     }
     return undefined;
 }

package/utils/backoff.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { CancellationToken } from '../cancellation/token.js';
 import { NEVER } from 'rxjs';
 import { randomFloat } from './math.js';
@@ -109,37 +161,44 @@ export async function autoBackoffLoop(loopFunction, options = {}) {
  * @param options Additional options for backoff configuration and cancellation.
  */
 export async function backoffLoop(loopFunction, options = {}) {
-    const { cancellationSignal, ...backoffOptions } = options;
-    const backoffHelper = new BackoffHelper(backoffOptions);
-    const loopToken = new CancellationToken();
-    let shouldBackoff = false;
-    let customBackoffDelay;
-    if (isDefined(cancellationSignal)) {
-        loopToken.inherit(cancellationSignal, { set: true, unset: false, complete: false, error: false });
-    }
-    const controller = {
-        backoff: (delay) => {
-            shouldBackoff = true;
-            customBackoffDelay = delay;
-        },
-        break: () => loopToken.set(),
-    };
-    while (loopToken.isUnset) {
-        await loopFunction(controller, loopToken.signal, backoffHelper.status);
-        // Exit immediately if the loop function requested a break.
-        if (loopToken.isSet) {
-            return;
-        }
-        if (shouldBackoff) {
-            shouldBackoff = false;
-            const delay = customBackoffDelay ?? backoffHelper.getNextDelay();
-            await cancelableTimeout(delay, loopToken.signal);
-        }
-        else {
-            // If an iteration completes successfully without a backoff request, reset the delay.
-            backoffHelper.reset();
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { cancellationSignal, ...backoffOptions } = options;
+        const backoffHelper = new BackoffHelper(backoffOptions);
+        const loopToken = __addDisposableResource(env_1, new CancellationToken(cancellationSignal), false);
+        let shouldBackoff = false;
+        let customBackoffDelay;
+        const controller = {
+            backoff: (delay) => {
+                shouldBackoff = true;
+                customBackoffDelay = delay;
+            },
+            break: () => loopToken.set(),
+        };
+        while (loopToken.isUnset) {
+            await loopFunction(controller, loopToken, backoffHelper.status);
+            // Exit immediately if the loop function requested a break.
+            if (loopToken.isSet) {
+                return;
+            }
+            if (shouldBackoff) {
+                shouldBackoff = false;
+                const delay = customBackoffDelay ?? backoffHelper.getNextDelay();
+                await cancelableTimeout(delay, loopToken);
+            }
+            else {
+                // If an iteration completes successfully without a backoff request, reset the delay.
+                backoffHelper.reset();
+            }
         }
     }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 }
 /**
  * Creates an async generator that yields a callback to trigger a backoff.
@@ -182,7 +241,7 @@ export async function* backoffGenerator(options = {}) {
             const continueToken = backoffOptions?.continueToken;
             if (isDefined(continueToken)) {
                 timeoutSignal = isDefined(cancellationSignal)
-                    ? cancellationSignal.createChild().inherit(continueToken)
+                    ? cancellationSignal.inherit(continueToken)
                     : continueToken;
             }
         };

package/utils/file-reader.js

@@ -1,4 +1,3 @@
-import { DetailsError } from '../errors/details.error.js';
 export async function readAsText(blob, encoding) {
     return await setup((reader) => reader.readAsText(blob, encoding));
 }
@@ -12,7 +11,7 @@ async function setup(dispatcher) {
     return await new Promise((resolve, reject) => {
         const reader = new FileReader();
         reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new DetailsError(reader.error.message, reader.error));
+        reader.onerror = () => reject(new Error('FileReader error', { cause: reader.error }));
         dispatcher(reader);
     });
 }

package/utils/retry-with-backoff.js

@@ -15,7 +15,7 @@ export async function retryWithBackoff(func, options = {}) {
     await backoffLoop(async (controller, loopSignal, status) => {
         try {
             const attemptSignal = isDefined(signal)
-                ? signal.createChild().inherit(loopSignal)
+                ? signal.inherit(loopSignal)
                 : loopSignal;
             if (isDefined(timeout)) {
                 result = await withTimeout(timeout, async () => await func(attemptSignal));

package/utils/timer.d.ts

@@ -1,6 +1,6 @@
 export declare class Timer {
     private elapsedNanoseconds;
-    private begin?;
+    private begin;
     constructor(start?: boolean);
     static startNew(): Timer;
     static measure(func: () => any): number;

package/utils/timer.js

@@ -1,3 +1,4 @@
+import { isDefined, isUndefined } from './type-guards.js';
 const nsPerSec = 1e9;
 const nsPerMs = 1e6;
 const nsPerUs = 1e3;
@@ -41,12 +42,10 @@ export class Timer {
         return timer.milliseconds;
     }
     start() {
-        if (this.begin == undefined) {
-            this.begin = getBegin();
-        }
+        this.begin ??= getBegin();
     }
     stop() {
-        if (this.begin != undefined) {
+        if (isDefined(this.begin)) {
             const nanoseconds = this.read();
             this.elapsedNanoseconds += nanoseconds;
             this.begin = undefined;
@@ -61,8 +60,7 @@ export class Timer {
         this.elapsedNanoseconds = 0;
     }
     get nanoseconds() {
-        const result = this.elapsedNanoseconds + this.read();
-        return result;
+        return this.elapsedNanoseconds + this.read();
     }
     get microseconds() {
         return this.nanoseconds / nsPerUs;
@@ -74,7 +72,7 @@ export class Timer {
         return this.nanoseconds / nsPerSec;
     }
     read() {
-        if (this.begin == undefined) {
+        if (isUndefined(this.begin)) {
             return 0;
         }
         const result = getDuration(this.begin);

package/utils/timing.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import { CancellationSignal } from '../cancellation/token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
 import { type ValueOrProvider } from './value-or-provider.js';
 /** Timeout for specified duration */
 export declare function timeout(milliseconds?: number, options?: {

package/utils/timing.js

@@ -1,5 +1,4 @@
-import { firstValueFrom, map, race, timer } from 'rxjs';
-import { CancellationSignal } from '../cancellation/token.js';
+import { firstValueFrom, from, map, race, timer } from 'rxjs';
 import { TimeoutError } from '../errors/timeout.error.js';
 import { _throw } from './throw.js';
 import { resolveValueOrProvider } from './value-or-provider.js';
@@ -21,10 +20,9 @@ export async function timeoutUntil(timestamp) {
 }
 /** Timeout for specified duration */
 export async function cancelableTimeout(milliseconds, cancelSignal) {
-    const observable = (cancelSignal instanceof CancellationSignal) ? cancelSignal.set$ : cancelSignal;
     return await firstValueFrom(race([
         timer(milliseconds).pipe(map(() => 'timeout')),
-        observable.pipe(map(() => 'canceled')),
+        from(cancelSignal).pipe(map(() => 'canceled')),
     ]));
 }
 /** Timeout until specified time */

package/utils/z-base32.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/noBitwiseOperators: ok */
 import type { BinaryData } from '../types/index.js';
 export declare function zBase32Encode(buffer: BinaryData): string;
 export declare function zBase32Decode(input: string): Uint8Array<ArrayBuffer>;

package/utils/z-base32.js

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/noBitwiseOperators: ok */
 import { Alphabet } from './alphabet.js';
 import { toUint8Array } from './binary.js';
 import { assertDefined } from './type-guards.js';