@mathscapes/iterflow 1.0.0-rc1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mathscapes Research
+
+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,154 @@
+# Iterflow
+
+Lazy iterators with built-in statistics and windowing. Zero dependencies.
+
+```typescript
+import { iter } from '@mathscapes/iterflow';
+
+// Rolling average of stock prices
+const prices = [100, 102, 101, 105, 107, 110];
+iter(prices)
+  .window(5)
+  .map(w => iter(w).mean())
+  .toArray();
+
+// Process millions of records with constant memory
+function* hugeDataset() {
+  for (let i = 0; i < 1000000; i++) {
+    yield { valid: i % 2 === 0, value: i };
+  }
+}
+iter(hugeDataset())
+  .filter(x => x.valid)
+  .map(x => x.value)
+  .take(1000)
+  .sum();
+```
+
+## Install
+
+```bash
+npm install @mathscapes/iterflow
+```
+
+## Why?
+
+Native arrays are eager. Native Iterator Helpers (ES2025) add lazy ops, but no statistics or windowing.
+
+## API Reference
+
+### Factory Function
+
+- `iter<T>(src: Iterable<T>): Iterflow<T>` Wrap any iterable.
+
+---
+
+### Transform Methods
+
+Transform methods return a new `Iterflow<T>` and are lazily evaluated. No computation happens until a terminal method is called.
+
+- `.map<U>(fn: (v: T, i: number) => U): Iterflow<U>` Transform each element.
+- `.filter(fn: (v: T, i: number) => boolean): Iterflow<T>` Keep matching elements.
+- `.flatMap<U>(fn: (v: T, i: number) => Iterable<U>): Iterflow<U>` Map and flatten.
+- `.take(n: number): Iterflow<T>` First n elements.
+- `.drop(n: number): Iterflow<T>` Skip first n elements.
+- `.takeWhile(fn: (v: T, i: number) => boolean): Iterflow<T>` Take while predicate is true.
+- `.dropWhile(fn: (v: T, i: number) => boolean): Iterflow<T>` Skip while predicate is true.
+- `.distinct(): Iterflow<T>` Remove duplicates.
+- `.enumerate(): Iterflow<[number, T]>` Yield [index, value] pairs.
+- `.concat<U>(...others: Iterable<U>[]): Iterflow<T | U>` Append iterables.
+- `.window(size: number): Iterflow<T[]>` Sliding windows.
+- `.chunk(size: number): Iterflow<T[]>` Fixed-size chunks.
+
+---
+
+### Terminal Methods
+
+Terminal methods consume the iterator and return concrete values.
+
+- `.toArray(): T[]` Collect to array.
+- `.reduce<U>(fn: (acc: U, v: T, i: number) => U, init: U): U` Fold to single value.
+- `.find(fn: (v: T, i: number) => boolean): T | undefined` First matching element.
+- `.forEach(fn: (v: T, i: number) => void): void` Execute function for each.
+- `.first(): T | undefined` First element.
+- `.last(): T | undefined` Last element.
+- `.count(): number` Count elements.
+- `.some(fn: (v: T, i: number) => boolean): boolean` Any match?
+- `.every(fn: (v: T, i: number) => boolean): boolean` All match?
+
+---
+
+### Statistical Methods
+
+Statistical methods only work on `Iterflow<number>` and throw `EmptySequenceError` on empty sequences.
+
+- `.sum(): number` Sum.
+- `.mean(): number` Arithmetic mean.
+- `.median(): number` Median (50th percentile).
+- `.min(): number` Minimum.
+- `.max(): number` Maximum.
+- `.variance(): number` Population variance.
+
+---
+
+### Standalone Functions
+
+```typescript
+import { sum, mean, median, min, max, variance } from '@mathscapes/iterflow';
+```
+
+- `sum(src: Iterable<number>): number`
+- `mean(src: Iterable<number>): number`
+- `median(src: Iterable<number>): number`
+- `min(src: Iterable<number>): number`
+- `max(src: Iterable<number>): number`
+- `variance(src: Iterable<number>): number`
+
+---
+
+### Error Classes
+
+- `IterflowError` Base error class.
+- `EmptySequenceError` Thrown by statistical methods on empty sequences. Has `op: string` property.
+
+---
+
+### Type Exports
+
+```typescript
+import type { Predicate, Mapper, Reducer, FlatMapper } from '@mathscapes/iterflow';
+```
+
+- `Predicate<T>` = `(v: T, i: number) => boolean`
+- `Mapper<T, U>` = `(v: T, i: number) => U`
+- `Reducer<T, U>` = `(acc: U, v: T, i: number) => U`
+- `FlatMapper<T, U>` = `(v: T, i: number) => Iterable<U>`
+
+---
+
+### Utility Functions
+
+- `isIterable(v: unknown): v is Iterable<unknown>` Type guard for iterables.
+
+---
+
+## Benchmarks
+
+Performance benchmarks comparing iterflow against Lodash, iter-ops, RxJS, and native methods are available in the [`benchmarks/`](benchmarks/) directory. See [benchmarks/README.md](benchmarks/README.md) for reproduction instructions.
+
+## Examples
+
+See the [`examples/`](examples/) directory for examples comparing iterflow with native JavaScript, Lodash, and RxJS.
+
+## TypeScript
+
+Full type inference. Statistical methods are constrained to `Iterflow<number>`:
+
+```typescript
+iter(['a', 'b', 'c']).sum()  // TypeScript error
+iter([1, 2, 3]).sum()        // OK: number
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,478 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EmptySequenceError: () => EmptySequenceError,
+  Iterflow: () => Iterflow,
+  IterflowError: () => IterflowError,
+  isIterable: () => isIterable,
+  iter: () => iter,
+  max: () => max,
+  mean: () => mean,
+  median: () => median,
+  min: () => min,
+  sum: () => sum,
+  variance: () => variance
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var IterflowError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "IterflowError";
+  }
+};
+var EmptySequenceError = class extends IterflowError {
+  constructor(op) {
+    super(`Cannot compute ${op} of empty sequence`);
+    this.op = op;
+    this.name = "EmptySequenceError";
+  }
+};
+var isIterable = (v) => v != null && typeof v === "object" && Symbol.iterator in v;
+
+// src/internal.ts
+function makeTransform(src, generator) {
+  return {
+    *[Symbol.iterator]() {
+      yield* generator(src);
+    }
+  };
+}
+function assertNonEmpty(count2, op) {
+  if (count2 === 0) {
+    throw new EmptySequenceError(op);
+  }
+}
+function assertHasValue(has, op) {
+  if (!has) {
+    throw new EmptySequenceError(op);
+  }
+}
+function validateInteger(n, param) {
+  if (!Number.isFinite(n)) {
+    throw new RangeError(`${param} must be finite`);
+  }
+  if (!Number.isInteger(n)) {
+    throw new TypeError(`${param} must be an integer`);
+  }
+}
+function validateNonNegative(n, param) {
+  validateInteger(n, param);
+  if (n < 0) {
+    throw new RangeError(`${param} must be non-negative`);
+  }
+}
+function validatePositive(n, param) {
+  validateInteger(n, param);
+  if (n <= 0) {
+    throw new RangeError(`${param} must be positive`);
+  }
+}
+
+// src/transforms.ts
+function map(src, fn) {
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) yield fn(v, i++);
+  });
+}
+function flatMap(src, fn) {
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) yield* fn(v, i++);
+  });
+}
+function enumerate(src) {
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) yield [i++, v];
+  });
+}
+function filter(src, fn) {
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) if (fn(v, i++)) yield v;
+  });
+}
+function take(src, n) {
+  validateNonNegative(n, "Count");
+  return makeTransform(src, function* (s) {
+    let remaining = n;
+    for (const v of s) {
+      if (remaining-- <= 0) break;
+      yield v;
+    }
+  });
+}
+function drop(src, n) {
+  validateNonNegative(n, "Count");
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) if (i++ >= n) yield v;
+  });
+}
+function takeWhile(src, fn) {
+  return makeTransform(src, function* (s) {
+    let i = 0;
+    for (const v of s) {
+      if (!fn(v, i++)) break;
+      yield v;
+    }
+  });
+}
+function dropWhile(src, fn) {
+  return makeTransform(src, function* (s) {
+    let i = 0, dropping = true;
+    for (const v of s) {
+      if (dropping && !fn(v, i)) dropping = false;
+      if (!dropping) yield v;
+      i++;
+    }
+  });
+}
+function distinct(src) {
+  return makeTransform(src, function* (s) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const v of s) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        yield v;
+      }
+    }
+  });
+}
+function window(src, size) {
+  validatePositive(size, "Window size");
+  return makeTransform(src, function* (s) {
+    const buf = [];
+    for (const v of s) {
+      buf.push(v);
+      if (buf.length === size) {
+        yield buf.slice();
+        buf.shift();
+      }
+    }
+  });
+}
+function chunk(src, size) {
+  validatePositive(size, "Chunk size");
+  return makeTransform(src, function* (s) {
+    let batch = [];
+    for (const v of s) {
+      batch.push(v);
+      if (batch.length === size) {
+        yield batch;
+        batch = [];
+      }
+    }
+    if (batch.length) yield batch;
+  });
+}
+function concat(src, ...others) {
+  return makeTransform(src, function* (s) {
+    yield* s;
+    for (const o of others) yield* o;
+  });
+}
+
+// src/terminals.ts
+function toArray(src) {
+  return Array.from(src);
+}
+function reduce(src, fn, init) {
+  let acc = init, i = 0;
+  for (const v of src) acc = fn(acc, v, i++);
+  return acc;
+}
+function find(src, fn) {
+  let i = 0;
+  for (const v of src) if (fn(v, i++)) return v;
+  return void 0;
+}
+function forEach(src, fn) {
+  let i = 0;
+  for (const v of src) fn(v, i++);
+}
+function first(src) {
+  for (const v of src) return v;
+  return void 0;
+}
+function last(src) {
+  if (Array.isArray(src)) return src[src.length - 1];
+  let last2;
+  for (const v of src) last2 = v;
+  return last2;
+}
+function count(src) {
+  if (Array.isArray(src)) return src.length;
+  let n = 0;
+  for (const _ of src) n++;
+  return n;
+}
+function some(src, fn) {
+  let i = 0;
+  for (const v of src) if (fn(v, i++)) return true;
+  return false;
+}
+function every(src, fn) {
+  let i = 0;
+  for (const v of src) if (!fn(v, i++)) return false;
+  return true;
+}
+var sum = (src) => {
+  let total = 0, count2 = 0;
+  for (const v of src) {
+    total += v;
+    count2++;
+  }
+  assertNonEmpty(count2, "sum");
+  return total;
+};
+var mean = (src) => {
+  let total = 0, count2 = 0;
+  for (const v of src) {
+    total += v;
+    count2++;
+  }
+  assertNonEmpty(count2, "mean");
+  return total / count2;
+};
+function partition(arr, left, right) {
+  const pivot = arr[right];
+  let i = left;
+  for (let j = left; j < right; j++) {
+    if (arr[j] < pivot) {
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+      i++;
+    }
+  }
+  [arr[i], arr[right]] = [arr[right], arr[i]];
+  return i;
+}
+function quickselect(arr, k) {
+  let left = 0;
+  let right = arr.length - 1;
+  while (left < right) {
+    const pivotIndex = partition(arr, left, right);
+    if (pivotIndex === k) {
+      return arr[k];
+    } else if (pivotIndex > k) {
+      right = pivotIndex - 1;
+    } else {
+      left = pivotIndex + 1;
+    }
+  }
+  return arr[left];
+}
+var median = (src) => {
+  const arr = Array.from(src);
+  assertNonEmpty(arr.length, "median");
+  const mid = arr.length >> 1;
+  if (arr.length % 2) {
+    return quickselect(arr, mid);
+  } else {
+    const upper = quickselect(arr, mid);
+    const lower = quickselect(arr, mid - 1);
+    return (lower + upper) / 2;
+  }
+};
+var min = (src) => {
+  let result = Infinity, has = false;
+  for (const v of src) {
+    if (v < result) result = v;
+    has = true;
+  }
+  assertHasValue(has, "min");
+  return result;
+};
+var max = (src) => {
+  let result = -Infinity, has = false;
+  for (const v of src) {
+    if (v > result) result = v;
+    has = true;
+  }
+  assertHasValue(has, "max");
+  return result;
+};
+var variance = (src) => {
+  let count2 = 0;
+  let mean2 = 0;
+  let M2 = 0;
+  for (const x of src) {
+    count2++;
+    const delta = x - mean2;
+    mean2 += delta / count2;
+    const delta2 = x - mean2;
+    M2 += delta * delta2;
+  }
+  assertNonEmpty(count2, "variance");
+  return M2 / count2;
+};
+
+// src/index.ts
+var Iterflow = class _Iterflow {
+  constructor(src) {
+    this.src = src;
+  }
+  [Symbol.iterator]() {
+    return this.src[Symbol.iterator]();
+  }
+  // Transforms
+  map(fn) {
+    return new _Iterflow(map(this.src, fn));
+  }
+  filter(fn) {
+    return new _Iterflow(filter(this.src, fn));
+  }
+  flatMap(fn) {
+    return new _Iterflow(flatMap(this.src, fn));
+  }
+  take(n) {
+    return new _Iterflow(take(this.src, n));
+  }
+  drop(n) {
+    return new _Iterflow(drop(this.src, n));
+  }
+  takeWhile(fn) {
+    return new _Iterflow(takeWhile(this.src, fn));
+  }
+  dropWhile(fn) {
+    return new _Iterflow(dropWhile(this.src, fn));
+  }
+  distinct() {
+    return new _Iterflow(distinct(this.src));
+  }
+  /**
+   * Yield [index, value] pairs.
+   */
+  enumerate() {
+    return new _Iterflow(enumerate(this.src));
+  }
+  /**
+   * Append additional iterables to the sequence.
+   */
+  concat(...others) {
+    return new _Iterflow(concat(this.src, ...others));
+  }
+  /**
+   * Create sliding windows of the specified size.
+   */
+  window(size) {
+    return new _Iterflow(window(this.src, size));
+  }
+  /**
+   * Split the sequence into fixed-size chunks.
+   */
+  chunk(size) {
+    return new _Iterflow(chunk(this.src, size));
+  }
+  // Terminals
+  toArray() {
+    return toArray(this.src);
+  }
+  reduce(fn, init) {
+    return reduce(this.src, fn, init);
+  }
+  find(fn) {
+    return find(this.src, fn);
+  }
+  forEach(fn) {
+    forEach(this.src, fn);
+  }
+  first() {
+    return first(this.src);
+  }
+  last() {
+    return last(this.src);
+  }
+  count() {
+    return count(this.src);
+  }
+  some(fn) {
+    return some(this.src, fn);
+  }
+  every(fn) {
+    return every(this.src, fn);
+  }
+  // Stats (numbers only)
+  /**
+   * Calculate the sum of all numbers.
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  sum() {
+    return sum(this.src);
+  }
+  /**
+   * Calculate the arithmetic mean.
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  mean() {
+    return mean(this.src);
+  }
+  /**
+   * Calculate the median (50th percentile).
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  median() {
+    return median(this.src);
+  }
+  /**
+   * Find the minimum value.
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  min() {
+    return min(this.src);
+  }
+  /**
+   * Find the maximum value.
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  max() {
+    return max(this.src);
+  }
+  /**
+   * Calculate the population variance.
+   * @throws {EmptySequenceError} If the sequence is empty.
+   */
+  variance() {
+    return variance(this.src);
+  }
+};
+function iter(src) {
+  return new Iterflow(src);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmptySequenceError,
+  Iterflow,
+  IterflowError,
+  isIterable,
+  iter,
+  max,
+  mean,
+  median,
+  min,
+  sum,
+  variance
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core.ts","../src/internal.ts","../src/transforms.ts","../src/terminals.ts"],"sourcesContent":["/**\n * iterflow - Lazy iterators with statistics and windowing\n * @packageDocumentation\n */\n\nimport type { Predicate, Mapper, Reducer, FlatMapper } from './core.js';\nimport * as transforms from './transforms.js';\nimport * as terminals from './terminals.js';\n\n// Iterflow class\nexport class Iterflow<T> implements Iterable<T> {\n  constructor(private readonly src: Iterable<T>) {}\n\n  [Symbol.iterator](): Iterator<T> {\n    return this.src[Symbol.iterator]();\n  }\n\n  // Transforms\n  map<U>(fn: Mapper<T, U>): Iterflow<U> {\n    return new Iterflow(transforms.map(this.src, fn));\n  }\n\n  filter(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.filter(this.src, fn));\n  }\n\n  flatMap<U>(fn: FlatMapper<T, U>): Iterflow<U> {\n    return new Iterflow(transforms.flatMap(this.src, fn));\n  }\n\n  take(n: number): Iterflow<T> {\n    return new Iterflow(transforms.take(this.src, n));\n  }\n\n  drop(n: number): Iterflow<T> {\n    return new Iterflow(transforms.drop(this.src, n));\n  }\n\n  takeWhile(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.takeWhile(this.src, fn));\n  }\n\n  dropWhile(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.dropWhile(this.src, fn));\n  }\n\n  distinct(): Iterflow<T> {\n    return new Iterflow(transforms.distinct(this.src));\n  }\n\n  /**\n   * Yield [index, value] pairs.\n   */\n  enumerate(): Iterflow<[number, T]> {\n    return new Iterflow(transforms.enumerate(this.src));\n  }\n\n  /**\n   * Append additional iterables to the sequence.\n   */\n  concat<U>(...others: Iterable<U>[]): Iterflow<T | U> {\n    return new Iterflow(transforms.concat(this.src, ...others));\n  }\n\n  /**\n   * Create sliding windows of the specified size.\n   */\n  window(size: number): Iterflow<T[]> {\n    return new Iterflow(transforms.window(this.src, size));\n  }\n\n  /**\n   * Split the sequence into fixed-size chunks.\n   */\n  chunk(size: number): Iterflow<T[]> {\n    return new Iterflow(transforms.chunk(this.src, size));\n  }\n\n  // Terminals\n  toArray(): T[] {\n    return terminals.toArray(this.src);\n  }\n\n  reduce<U>(fn: Reducer<T, U>, init: U): U {\n    return terminals.reduce(this.src, fn, init);\n  }\n\n  find(fn: Predicate<T>): T | undefined {\n    return terminals.find(this.src, fn);\n  }\n\n  forEach(fn: (v: T, i: number) => void): void {\n    terminals.forEach(this.src, fn);\n  }\n\n  first(): T | undefined {\n    return terminals.first(this.src);\n  }\n\n  last(): T | undefined {\n    return terminals.last(this.src);\n  }\n\n  count(): number {\n    return terminals.count(this.src);\n  }\n\n  some(fn: Predicate<T>): boolean {\n    return terminals.some(this.src, fn);\n  }\n\n  every(fn: Predicate<T>): boolean {\n    return terminals.every(this.src, fn);\n  }\n\n  // Stats (numbers only)\n  /**\n   * Calculate the sum of all numbers.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  sum(this: Iterflow<number>): number {\n    return terminals.sum(this.src);\n  }\n\n  /**\n   * Calculate the arithmetic mean.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  mean(this: Iterflow<number>): number {\n    return terminals.mean(this.src);\n  }\n\n  /**\n   * Calculate the median (50th percentile).\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  median(this: Iterflow<number>): number {\n    return terminals.median(this.src);\n  }\n\n  /**\n   * Find the minimum value.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  min(this: Iterflow<number>): number {\n    return terminals.min(this.src);\n  }\n\n  /**\n   * Find the maximum value.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  max(this: Iterflow<number>): number {\n    return terminals.max(this.src);\n  }\n\n  /**\n   * Calculate the population variance.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  variance(this: Iterflow<number>): number {\n    return terminals.variance(this.src);\n  }\n}\n\n// Factory function\nexport function iter<T>(src: Iterable<T>): Iterflow<T> {\n  return new Iterflow(src);\n}\n\n// Re-exports from other modules\nexport { IterflowError, EmptySequenceError, isIterable } from './core.js';\nexport type { Predicate, Mapper, Reducer, FlatMapper } from './core.js';\nexport { sum, mean, median, min, max, variance } from './terminals.js';\n","// Error classes\n/**\n * Base error class for all iterflow errors.\n */\nexport class IterflowError extends Error {\n  constructor(msg: string) {\n    super(msg);\n    this.name = 'IterflowError';\n  }\n}\n\n/**\n * Thrown by statistical methods when called on empty sequences.\n */\nexport class EmptySequenceError extends IterflowError {\n  constructor(readonly op: string) {\n    super(`Cannot compute ${op} of empty sequence`);\n    this.name = 'EmptySequenceError';\n  }\n}\n\n// Type definitions\nexport type Predicate<T> = (v: T, i: number) => boolean;\nexport type Mapper<T, U> = (v: T, i: number) => U;\nexport type Reducer<T, U> = (acc: U, v: T, i: number) => U;\nexport type FlatMapper<T, U> = (v: T, i: number) => Iterable<U>;\n\n// Utilities\n/**\n * Type guard to check if a value is iterable.\n */\nexport const isIterable = (v: unknown): v is Iterable<unknown> =>\n  v != null && typeof v === 'object' && Symbol.iterator in v;\n","import { EmptySequenceError } from './core.js';\n\n// Generator factory\nexport function makeTransform<T, U>(\n  src: Iterable<T>,\n  generator: (src: Iterable<T>) => Generator<U>\n): Iterable<U> {\n  return {\n    *[Symbol.iterator]() {\n      yield* generator(src);\n    }\n  };\n}\n\n// Iteration helpers\nexport function assertNonEmpty(count: number, op: string): void {\n  if (count === 0) {\n    throw new EmptySequenceError(op);\n  }\n}\n\nexport function assertHasValue(has: boolean, op: string): void {\n  if (!has) {\n    throw new EmptySequenceError(op);\n  }\n}\n\n// Validation helpers\nexport function validateInteger(n: number, param: string): void {\n  if (!Number.isFinite(n)) {\n    throw new RangeError(`${param} must be finite`);\n  }\n  if (!Number.isInteger(n)) {\n    throw new TypeError(`${param} must be an integer`);\n  }\n}\n\nexport function validateNonNegative(n: number, param: string): void {\n  validateInteger(n, param);\n  if (n < 0) {\n    throw new RangeError(`${param} must be non-negative`);\n  }\n}\n\nexport function validatePositive(n: number, param: string): void {\n  validateInteger(n, param);\n  if (n <= 0) {\n    throw new RangeError(`${param} must be positive`);\n  }\n}\n","import type { Predicate, Mapper, FlatMapper } from './core.js';\nimport { makeTransform, validateNonNegative, validatePositive } from './internal.js';\n\n// Mapping transforms\nexport function map<T, U>(src: Iterable<T>, fn: Mapper<T, U>): Iterable<U> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield fn(v, i++);\n  });\n}\n\nexport function flatMap<T, U>(src: Iterable<T>, fn: FlatMapper<T, U>): Iterable<U> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield* fn(v, i++);\n  });\n}\n\nexport function enumerate<T>(src: Iterable<T>): Iterable<[number, T]> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield [i++, v];\n  });\n}\n\n// Filtering transforms\nexport function filter<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) if (fn(v, i++)) yield v;\n  });\n}\n\nexport function take<T>(src: Iterable<T>, n: number): Iterable<T> {\n  validateNonNegative(n, 'Count');\n  return makeTransform(src, function* (s) {\n    let remaining = n;\n    for (const v of s) {\n      if (remaining-- <= 0) break;\n      yield v;\n    }\n  });\n}\n\nexport function drop<T>(src: Iterable<T>, n: number): Iterable<T> {\n  validateNonNegative(n, 'Count');\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) if (i++ >= n) yield v;\n  });\n}\n\nexport function takeWhile<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) {\n      if (!fn(v, i++)) break;\n      yield v;\n    }\n  });\n}\n\nexport function dropWhile<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0, dropping = true;\n    for (const v of s) {\n      if (dropping && !fn(v, i)) dropping = false;\n      if (!dropping) yield v;\n      i++;\n    }\n  });\n}\n\nexport function distinct<T>(src: Iterable<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    const seen = new Set<T>();\n    for (const v of s) {\n      if (!seen.has(v)) { seen.add(v); yield v; }\n    }\n  });\n}\n\n// Windowing transforms\nexport function window<T>(src: Iterable<T>, size: number): Iterable<T[]> {\n  validatePositive(size, 'Window size');\n  return makeTransform(src, function* (s) {\n    const buf: T[] = [];\n    for (const v of s) {\n      buf.push(v);\n      if (buf.length === size) { yield buf.slice(); buf.shift(); }\n    }\n  });\n}\n\nexport function chunk<T>(src: Iterable<T>, size: number): Iterable<T[]> {\n  validatePositive(size, 'Chunk size');\n  return makeTransform(src, function* (s) {\n    let batch: T[] = [];\n    for (const v of s) {\n      batch.push(v);\n      if (batch.length === size) { yield batch; batch = []; }\n    }\n    if (batch.length) yield batch;\n  });\n}\n\n// Combining transforms\nexport function concat<T, U>(src: Iterable<T>, ...others: Iterable<U>[]): Iterable<T | U> {\n  return makeTransform(src, function* (s) {\n    yield* s;\n    for (const o of others) yield* o;\n  });\n}\n","import type { Predicate, Reducer } from './core.js';\nimport { assertNonEmpty, assertHasValue } from './internal.js';\n\n// Collection terminals\nexport function toArray<T>(src: Iterable<T>): T[] {\n  return Array.from(src);\n}\n\nexport function reduce<T, U>(src: Iterable<T>, fn: Reducer<T, U>, init: U): U {\n  let acc = init, i = 0;\n  for (const v of src) acc = fn(acc, v, i++);\n  return acc;\n}\n\nexport function find<T>(src: Iterable<T>, fn: Predicate<T>): T | undefined {\n  let i = 0;\n  for (const v of src) if (fn(v, i++)) return v;\n  return undefined;\n}\n\nexport function forEach<T>(src: Iterable<T>, fn: (v: T, i: number) => void): void {\n  let i = 0;\n  for (const v of src) fn(v, i++);\n}\n\n// Testing terminals\nexport function first<T>(src: Iterable<T>): T | undefined {\n  for (const v of src) return v;\n  return undefined;\n}\n\nexport function last<T>(src: Iterable<T>): T | undefined {\n  if (Array.isArray(src)) return src[src.length - 1];\n  let last: T | undefined;\n  for (const v of src) last = v;\n  return last;\n}\n\nexport function count<T>(src: Iterable<T>): number {\n  if (Array.isArray(src)) return src.length;\n  let n = 0;\n  for (const _ of src) n++;\n  return n;\n}\n\nexport function some<T>(src: Iterable<T>, fn: Predicate<T>): boolean {\n  let i = 0;\n  for (const v of src) if (fn(v, i++)) return true;\n  return false;\n}\n\nexport function every<T>(src: Iterable<T>, fn: Predicate<T>): boolean {\n  let i = 0;\n  for (const v of src) if (!fn(v, i++)) return false;\n  return true;\n}\n\n// Statistical terminals\n/**\n * Calculate the sum of all numbers.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const sum = (src: Iterable<number>): number => {\n  let total = 0, count = 0;\n  for (const v of src) { total += v; count++; }\n  assertNonEmpty(count, 'sum');\n  return total;\n};\n\n/**\n * Calculate the arithmetic mean.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const mean = (src: Iterable<number>): number => {\n  let total = 0, count = 0;\n  for (const v of src) { total += v; count++; }\n  assertNonEmpty(count, 'mean');\n  return total / count;\n};\n\n/**\n * Partition array around a pivot for Quickselect.\n * @private\n */\nfunction partition(arr: number[], left: number, right: number): number {\n  const pivot = arr[right]!;\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (arr[j]! < pivot) {\n      [arr[i], arr[j]] = [arr[j]!, arr[i]!];\n      i++;\n    }\n  }\n  [arr[i], arr[right]] = [arr[right]!, arr[i]!];\n  return i;\n}\n\n/**\n * Find the k-th smallest element using Quickselect (Hoare's selection algorithm).\n * @private\n */\nfunction quickselect(arr: number[], k: number): number {\n  let left = 0;\n  let right = arr.length - 1;\n\n  while (left < right) {\n    const pivotIndex = partition(arr, left, right);\n    if (pivotIndex === k) {\n      return arr[k]!;\n    } else if (pivotIndex > k) {\n      right = pivotIndex - 1;\n    } else {\n      left = pivotIndex + 1;\n    }\n  }\n\n  return arr[left]!;\n}\n\n/**\n * Calculate the median (50th percentile) using Quickselect algorithm.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const median = (src: Iterable<number>): number => {\n  const arr = Array.from(src);\n  assertNonEmpty(arr.length, 'median');\n\n  const mid = arr.length >> 1;\n  if (arr.length % 2) {\n    // Odd length: return middle element\n    return quickselect(arr, mid);\n  } else {\n    // Even length: return average of two middle elements\n    const upper = quickselect(arr, mid);\n    const lower = quickselect(arr, mid - 1);\n    return (lower + upper) / 2;\n  }\n};\n\n/**\n * Find the minimum value.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const min = (src: Iterable<number>): number => {\n  let result = Infinity, has = false;\n  for (const v of src) { if (v < result) result = v; has = true; }\n  assertHasValue(has, 'min');\n  return result;\n};\n\n/**\n * Find the maximum value.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const max = (src: Iterable<number>): number => {\n  let result = -Infinity, has = false;\n  for (const v of src) { if (v > result) result = v; has = true; }\n  assertHasValue(has, 'max');\n  return result;\n};\n\n/**\n * Calculate the population variance using Welford's online algorithm.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const variance = (src: Iterable<number>): number => {\n  let count = 0;\n  let mean = 0;\n  let M2 = 0;\n\n  for (const x of src) {\n    count++;\n    const delta = x - mean;\n    mean += delta / count;\n    const delta2 = x - mean;\n    M2 += delta * delta2;\n  }\n\n  assertNonEmpty(count, 'variance');\n  return M2 / count;\n};\n"],"mappings":"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","names":["count","last","count","mean"]}