@tstdl/base 0.93.34 → 0.93.36

package/source/utils/image.ts

@@ -0,0 +1,94 @@
+import { AssertionError } from '#/errors/assertion.error.js';
+import { firstValueFrom, fromEvent, map, race, switchMap, throwError } from 'rxjs';
+import { FactoryMap } from './factory-map.js';
+import { assertNotNullPass, isFunction, isNull } from './type-guards.js';
+
+const supportedImageDecoders = new FactoryMap<string, Promise<boolean>>(async (dataUrl) => _canDecodeImage(dataUrl));
+const supportedImageEncoders = new FactoryMap<string, boolean>((mimeType) => _canEncodeImage(mimeType));
+
+const webpData = 'data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoCAAEAAQAcJaQAA3AA/v3AgAA=';
+const avifData = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=';
+
+export async function canDecodeWebp(): Promise<boolean> {
+  return canDecodeImage(webpData);
+}
+
+export async function canDecodeAvif(): Promise<boolean> {
+  return canDecodeImage(avifData);
+}
+
+export async function canDecodeImage(dataUrl: string): Promise<boolean> {
+  return supportedImageDecoders.get(dataUrl);
+}
+
+export function canEncodeImageFormat(mimeType: string): boolean {
+  return supportedImageEncoders.get(mimeType);
+}
+
+async function _canDecodeImage(dataUrl: string): Promise<boolean> {
+  if (isFunction(globalThis.createImageBitmap)) {
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    return createImageBitmap(blob).then(() => true).catch(() => false);
+  }
+
+  const image = new Image();
+
+  const canPromise = firstValueFrom(race([
+    fromEvent(image, 'load').pipe(map(() => true)),
+    fromEvent(image, 'error').pipe(map(() => false))
+  ]));
+
+  image.src = dataUrl;
+
+  return canPromise;
+}
+
+function _canEncodeImage(mimeType: string): boolean {
+  return document.createElement('canvas').toDataURL(mimeType).startsWith(`data:${mimeType};`);
+}
+
+export async function compressImage(sourceImage: Blob, width: number, height: number, mimeType: string, quality: number): Promise<Blob> {
+  const canvas = document.createElement('canvas');
+
+  const objectUrl = URL.createObjectURL(sourceImage);
+
+  try {
+    const image = new Image();
+
+    const imagePromise = firstValueFrom(race([
+      fromEvent(image, 'load').pipe(map(() => undefined)),
+      fromEvent(image, 'error').pipe(switchMap((event: Event) => throwError(() => ((event as ErrorEvent).error as Error | undefined) ?? new Error((event as ErrorEvent).message))))
+    ]));
+
+    image.src = objectUrl;
+    await imagePromise;
+
+    const widthFactor = width / image.naturalWidth;
+    const heightFactor = height / image.naturalHeight;
+    const scaleFactor = Math.min(1, (widthFactor < heightFactor) ? widthFactor : heightFactor);
+    const targetWidth = width * scaleFactor;
+    const targetHeight = height * scaleFactor;
+
+    canvas.width = targetWidth;
+    canvas.height = targetHeight;
+
+    const context = assertNotNullPass(canvas.getContext('2d'), 'canvas 2d context not supported');
+    context.imageSmoothingQuality = 'high';
+    context.drawImage(image, 0, 0, targetWidth, targetHeight);
+
+    const resultBlob = await new Promise<Blob>((resolve, reject) => canvas.toBlob((blob) => {
+      if (isNull(blob)) {
+        reject(new AssertionError('could not render image'));
+        return;
+      }
+
+      resolve(blob);
+    }, mimeType, quality));
+
+    return resultBlob;
+  }
+  finally {
+    URL.revokeObjectURL(objectUrl);
+  }
+}

package/source/utils/index.ts

@@ -0,0 +1,60 @@
+export * from './alphabet.js';
+export * from './any-iterable-iterator.js';
+export * from './async-iterator-iterable-iterator.js';
+export * from './backoff.js';
+export * from './base64.js';
+export * from './benchmark.js';
+export * from './binary-search.js';
+export * from './binary.js';
+export * from './clone.js';
+export * from './comparison.js';
+export * from './compression.js';
+export * from './config-parser.js';
+export * from './crc32.js';
+export * from './cryptography.js';
+export * from './date-time.js';
+export * from './encoding.js';
+export * from './enum.js';
+export * from './equals.js';
+export * from './event-loop.js';
+export * from './factory-map.js';
+export * from './feedable-async-iterable.js';
+export * from './file-reader.js';
+export * from './format-error.js';
+export * from './format.js';
+export * from './helpers.js';
+export * from './html-link-utils.js';
+export * from './image.js';
+export * from './jwt.js';
+export * from './map.js';
+export * from './math.js';
+export * from './merge.js';
+export * from './middleware.js';
+export * from './moving-metric.js';
+export * from './noop.js';
+export * from './ordered-feedable-async-iterable.js';
+export * from './patch-worker.js';
+export * from './patterns.js';
+export * from './periodic-reporter.js';
+export * from './periodic-sampler.js';
+export * from './provider-function-iterable.js';
+export * from './proxy.js';
+export * from './random.js';
+export * from './reactive-value-to-signal.js';
+export * from './reflection.js';
+export * from './repl.js';
+export * from './set.js';
+export * from './singleton.js';
+export * from './sort.js';
+export * from './throw.js';
+export * from './timer.js';
+export * from './timing.js';
+export * from './try-chain.js';
+export * from './try-ignore.js';
+export * from './type-guards.js';
+export * from './type-of.js';
+export * from './type/index.js';
+export * from './units.js';
+export * from './url-builder.js';
+export * from './value-or-provider.js';
+export * from './z-base32.js';

package/source/utils/iterable-helpers/all.ts

@@ -0,0 +1,15 @@
+import type { Predicate } from './types.js';
+
+export function all<T>(iterable: Iterable<T>, predicate: Predicate<T> = (() => true)): boolean {
+  let index = 0;
+
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+
+    if (!matches) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/source/utils/iterable-helpers/any.ts

@@ -0,0 +1,15 @@
+import type { Predicate } from './types.js';
+
+export function any<T>(iterable: Iterable<T>, predicate: Predicate<T> = (() => true)): boolean {
+  let index = 0;
+
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+
+    if (matches) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/source/utils/iterable-helpers/assert.ts

@@ -0,0 +1,11 @@
+import { assert as assertHelper } from '../type-guards.js';
+import type { Predicate, TypePredicate } from './types.js';
+
+export function* assert<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate: TypePredicate<T, TPredicate> | Predicate<T>): IterableIterator<TPredicate> {
+  let index = 0;
+
+  for (const item of iterable) {
+    assertHelper(predicate(item, index++));
+    yield item as TPredicate;
+  }
+}

package/source/utils/iterable-helpers/batch.ts

@@ -0,0 +1,16 @@
+export function* batch<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]> {
+  let buffer: T[] = [];
+
+  for (const item of iterable) {
+    buffer.push(item);
+
+    if (buffer.length >= size) {
+      yield buffer;
+      buffer = [];
+    }
+  }
+
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}

package/source/utils/iterable-helpers/concat.ts

@@ -0,0 +1,5 @@
+export function* concat<T>(...iterables: Iterable<T>[]): IterableIterator<T> {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
+}

package/source/utils/iterable-helpers/default-if-empty.ts

@@ -0,0 +1,12 @@
+export function* defaultIfEmpty<T, TDefault>(iterable: Iterable<T>, defaultValue: TDefault): IterableIterator<T | TDefault> {
+  let empty = true;
+
+  for (const item of iterable) {
+    empty = false;
+    yield item;
+  }
+
+  if (empty) {
+    yield defaultValue;
+  }
+}

package/source/utils/iterable-helpers/deferred.ts

@@ -0,0 +1,3 @@
+export function* deferredIterable<T>(source: () => Iterable<T>): IterableIterator<T> {
+  yield* source();
+}

package/source/utils/iterable-helpers/difference.ts

@@ -0,0 +1,32 @@
+import { concat } from './concat.js';
+import { map } from './map.js';
+import type { IteratorFunction } from './types.js';
+
+export function* difference<T>(baseIterable: Iterable<T>, iterable: Iterable<T>, selector: IteratorFunction<T, any> = (item) => item): IterableIterator<T> {
+  const diffItems = map(iterable, selector);
+  const diffItemsSet = new Set(diffItems);
+
+  let index = 0;
+  for (const item of baseIterable) {
+    const selected = selector(item, index++);
+
+    if (!diffItemsSet.has(selected)) {
+      yield item;
+    }
+  }
+}
+
+export function* differenceMany<T>(baseIterable: Iterable<T>, iterables: Iterable<T>[], selector: IteratorFunction<T, any> = (item) => item): IterableIterator<T> {
+  const items = concat(...iterables);
+  const diffItems = map(items, selector);
+  const diffItemsSet = new Set(diffItems);
+
+  let index = 0;
+  for (const item of baseIterable) {
+    const selected = selector(item, index++);
+
+    if (!diffItemsSet.has(selected)) {
+      yield item;
+    }
+  }
+}

package/source/utils/iterable-helpers/distinct.ts

@@ -0,0 +1,15 @@
+import type { IteratorFunction } from './types.js';
+
+export function* distinct<TIn>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, any> = (item) => item): IterableIterator<TIn> {
+  const items = new Set();
+  let index = 0;
+
+  for (const item of iterable) {
+    const selection = selector(item, index++);
+
+    if (!items.has(selection)) {
+      items.add(selection);
+      yield item;
+    }
+  }
+}

package/source/utils/iterable-helpers/drain.ts

@@ -0,0 +1,5 @@
+export function drain(iterable: Iterable<any>): void {
+  for (const _ of iterable) {
+    // just drain
+  }
+}

package/source/utils/iterable-helpers/filter.ts

@@ -0,0 +1,13 @@
+import type { Predicate, TypePredicate } from './types.js';
+
+export function* filter<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate: Predicate<T> | TypePredicate<T, TPredicate>): IterableIterator<TPredicate> {
+  let index = 0;
+
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+
+    if (matches) {
+      yield item as TPredicate;
+    }
+  }
+}

package/source/utils/iterable-helpers/first-or-default.ts

@@ -0,0 +1,12 @@
+import { filter } from './filter.js';
+import type { Predicate, TypePredicate } from './types.js';
+
+export function firstOrDefault<T, D, TPredicate extends T = T>(iterable: Iterable<T>, defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D {
+  const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
+
+  for (const item of source) {
+    return item as TPredicate;
+  }
+
+  return defaultValue;
+}

package/source/utils/iterable-helpers/first.ts

@@ -0,0 +1,12 @@
+import { filter } from './filter.js';
+import type { Predicate, TypePredicate } from './types.js';
+
+export function first<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate {
+  const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
+
+  for (const item of source) {
+    return item as TPredicate;
+  }
+
+  throw new Error('iterable was either empty or no element matched predicate');
+}

package/source/utils/iterable-helpers/for-each.ts

@@ -0,0 +1,9 @@
+import type { IteratorFunction } from './types.js';
+
+export function forEach<T>(iterable: Iterable<T>, func: IteratorFunction<T, void>): void {
+  let index = 0;
+
+  for (const item of iterable) {
+    func(item, index++);
+  }
+}

package/source/utils/iterable-helpers/group-single.ts

@@ -0,0 +1,8 @@
+import { groupToSingleMap } from './group-to-single-map.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
+
+export function groupSingle<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): IterableIterator<[TGroup, TIn]>;
+export function groupSingle<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn]>;
+export function groupSingle<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup, TIn]> {
+  return groupToSingleMap<TIn, TGroup>(iterable, ...selectors)[Symbol.iterator]();
+}

package/source/utils/iterable-helpers/group-to-map.ts

@@ -0,0 +1,40 @@
+import { MultiKeyMap } from '#/data-structures/multi-key-map.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
+
+export function groupToMap<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): Map<TGroup, TIn[]>;
+export function groupToMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]>;
+export function groupToMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup, TIn[]> {
+  let index = 0;
+
+  if (selectors.length == 1) {
+    const selector = selectors[0];
+    const map = new Map<TGroup[0], TIn[]>();
+
+    for (const item of iterable) {
+      const groupKey = selector(item, index++) as TGroup[0];
+
+      if (!map.has(groupKey)) {
+        map.set(groupKey, []);
+      }
+
+      map.get(groupKey)!.push(item);
+    }
+
+    return map;
+  }
+
+  const map = new MultiKeyMap<TGroup, TIn[]>();
+
+  for (const item of iterable) {
+    const groupKeys = selectors.map((selector): any => selector(item, index)) as TGroup;
+    index++;
+
+    if (!map.has(groupKeys)) {
+      map.set(groupKeys, []);
+    }
+
+    map.get(groupKeys)!.push(item);
+  }
+
+  return map.toMap();
+}

package/source/utils/iterable-helpers/group-to-single-map.ts

@@ -0,0 +1,40 @@
+import { MultiKeyMap } from '#/data-structures/multi-key-map.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
+
+export function groupToSingleMap<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): Map<TGroup, TIn>;
+export function groupToSingleMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn>;
+export function groupToSingleMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup, TIn> {
+  let index = 0;
+
+  if (selectors.length == 1) {
+    const selector = selectors[0];
+    const map = new Map<TGroup[0], TIn>();
+
+    for (const item of iterable) {
+      const groupKey = selector(item, index++) as TGroup[0];
+
+      if (map.has(groupKey)) {
+        throw new Error(`Group ${String(groupKey)} has more than one item.`);
+      }
+
+      map.set(groupKey, item);
+    }
+
+    return map;
+  }
+
+  const map = new MultiKeyMap<TGroup, TIn>();
+
+  for (const item of iterable) {
+    const groupKeys = selectors.map((selector): any => selector(item, index)) as TGroup; // eslint-disable-line @typescript-eslint/no-loop-func
+    index++;
+
+    if (map.has(groupKeys)) {
+      throw new Error(`Group [${groupKeys.map((key) => String(key)).join(', ')}] has more than one item.`);
+    }
+
+    map.set(groupKeys, item);
+  }
+
+  return map.toMap();
+}

package/source/utils/iterable-helpers/group.ts

@@ -0,0 +1,8 @@
+import { groupToMap } from './group-to-map.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
+
+export function group<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): IterableIterator<[TGroup, TIn[]]>;
+export function group<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]]>;
+export function group<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup, TIn[]]> {
+  return groupToMap<TIn, TGroup>(iterable, ...selectors)[Symbol.iterator]();
+}

package/source/utils/iterable-helpers/includes.ts

@@ -0,0 +1,5 @@
+import { any } from './any.js';
+
+export function includes<T>(iterable: Iterable<T>, value: T): boolean {
+  return any(iterable, (item) => item == value);
+}

package/source/utils/iterable-helpers/index.ts

@@ -0,0 +1,39 @@
+export * from './all.js';
+export * from './any.js';
+export * from './assert.js';
+export * from './batch.js';
+export * from './concat.js';
+export * from './default-if-empty.js';
+export * from './deferred.js';
+export * from './difference.js';
+export * from './distinct.js';
+export * from './drain.js';
+export * from './filter.js';
+export * from './first-or-default.js';
+export * from './first.js';
+export * from './for-each.js';
+export * from './group-single.js';
+export * from './group-to-map.js';
+export * from './group-to-single-map.js';
+export * from './group.js';
+export * from './includes.js';
+export * from './is-iterable.js';
+export * from './last-or-default.js';
+export * from './last.js';
+export * from './map-many.js';
+export * from './map.js';
+export * from './materialize.js';
+export * from './metadata.js';
+export * from './pairwise.js';
+export * from './range.js';
+export * from './reduce.js';
+export * from './single-or-default.js';
+export * from './single.js';
+export * from './skip.js';
+export * from './sort.js';
+export * from './take-until.js';
+export * from './take-while.js';
+export * from './take.js';
+export * from './tap.js';
+export * from './types.js';
+export * from './while.js';

package/source/utils/iterable-helpers/is-iterable.ts

@@ -0,0 +1,11 @@
+import type { AnyIterable } from '../any-iterable-iterator.js';
+import { isFunction, isNotNullOrUndefined } from '../type-guards.js';
+
+export function isIterable<T>(value: unknown): value is Iterable<T> {
+  return isNotNullOrUndefined(value) && isFunction((value as Iterable<T>)[Symbol.iterator]);
+}
+
+export function isIterableIterator<T>(anyIterable: AnyIterable<T>): anyIterable is IterableIterator<T>;
+export function isIterableIterator<T = any>(value: any): value is IterableIterator<T> {
+  return isIterable(value) && isFunction((value as Partial<IterableIterator<any>>).next);
+}

package/source/utils/iterable-helpers/last-or-default.ts

@@ -0,0 +1,20 @@
+import { filter } from './filter.js';
+import type { Predicate, TypePredicate } from './types.js';
+
+export function lastOrDefault<T, D, TPredicate extends T = T>(iterable: Iterable<T>, defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D {
+  const source = (predicate == undefined) ? iterable : filter<T, TPredicate>(iterable, predicate);
+
+  let hasLastItem = false;
+  let lastItem: T;
+
+  for (const item of source) {
+    hasLastItem = true;
+    lastItem = item;
+  }
+
+  if (hasLastItem) {
+    return lastItem! as T as TPredicate;
+  }
+
+  return defaultValue;
+}

package/source/utils/iterable-helpers/last.ts

@@ -0,0 +1,20 @@
+import { filter } from './filter.js';
+import type { Predicate, TypePredicate } from './types.js';
+
+export function last<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate {
+  const source = (predicate == undefined) ? iterable : filter<T, TPredicate>(iterable, predicate);
+
+  let hasLastItem = false;
+  let lastItem: T;
+
+  for (const item of source) {
+    hasLastItem = true;
+    lastItem = item;
+  }
+
+  if (hasLastItem) {
+    return lastItem! as T as TPredicate; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+  }
+
+  throw new Error('iterable was either empty or no element matched predicate');
+}

package/source/utils/iterable-helpers/map-many.ts

@@ -0,0 +1,10 @@
+import type { IteratorFunction } from './types.js';
+
+export function* mapMany<TIn, TOut>(iterable: Iterable<TIn>, mapper: IteratorFunction<TIn, Iterable<TOut>>): IterableIterator<TOut> {
+  let index = 0;
+
+  for (const item of iterable) {
+    const mapped = mapper(item, index++);
+    yield* mapped;
+  }
+}

package/source/utils/iterable-helpers/map.ts

@@ -0,0 +1,10 @@
+import type { IteratorFunction } from './types.js';
+
+export function* map<TIn, TOut>(iterable: Iterable<TIn>, mapper: IteratorFunction<TIn, TOut>): IterableIterator<TOut> {
+  let index = 0;
+
+  for (const item of iterable) {
+    const mapped = mapper(item, index++);
+    yield mapped;
+  }
+}

package/source/utils/iterable-helpers/materialize.ts

@@ -0,0 +1,3 @@
+export function materialize<T>(iterable: Iterable<T>): Iterable<T> {
+  return [...iterable];
+}

package/source/utils/iterable-helpers/metadata.ts

@@ -0,0 +1,25 @@
+import type { IterableItemMetadata } from './types.js';
+
+export function* metadata<T>(iterable: Iterable<T>): IterableIterator<IterableItemMetadata<T>> {
+  let index = 0;
+  let isFirst = true;
+
+  let hasPrevious = false;
+  let previous: T;
+
+  for (const item of iterable) {
+    if (hasPrevious) {
+      yield { index: index++, isFirst, isLast: false, value: previous! };
+      isFirst = false;
+    }
+    else {
+      hasPrevious = true;
+    }
+
+    previous = item;
+  }
+
+  if (hasPrevious) {
+    yield { index: index++, isFirst, isLast: true, value: previous! };
+  }
+}

package/source/utils/iterable-helpers/pairwise.ts

@@ -0,0 +1,15 @@
+export function* pairwise<T>(iterable: Iterable<T>): IterableIterator<[left: T, right: T]> {
+  let hasPrevious = false;
+  let previous: T;
+
+  for (const item of iterable) {
+    if (hasPrevious) {
+      yield [previous!, item];
+    }
+    else {
+      hasPrevious = true;
+    }
+
+    previous = item;
+  }
+}

package/source/utils/iterable-helpers/range.ts

@@ -0,0 +1,5 @@
+export function* range(fromInclusive: number, toInclusive: number): IterableIterator<number> {
+  for (let i = fromInclusive; i <= toInclusive; i++) {
+    yield i;
+  }
+}

package/source/utils/iterable-helpers/reduce.ts

@@ -0,0 +1,17 @@
+import type { Reducer } from './types.js';
+
+export function reduce<T, U>(iterable: Iterable<T>, reducer: Reducer<T, U>, initialValue?: U): U {
+  let accumulator: T | U | undefined = initialValue;
+  let index = 0;
+
+  for (const currentValue of iterable) {
+    if (accumulator == undefined) {
+      accumulator = currentValue;
+    }
+    else {
+      accumulator = reducer(accumulator as U, currentValue, index++);
+    }
+  }
+
+  return accumulator as U;
+}