@dangayle/rustlike 0.1.0

package/dist/async-iter-aLdg-qp2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-iter-aLdg-qp2.mjs","names":[],"sources":["../src/core.ts","../src/iter.ts","../src/async-iter.ts"],"sourcesContent":["/**\n * Core Algebraic Data Types: Option<T> and Result<T, E>\n *\n * This file merges Result and Option to allow seamless interoperation\n * (converting Result -> Option and vice versa) without circular dependencies.\n */\n\n// ============================================================================\n// Option<T> Definitions\n// ============================================================================\n\nexport interface Some<T> {\n  readonly some: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): Option<U>;\n  mapOr<U>(defaultValue: U, fn: (value: T) => U): U;\n  mapOrElse<U>(defaultFn: () => U, fn: (value: T) => U): U;\n  andThen<U>(fn: (value: T) => Option<U>): Option<U>;\n  and<U>(other: Option<U>): Option<U>;\n  or(other: Option<T>): Option<T>;\n  orElse(fn: () => Option<T>): Option<T>;\n  xor(other: Option<T>): Option<T>;\n  filter(predicate: (value: T) => boolean): Option<T>;\n  contains(value: T): boolean;\n  unwrap(): T;\n  unwrapOr(defaultValue: T): T;\n  unwrapOrElse(fn: () => T): T;\n  expect(message: string): T;\n  match<U>(handlers: { some: (value: T) => U; none: () => U }): U;\n  okOr<E>(error: E): Result<T, E>;\n  zip<U>(other: Option<U>): Option<readonly [T, U]>;\n  /** Flatten nested Option<Option<T>> to Option<T> */\n  flatten<U>(this: Option<Option<U>>): Option<U>;\n  /** Inspect the value if present, without modifying it */\n  inspect(fn: (value: T) => void): Option<T>;\n  isSome(): this is Some<T>;\n  isNone(): this is None;\n}\n\nexport interface None {\n  readonly some: false;\n  map<U>(fn: (value: never) => U): Option<U>;\n  mapOr<U>(defaultValue: U, fn: (value: never) => U): U;\n  mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;\n  andThen<U>(fn: (value: never) => Option<U>): Option<U>;\n  and<U>(other: Option<U>): None;\n  or<T>(other: Option<T>): Option<T>;\n  orElse<T>(fn: () => Option<T>): Option<T>;\n  xor<T>(other: Option<T>): Option<T>;\n  filter(predicate: (value: never) => boolean): None;\n  contains(value: unknown): false;\n  unwrap(): never;\n  unwrapOr<T>(defaultValue: T): T;\n  unwrapOrElse<T>(fn: () => T): T;\n  expect(message: string): never;\n  match<U>(handlers: { some: (value: never) => U; none: () => U }): U;\n  okOr<E>(error: E): Result<never, E>;\n  zip<U>(other: Option<U>): None;\n  /** Flatten nested Option<Option<T>> to Option<T> */\n  flatten<U>(this: Option<Option<U>>): Option<U>;\n  /** Inspect the value if present, without modifying it */\n  inspect(fn: (value: never) => void): Option<never>;\n  isSome(): this is Some<never>;\n  isNone(): this is None;\n}\n\nexport type Option<T> = Some<T> | None;\n\n// ============================================================================\n// Result<T, E> Definitions\n// ============================================================================\n\nexport interface Ok<T, E = never> {\n  readonly ok: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): Result<U, E>;\n  mapOr<U>(defaultValue: U, fn: (value: T) => U): U;\n  mapOrElse<U>(defaultFn: (error: E) => U, fn: (value: T) => U): U;\n  mapErr<F>(fn: (error: E) => F): Result<T, F>;\n  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;\n  and<U>(other: Result<U, E>): Result<U, E>;\n  or<F>(other: Result<T, F>): Result<T, F>;\n  orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;\n  contains(value: T): boolean;\n  containsErr(error: E): boolean;\n  unwrap(): T;\n  unwrapOr(defaultValue: T): T;\n  unwrapOrElse(fn: (error: E) => T): T;\n  expect(message: string): T;\n  /** Get the error or throw (panics if Ok) */\n  unwrapErr(): E;\n  /** Get the error or throw with custom message (panics if Ok) */\n  expectErr(message: string): E;\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U;\n  /** Convert to Option<T>, discarding the error if any */\n  toOption(): Option<T>;\n  /** Convert to Option<E>, discarding the value if any */\n  err(): Option<E>;\n  /** Flatten nested Result<Result<T, E>, E> to Result<T, E> */\n  flatten<U>(this: Result<Result<U, E>, E>): Result<U, E>;\n  /** Inspect the value if Ok, without modifying it */\n  inspect(fn: (value: T) => void): Result<T, E>;\n  /** Inspect the error if Err, without modifying it */\n  inspectErr(fn: (error: E) => void): Result<T, E>;\n  isOk(): this is Ok<T, E>;\n  isErr(): this is Err<E, T>;\n}\n\nexport interface Err<E, T = never> {\n  readonly ok: false;\n  readonly error: E;\n  map<U>(fn: (value: T) => U): Result<U, E>;\n  mapOr<U>(defaultValue: U, fn: (value: T) => U): U;\n  mapOrElse<U>(defaultFn: (error: E) => U, fn: (value: T) => U): U;\n  mapErr<F>(fn: (error: E) => F): Result<T, F>;\n  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;\n  and<U>(other: Result<U, E>): Result<U, E>;\n  or<F>(other: Result<T, F>): Result<T, F>;\n  orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;\n  contains(value: T): boolean;\n  containsErr(error: E): boolean;\n  unwrap(): T;\n  unwrapOr(defaultValue: T): T;\n  unwrapOrElse(fn: (error: E) => T): T;\n  expect(message: string): T;\n  /** Get the error (panics if Ok) */\n  unwrapErr(): E;\n  /** Get the error or return it (identity for Err) */\n  expectErr(message: string): E;\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U;\n  /** Convert to Option<T>, discarding the error if any */\n  toOption(): Option<T>;\n  /** Convert to Option<E>, discarding the value if any */\n  err(): Option<E>;\n  /** Flatten nested Result<Result<T, E>, E> to Result<T, E> */\n  flatten<U>(this: Result<Result<U, E>, E>): Result<U, E>;\n  /** Inspect the value if Ok, without modifying it */\n  inspect(fn: (value: T) => void): Result<T, E>;\n  /** Inspect the error if Err, without modifying it */\n  inspectErr(fn: (error: E) => void): Result<T, E>;\n  isOk(): this is Ok<T, E>;\n  isErr(): this is Err<E, T>;\n}\n\nexport type Result<T, E> = Ok<T, E> | Err<E, T>;\n\n// ============================================================================\n// Internal Helper: JSON Stringify for Panic Messages\n// ============================================================================\n\nconst PANIC_STRING_MAX_LENGTH = 200;\n\nexport function toPanicString(value: unknown): string {\n  let str: string;\n  if (value instanceof Error) {\n    str = value.message;\n  } else {\n    try {\n      str = JSON.stringify(value);\n    } catch {\n      str = String(value);\n    }\n  }\n  if (str.length > PANIC_STRING_MAX_LENGTH) {\n    return str.slice(0, PANIC_STRING_MAX_LENGTH) + \"...\";\n  }\n  return str;\n}\n\n// ============================================================================\n// Option Implementation\n// ============================================================================\n\nclass SomeImpl<T> implements Some<T> {\n  readonly some = true as const;\n  constructor(readonly value: T) {}\n\n  map<U>(fn: (value: T) => U): Option<U> {\n    return new SomeImpl(fn(this.value));\n  }\n\n  mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n    return fn(this.value);\n  }\n\n  mapOrElse<U>(_defaultFn: () => U, fn: (value: T) => U): U {\n    return fn(this.value);\n  }\n\n  andThen<U>(fn: (value: T) => Option<U>): Option<U> {\n    return fn(this.value);\n  }\n\n  and<U>(other: Option<U>): Option<U> {\n    return other;\n  }\n\n  or(_other: Option<T>): Option<T> {\n    return this;\n  }\n\n  orElse(_fn: () => Option<T>): Option<T> {\n    return this;\n  }\n\n  xor(other: Option<T>): Option<T> {\n    return other.isSome() ? NoneValue : this;\n  }\n\n  filter(predicate: (value: T) => boolean): Option<T> {\n    return predicate(this.value) ? this : NoneValue;\n  }\n\n  contains(value: T): boolean {\n    return this.value === value;\n  }\n\n  unwrap(): T {\n    return this.value;\n  }\n\n  unwrapOr(_defaultValue: T): T {\n    return this.value;\n  }\n\n  unwrapOrElse(_fn: () => T): T {\n    return this.value;\n  }\n\n  expect(_message: string): T {\n    return this.value;\n  }\n\n  match<U>(handlers: { some: (value: T) => U; none: () => U }): U {\n    return handlers.some(this.value);\n  }\n\n  okOr<E>(_error: E): Result<T, E> {\n    return new OkImpl(this.value);\n  }\n\n  zip<U>(other: Option<U>): Option<readonly [T, U]> {\n    return other.isSome() ? new SomeImpl([this.value, other.value] as const) : NoneValue;\n  }\n\n  flatten<U>(this: Option<Option<U>>): Option<U> {\n    return this.unwrap();\n  }\n\n  inspect(fn: (value: T) => void): Option<T> {\n    fn(this.value);\n    return this;\n  }\n\n  isSome(): this is Some<T> {\n    return true;\n  }\n\n  isNone(): this is None {\n    return false;\n  }\n}\n\nclass NoneImpl implements None {\n  readonly some = false as const;\n\n  map<U>(_fn: (value: never) => U): Option<U> {\n    return this as unknown as Option<U>;\n  }\n\n  mapOr<U>(defaultValue: U, _fn: (value: never) => U): U {\n    return defaultValue;\n  }\n\n  mapOrElse<U>(defaultFn: () => U, _fn: (value: never) => U): U {\n    return defaultFn();\n  }\n\n  andThen<U>(_fn: (value: never) => Option<U>): Option<U> {\n    return this as unknown as Option<U>;\n  }\n\n  and<U>(_other: Option<U>): None {\n    return this;\n  }\n\n  or<T>(other: Option<T>): Option<T> {\n    return other;\n  }\n\n  orElse<T>(fn: () => Option<T>): Option<T> {\n    return fn();\n  }\n\n  xor<T>(other: Option<T>): Option<T> {\n    return other;\n  }\n\n  filter(_predicate: (value: never) => boolean): None {\n    return this;\n  }\n\n  contains(_value: unknown): false {\n    return false;\n  }\n\n  unwrap(): never {\n    throw new Error(\"Called unwrap on None\");\n  }\n\n  unwrapOr<T>(defaultValue: T): T {\n    return defaultValue;\n  }\n\n  unwrapOrElse<T>(fn: () => T): T {\n    return fn();\n  }\n\n  expect(message: string): never {\n    throw new Error(message);\n  }\n\n  match<U>(handlers: { some: (value: never) => U; none: () => U }): U {\n    return handlers.none();\n  }\n\n  okOr<E>(error: E): Result<never, E> {\n    return new ErrImpl(error);\n  }\n\n  zip<U>(_other: Option<U>): None {\n    return this;\n  }\n\n  flatten<U>(this: Option<Option<U>>): Option<U> {\n    return this as unknown as Option<U>;\n  }\n\n  inspect(_fn: (value: never) => void): Option<never> {\n    return this;\n  }\n\n  isSome(): this is Some<never> {\n    return false;\n  }\n\n  isNone(): this is None {\n    return true;\n  }\n}\n\n// Singleton None value (frozen for immutability)\nconst NoneValue: None = Object.freeze(new NoneImpl()) as None;\n\n// ============================================================================\n// Result Implementation\n// ============================================================================\n\nclass OkImpl<T, E = never> implements Ok<T, E> {\n  readonly ok = true as const;\n  constructor(readonly value: T) {}\n\n  map<U>(fn: (value: T) => U): Result<U, E> {\n    return new OkImpl(fn(this.value));\n  }\n\n  mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n    return fn(this.value);\n  }\n\n  mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    return fn(this.value);\n  }\n\n  mapErr<F>(_fn: (error: E) => F): Result<T, F> {\n    return this as unknown as Result<T, F>;\n  }\n\n  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n    return fn(this.value);\n  }\n\n  and<U>(other: Result<U, E>): Result<U, E> {\n    return other;\n  }\n\n  or<F>(_other: Result<T, F>): Result<T, F> {\n    return this as unknown as Result<T, F>;\n  }\n\n  orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {\n    return this as unknown as Result<T, F>;\n  }\n\n  contains(value: T): boolean {\n    return this.value === value;\n  }\n\n  containsErr(_error: E): boolean {\n    return false;\n  }\n\n  unwrap(): T {\n    return this.value;\n  }\n\n  unwrapOr(_defaultValue: T): T {\n    return this.value;\n  }\n\n  unwrapOrElse(_fn: (error: E) => T): T {\n    return this.value;\n  }\n\n  expect(_message: string): T {\n    return this.value;\n  }\n\n  unwrapErr(): E {\n    throw new Error(`Called unwrapErr on Ok: ${toPanicString(this.value)}`);\n  }\n\n  expectErr(message: string): E {\n    throw new Error(`${message}: ${toPanicString(this.value)}`);\n  }\n\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U {\n    return handlers.ok(this.value);\n  }\n\n  toOption(): Option<T> {\n    return new SomeImpl(this.value);\n  }\n\n  err(): Option<E> {\n    return NoneValue;\n  }\n\n  flatten<U>(this: Result<Result<U, E>, E>): Result<U, E> {\n    return this.unwrap();\n  }\n\n  inspect(fn: (value: T) => void): Result<T, E> {\n    fn(this.value);\n    return this;\n  }\n\n  inspectErr(_fn: (error: E) => void): Result<T, E> {\n    return this;\n  }\n\n  isOk(): this is Ok<T, E> {\n    return true;\n  }\n\n  isErr(): this is Err<E, T> {\n    return false;\n  }\n}\n\nclass ErrImpl<E, T = never> implements Err<E, T> {\n  readonly ok = false as const;\n  constructor(readonly error: E) {}\n\n  map<U>(_fn: (value: T) => U): Result<U, E> {\n    return this as unknown as Result<U, E>;\n  }\n\n  mapOr<U>(defaultValue: U, _fn: (value: T) => U): U {\n    return defaultValue;\n  }\n\n  mapOrElse<U>(defaultFn: (error: E) => U, _fn: (value: T) => U): U {\n    return defaultFn(this.error);\n  }\n\n  mapErr<F>(fn: (error: E) => F): Result<T, F> {\n    return new ErrImpl(fn(this.error));\n  }\n\n  andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {\n    return this as unknown as Result<U, E>;\n  }\n\n  and<U>(_other: Result<U, E>): Result<U, E> {\n    return this as unknown as Result<U, E>;\n  }\n\n  or<F>(other: Result<T, F>): Result<T, F> {\n    return other;\n  }\n\n  orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {\n    return fn(this.error);\n  }\n\n  contains(_value: T): boolean {\n    return false;\n  }\n\n  containsErr(error: E): boolean {\n    return this.error === error;\n  }\n\n  unwrap(): T {\n    throw new Error(`Called unwrap on Err: ${toPanicString(this.error)}`);\n  }\n\n  unwrapOr(defaultValue: T): T {\n    return defaultValue;\n  }\n\n  unwrapOrElse(fn: (error: E) => T): T {\n    return fn(this.error);\n  }\n\n  expect(message: string): T {\n    throw new Error(`${message}: ${toPanicString(this.error)}`);\n  }\n\n  unwrapErr(): E {\n    return this.error;\n  }\n\n  expectErr(_message: string): E {\n    return this.error;\n  }\n\n  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U {\n    return handlers.err(this.error);\n  }\n\n  toOption(): Option<T> {\n    return NoneValue;\n  }\n\n  err(): Option<E> {\n    return new SomeImpl(this.error);\n  }\n\n  flatten<U>(this: Result<Result<U, E>, E>): Result<U, E> {\n    return this as unknown as Result<U, E>;\n  }\n\n  inspect(_fn: (value: T) => void): Result<T, E> {\n    return this;\n  }\n\n  inspectErr(fn: (error: E) => void): Result<T, E> {\n    fn(this.error);\n    return this;\n  }\n\n  isOk(): this is Ok<T, E> {\n    return false;\n  }\n\n  isErr(): this is Err<E, T> {\n    return true;\n  }\n}\n\n// ============================================================================\n// Constructors (Public API)\n// ============================================================================\n\nexport const Some = <T>(value: T): Some<T> => new SomeImpl(value);\nexport const None: None = NoneValue;\nexport const Ok = <T, E = never>(value: T): Ok<T, E> => new OkImpl(value);\nexport const Err = <E, T = never>(error: E): Err<E, T> => new ErrImpl(error);\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\nexport const isSome = <T>(option: Option<T>): option is Some<T> => option.some;\nexport const isNone = <T>(option: Option<T>): option is None => !option.some;\nexport const isOk = <T, E>(result: Result<T, E>): result is Ok<T, E> => result.ok;\nexport const isErr = <T, E>(result: Result<T, E>): result is Err<E, T> => !result.ok;\n\n// ============================================================================\n// Namespaces (Static Helpers)\n// ============================================================================\n\nexport const Option = {\n  some: Some,\n  none: None,\n  isSome,\n  isNone,\n\n  from: <T>(value: T | null | undefined): Option<T> => (value != null ? Some(value) : None),\n\n  map: <T, U>(option: Option<T>, fn: (value: T) => U): Option<U> => option.map(fn),\n\n  andThen: <T, U>(option: Option<T>, fn: (value: T) => Option<U>): Option<U> => option.andThen(fn),\n\n  or: <T>(option: Option<T>, other: Option<T>): Option<T> => option.or(other),\n\n  orElse: <T>(option: Option<T>, fn: () => Option<T>): Option<T> => option.orElse(fn),\n\n  filter: <T>(option: Option<T>, predicate: (value: T) => boolean): Option<T> =>\n    option.some ? option.filter(predicate) : None,\n\n  unwrap: <T>(option: Option<T>): T => option.unwrap(),\n\n  unwrapOr: <T>(option: Option<T>, defaultValue: T): T => option.unwrapOr(defaultValue),\n\n  unwrapOrElse: <T>(option: Option<T>, fn: () => T): T => option.unwrapOrElse(fn),\n\n  match: <T, U>(option: Option<T>, handlers: { some: (value: T) => U; none: () => U }): U =>\n    option.match(handlers),\n\n  zip: <T, U>(a: Option<T>, b: Option<U>): Option<readonly [T, U]> => a.zip(b),\n\n  okOr: <T, E>(option: Option<T>, error: E): Result<T, E> =>\n    option.some ? Ok(option.value) : Err(error),\n\n  flatten: <T>(option: Option<Option<T>>): Option<T> => option.flatten(),\n\n  transpose: <T, E>(option: Option<Result<T, E>>): Result<Option<T>, E> => {\n    if (option.isSome()) {\n      const val = option.unwrap();\n      if (val.isOk()) {\n        return Ok(Some(val.unwrap()));\n      } else {\n        return Err(val.unwrapErr());\n      }\n    }\n    return Ok(None);\n  },\n\n  /**\n   * Combine multiple Options into a single Option of an array.\n   * Returns None if any Option is None.\n   *\n   * @example\n   * const options = Option.all([Some(1), Some(2), Some(3)]);\n   * // Some([1, 2, 3])\n   *\n   * const withNone = Option.all([Some(1), None, Some(3)]);\n   * // None\n   */\n  all: <T>(options: readonly Option<T>[]): Option<T[]> => {\n    const values: T[] = [];\n    for (const option of options) {\n      if (option.isNone()) {\n        return None;\n      }\n      values.push(option.value);\n    }\n    return Some(values);\n  },\n\n  /** Alias for {@link all} — Rust's collect pattern. */\n  collect: <T>(options: readonly Option<T>[]): Option<T[]> => Option.all(options),\n} as const;\n\nexport const Result = {\n  ok: Ok,\n  err: Err,\n  isOk,\n  isErr,\n\n  map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> => result.map(fn),\n\n  mapErr: <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> => result.mapErr(fn),\n\n  andThen: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> =>\n    result.andThen(fn),\n\n  orElse: <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> =>\n    result.orElse(fn),\n\n  unwrap: <T, E>(result: Result<T, E>): T => result.unwrap(),\n\n  unwrapOr: <T, E>(result: Result<T, E>, defaultValue: T): T => result.unwrapOr(defaultValue),\n\n  unwrapOrElse: <T, E>(result: Result<T, E>, fn: (error: E) => T): T => result.unwrapOrElse(fn),\n\n  unwrapErr: <T, E>(result: Result<T, E>): E => result.unwrapErr(),\n\n  expectErr: <T, E>(result: Result<T, E>, message: string): E => result.expectErr(message),\n\n  match: <T, E, U>(\n    result: Result<T, E>,\n    handlers: { ok: (value: T) => U; err: (error: E) => U },\n  ): U => result.match(handlers),\n\n  toOption: <T, E>(result: Result<T, E>): Option<T> => result.toOption(),\n\n  fromThrowable: <T, E = unknown>(fn: () => T): Result<T, E> => {\n    try {\n      return Ok(fn());\n    } catch (e) {\n      // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n      // narrows via the E parameter (defaulting to `unknown`).\n      return Err(e as E);\n    }\n  },\n\n  fromPromise: async <T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>> => {\n    try {\n      return Ok(await promise);\n    } catch (e) {\n      // Cast: see fromThrowable — caller narrows E via the type parameter.\n      return Err(e as E);\n    }\n  },\n\n  flatten: <T, E>(result: Result<Result<T, E>, E>): Result<T, E> => result.flatten(),\n\n  transpose: <T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> => {\n    if (result.isOk()) {\n      const val = result.unwrap();\n      if (val.isSome()) {\n        return Some(Ok(val.unwrap()));\n      } else {\n        return None;\n      }\n    }\n    // If Result is Err, we wrap it in Some: Some(Err(e))\n    return Some(Err(result.unwrapErr()));\n  },\n\n  /**\n   * Combine multiple Results into a single Result of an array.\n   * Short-circuits on the first Err encountered.\n   *\n   * @example\n   * const results = Result.all([Ok(1), Ok(2), Ok(3)]);\n   * // Ok([1, 2, 3])\n   *\n   * const withErr = Result.all([Ok(1), Err(\"failed\"), Ok(3)]);\n   * // Err(\"failed\")\n   */\n  all: <T, E>(results: readonly Result<T, E>[]): Result<T[], E> => {\n    const values: T[] = [];\n    for (const result of results) {\n      if (result.isErr()) {\n        return result as unknown as Result<T[], E>;\n      }\n      values.push(result.value);\n    }\n    return Ok(values);\n  },\n\n  /** Alias for {@link all} — Rust's collect pattern. */\n  collect: <T, E>(results: readonly Result<T, E>[]): Result<T[], E> => Result.all(results),\n} as const;\n","/**\n * Lazy Iterator: Iter<T>\n *\n * Rust-like lazy iterator wrappers around JavaScript's native Iterator protocol.\n * Enables composable, memory-efficient data processing pipelines.\n */\n\nimport { Option, Some, None, Result, Ok, Err } from \"./core\";\n\n// ============================================================================\n// Iter<T> Interface (Public API)\n// ============================================================================\n\nexport interface Iter<T> {\n  // Core transformation\n  map<U>(fn: (value: T) => U): Iter<U>;\n  filter(pred: (value: T) => boolean): Iter<T>;\n  flatMap<U>(fn: (value: T) => Iterable<U>): Iter<U>;\n  inspect(fn: (value: T) => void): Iter<T>;\n\n  // Peekable adapter (matches Rust's peekable)\n  peekable(): PeekableIter<T>;\n\n  // Search\n  find(pred: (value: T) => boolean): Option<T>;\n  findMap<U>(fn: (value: T) => Option<U>): Option<U>;\n  any(pred: (value: T) => boolean): boolean;\n  all(pred: (value: T) => boolean): boolean;\n  position(pred: (value: T) => boolean): Option<number>;\n\n  // Aggregation\n  fold<U>(init: U, fn: (acc: U, value: T) => U): U;\n  reduce(fn: (acc: T, value: T) => T): Option<T>;\n  tryFold<U, E>(init: U, fn: (acc: U, value: T) => Result<U, E>): Result<U, E>;\n  count(): number;\n  last(): Option<T>;\n  nth(n: number): Option<T>;\n  partition(pred: (value: T) => boolean): [T[], T[]];\n\n  // Result integration\n  tryMap<U, E>(fn: (value: T) => Result<U, E>): Iter<Result<U, E>>;\n\n  // Limiting & skipping\n  take(n: number): Iter<T>;\n  skip(n: number): Iter<T>;\n  stepBy(step: number): Iter<T>;\n\n  // Enumerating (index, value pairs)\n  enumerate(): Iter<readonly [number, T]>;\n\n  // Combining iterators\n  zip<U>(other: Iterable<U>): Iter<readonly [T, U]>;\n  chain(other: Iterable<T>): Iter<T>;\n\n  // Flattening nested iterators\n  flatten<U>(this: Iter<Iterable<U>>): Iter<U>;\n\n  // Result collection (Rust-like: collect::<Result<Vec<_>, E>>())\n  collectResult<U, E>(this: Iter<Result<U, E>>): Result<U[], E>;\n\n  // Consumption\n  forEach(fn: (value: T) => void): void;\n  collect(): T[];\n\n  // Iterator protocol compliance\n  [Symbol.iterator](): Iterator<T>;\n  next(): IteratorResult<T>;\n}\n\nexport interface PeekableIter<T> extends Iter<T> {\n  // Peekable (for multi-line parsing)\n  peek(): Option<T>;\n}\n\n// ============================================================================\n// Internal Implementation\n// ============================================================================\n\n// Sentinel object for \"no peeked value\" state — reused across all instances.\nconst EMPTY_PEEK: Readonly<{ has: false; value: undefined }> = Object.freeze({\n  has: false,\n  value: undefined,\n});\n\n/**\n * Core iterator implementation using idiomatic TypeScript.\n * Uses generator functions internally for lazy evaluation.\n */\nclass IterImpl<T> implements Iter<T> {\n  private readonly source: Iterator<T>;\n  private peeked: { has: boolean; value: T | undefined } = EMPTY_PEEK;\n\n  constructor(source: Iterator<T>) {\n    this.source = source;\n  }\n\n  // -------------------------------------------------------------------------\n  // Core transformation\n  // -------------------------------------------------------------------------\n\n  map<U>(fn: (value: T) => U): Iter<U> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const value of source) {\n          yield fn(value);\n        }\n      })(),\n    );\n  }\n\n  filter(pred: (value: T) => boolean): Iter<T> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const value of source) {\n          if (pred(value)) {\n            yield value;\n          }\n        }\n      })(),\n    );\n  }\n\n  flatMap<U>(fn: (value: T) => Iterable<U>): Iter<U> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const value of source) {\n          for (const inner of fn(value)) {\n            yield inner;\n          }\n        }\n      })(),\n    );\n  }\n\n  inspect(fn: (value: T) => void): Iter<T> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const value of source) {\n          fn(value);\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  peekable(): PeekableIter<T> {\n    return this as PeekableIter<T>;\n  }\n\n  // -------------------------------------------------------------------------\n  // Search\n  // -------------------------------------------------------------------------\n\n  find(pred: (value: T) => boolean): Option<T> {\n    for (const value of this) {\n      if (pred(value)) {\n        return Some(value);\n      }\n    }\n    return None;\n  }\n\n  findMap<U>(fn: (value: T) => Option<U>): Option<U> {\n    for (const value of this) {\n      const result = fn(value);\n      if (result.isSome()) {\n        return result;\n      }\n    }\n    return None;\n  }\n\n  any(pred: (value: T) => boolean): boolean {\n    for (const value of this) {\n      if (pred(value)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  all(pred: (value: T) => boolean): boolean {\n    for (const value of this) {\n      if (!pred(value)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  position(pred: (value: T) => boolean): Option<number> {\n    let index = 0;\n    for (const value of this) {\n      if (pred(value)) {\n        return Some(index);\n      }\n      index++;\n    }\n    return None;\n  }\n\n  // -------------------------------------------------------------------------\n  // Aggregation\n  // -------------------------------------------------------------------------\n\n  fold<U>(init: U, fn: (acc: U, value: T) => U): U {\n    let acc = init;\n    for (const value of this) {\n      acc = fn(acc, value);\n    }\n    return acc;\n  }\n\n  reduce(fn: (acc: T, value: T) => T): Option<T> {\n    const first = this.next();\n    if (first.done) {\n      return None;\n    }\n    let acc = first.value;\n    for (const value of this) {\n      acc = fn(acc, value);\n    }\n    return Some(acc);\n  }\n\n  tryFold<U, E>(init: U, fn: (acc: U, value: T) => Result<U, E>): Result<U, E> {\n    let acc = init;\n    for (const value of this) {\n      const result = fn(acc, value);\n      if (result.isErr()) {\n        return result;\n      }\n      acc = result.value;\n    }\n    return Ok(acc);\n  }\n\n  count(): number {\n    let n = 0;\n    for (const _value of this) {\n      n++;\n    }\n    return n;\n  }\n\n  last(): Option<T> {\n    let last: Option<T> = None;\n    for (const value of this) {\n      last = Some(value);\n    }\n    return last;\n  }\n\n  nth(n: number): Option<T> {\n    if (n < 0) return None;\n    let index = 0;\n    for (const value of this) {\n      if (index === n) {\n        return Some(value);\n      }\n      index++;\n    }\n    return None;\n  }\n\n  partition(pred: (value: T) => boolean): [T[], T[]] {\n    const matching: T[] = [];\n    const rest: T[] = [];\n    for (const value of this) {\n      if (pred(value)) {\n        matching.push(value);\n      } else {\n        rest.push(value);\n      }\n    }\n    return [matching, rest];\n  }\n\n  // -------------------------------------------------------------------------\n  // Result integration\n  // -------------------------------------------------------------------------\n\n  tryMap<U, E>(fn: (value: T) => Result<U, E>): Iter<Result<U, E>> {\n    return this.map(fn);\n  }\n\n  // -------------------------------------------------------------------------\n  // Limiting & skipping\n  // -------------------------------------------------------------------------\n\n  take(n: number): Iter<T> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        let count = 0;\n        const iterator = source[Symbol.iterator]();\n        while (count < n) {\n          const result = iterator.next();\n          if (result.done) break;\n          yield result.value;\n          count++;\n        }\n      })(),\n    );\n  }\n\n  skip(n: number): Iter<T> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        let count = 0;\n        for (const value of source) {\n          if (count < n) {\n            count++;\n            continue;\n          }\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  stepBy(step: number): Iter<T> {\n    if (step <= 0) {\n      throw new Error(\"Iter.stepBy: step must be positive\");\n    }\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        let index = 0;\n        for (const value of source) {\n          if (index % step === 0) {\n            yield value;\n          }\n          index++;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Enumerating\n  // -------------------------------------------------------------------------\n\n  enumerate(): Iter<readonly [number, T]> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        let index = 0;\n        for (const value of source) {\n          yield [index, value] as const;\n          index++;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Combining iterators\n  // -------------------------------------------------------------------------\n\n  zip<U>(other: Iterable<U>): Iter<readonly [T, U]> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        const otherIter = other[Symbol.iterator]();\n        for (const value of source) {\n          const otherResult = otherIter.next();\n          if (otherResult.done) break;\n          yield [value, otherResult.value] as const;\n        }\n      })(),\n    );\n  }\n\n  chain(other: Iterable<T>): Iter<T> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const value of source) {\n          yield value;\n        }\n        for (const value of other) {\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Flattening nested iterators\n  // -------------------------------------------------------------------------\n\n  flatten<U>(this: Iter<Iterable<U>>): Iter<U> {\n    const source = this;\n    return new IterImpl(\n      (function* () {\n        for (const inner of source) {\n          for (const value of inner) {\n            yield value;\n          }\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Peekable\n  // -------------------------------------------------------------------------\n\n  peek(): Option<T> {\n    if (this.peeked.has) {\n      return Some(this.peeked.value as T);\n    }\n    const result = this.source.next();\n    if (result.done) {\n      return None;\n    }\n    this.peeked = { has: true, value: result.value };\n    return Some(result.value);\n  }\n\n  // -------------------------------------------------------------------------\n  // Result collection\n  // -------------------------------------------------------------------------\n\n  collectResult<U, E>(this: Iter<Result<U, E>>): Result<U[], E> {\n    const out: U[] = [];\n    for (const item of this) {\n      if (item.isErr()) {\n        return Err(item.error);\n      }\n      out.push(item.value);\n    }\n    return Ok(out);\n  }\n\n  // -------------------------------------------------------------------------\n  // Consumption\n  // -------------------------------------------------------------------------\n\n  forEach(fn: (value: T) => void): void {\n    for (const value of this) {\n      fn(value);\n    }\n  }\n\n  collect(): T[] {\n    const result: T[] = [];\n    for (const value of this) {\n      result.push(value);\n    }\n    return result;\n  }\n\n  // -------------------------------------------------------------------------\n  // Iterator protocol\n  // -------------------------------------------------------------------------\n\n  [Symbol.iterator](): Iterator<T> {\n    return this;\n  }\n\n  next(): IteratorResult<T> {\n    // Check peeked value first\n    if (this.peeked.has) {\n      const value = this.peeked.value as T;\n      this.peeked = EMPTY_PEEK;\n      return { done: false, value };\n    }\n    return this.source.next();\n  }\n}\n\n// ============================================================================\n// Factory Functions (Public API)\n// ============================================================================\n\n/**\n * Create an Iter from an iterator or iterable source.\n *\n * @example\n * const numbers = iter([1, 2, 3, 4, 5]);\n * const doubled = numbers.map(x => x * 2).collect();\n */\nexport function iter<T>(source: Iterator<T> | Iterable<T>): Iter<T> {\n  if (Symbol.iterator in source) {\n    return new IterImpl(source[Symbol.iterator]());\n  }\n  return new IterImpl(source);\n}\n\n/**\n * Create an Iter from an array.\n * Convenience function for the common case of iterating over arrays.\n *\n * @example\n * const items = iterFromArray(['a', 'b', 'c']);\n */\nexport function iterFromArray<T>(arr: readonly T[]): Iter<T> {\n  return new IterImpl(arr[Symbol.iterator]());\n}\n\n/**\n * Create an Iter from a generator function.\n * Useful for creating custom lazy sequences.\n *\n * @example\n * const naturals = iterFromGenerator(function* () {\n *   let n = 0;\n *   while (true) yield n++;\n * });\n * const firstTen = naturals.take(10).collect();\n */\nexport function iterFromGenerator<T>(gen: () => Generator<T>): Iter<T> {\n  return new IterImpl(gen());\n}\n\n// ============================================================================\n// Iter Namespace (Static Helpers)\n// ============================================================================\n\nexport const Iter = {\n  /**\n   * Create an Iter from an iterator or iterable source.\n   */\n  from: iter,\n\n  /**\n   * Create an Iter from an array.\n   */\n  fromArray: iterFromArray,\n\n  /**\n   * Create an Iter from a generator function.\n   */\n  fromGenerator: iterFromGenerator,\n\n  /**\n   * Create an empty iterator.\n   */\n  empty: <T>(): Iter<T> => new IterImpl((function* () {})()),\n\n  /**\n   * Create an iterator that yields a single value.\n   */\n  once: <T>(value: T): Iter<T> =>\n    new IterImpl(\n      (function* () {\n        yield value;\n      })(),\n    ),\n\n  /**\n   * Create an iterator that repeats a value n times.\n   */\n  repeat: <T>(value: T, n: number): Iter<T> =>\n    new IterImpl(\n      (function* () {\n        for (let i = 0; i < n; i++) {\n          yield value;\n        }\n      })(),\n    ),\n\n  /**\n   * Create an iterator over a range of numbers.\n   * @param start - Start of the range (inclusive)\n   * @param end - End of the range (exclusive)\n   * @param step - Step between values (default: 1)\n   */\n  range: (start: number, end: number, step = 1): Iter<number> =>\n    new IterImpl(\n      (function* () {\n        if (step === 0) {\n          throw new Error(\"Iter.range: step must be non-zero\");\n        }\n        for (let i = start; step > 0 ? i < end : i > end; i += step) {\n          yield i;\n        }\n      })(),\n    ),\n\n  /**\n   * Sum all numbers in an iterator.\n   */\n  sum: (iterator: Iter<number>): number => iterator.fold(0, (acc, x) => acc + x),\n\n  /**\n   * Multiply all numbers in an iterator.\n   */\n  product: (iterator: Iter<number>): number => iterator.fold(1, (acc, x) => acc * x),\n\n  /**\n   * Return the minimum value, or None for empty iterators.\n   */\n  min: (iterator: Iter<number>): Option<number> => iterator.reduce((a, b) => (a <= b ? a : b)),\n\n  /**\n   * Return the maximum value, or None for empty iterators.\n   */\n  max: (iterator: Iter<number>): Option<number> => iterator.reduce((a, b) => (a >= b ? a : b)),\n} as const;\n","/**\n * Async Lazy Iterator: AsyncIter<T>\n *\n * Rust-like async lazy iterator wrapper around JavaScript's native AsyncIterator protocol.\n * Enables composable, memory-efficient async data processing pipelines.\n */\n\nimport { Result, Ok, Err, Option, Some, None } from \"./core\";\n\n// ============================================================================\n// AsyncIter<T> Interface (Public API)\n// ============================================================================\n\nexport interface AsyncIter<T> {\n  // Core transformation\n  map<U>(fn: (value: T) => U | Promise<U>): AsyncIter<U>;\n  filter(pred: (value: T) => boolean | Promise<boolean>): AsyncIter<T>;\n  flatMap<U>(fn: (value: T) => Iterable<U> | AsyncIterable<U>): AsyncIter<U>;\n  inspect(fn: (value: T) => void | Promise<void>): AsyncIter<T>;\n\n  // Peekable adapter (matches Rust's peekable)\n  peekable(): PeekableAsyncIter<T>;\n\n  // Search\n  find(pred: (value: T) => boolean | Promise<boolean>): Promise<Option<T>>;\n  findMap<U>(fn: (value: T) => Option<U> | Promise<Option<U>>): Promise<Option<U>>;\n  any(pred: (value: T) => boolean | Promise<boolean>): Promise<boolean>;\n  all(pred: (value: T) => boolean | Promise<boolean>): Promise<boolean>;\n  position(pred: (value: T) => boolean | Promise<boolean>): Promise<Option<number>>;\n\n  // Aggregation\n  fold<U>(init: U, fn: (acc: U, value: T) => U | Promise<U>): Promise<U>;\n  reduce(fn: (acc: T, value: T) => T | Promise<T>): Promise<Option<T>>;\n  tryFold<U, E>(\n    init: U,\n    fn: (acc: U, value: T) => Result<U, E> | Promise<Result<U, E>>,\n  ): Promise<Result<U, E>>;\n  count(): Promise<number>;\n  last(): Promise<Option<T>>;\n  nth(n: number): Promise<Option<T>>;\n  partition(pred: (value: T) => boolean | Promise<boolean>): Promise<[T[], T[]]>;\n\n  // Result integration\n  tryMap<U, E>(fn: (value: T) => Result<U, E> | Promise<Result<U, E>>): AsyncIter<Result<U, E>>;\n\n  // Limiting & skipping\n  take(n: number): AsyncIter<T>;\n  skip(n: number): AsyncIter<T>;\n  stepBy(step: number): AsyncIter<T>;\n\n  // Enumerating (index, value pairs)\n  enumerate(): AsyncIter<readonly [number, T]>;\n\n  // Combining iterators\n  zip<U>(other: AsyncIterable<U>): AsyncIter<readonly [T, U]>;\n  chain(other: AsyncIterable<T>): AsyncIter<T>;\n\n  // Flattening nested iterators\n  flatten<U>(this: AsyncIter<AsyncIterable<U> | Iterable<U>>): AsyncIter<U>;\n\n  // Result collection (Rust-like: collect::<Result<Vec<_>, E>>())\n  collectResult<U, E>(this: AsyncIter<Result<U, E>>): Promise<Result<U[], E>>;\n\n  // Consumption\n  forEach(fn: (value: T) => void | Promise<void>): Promise<void>;\n  collect(): Promise<T[]>;\n\n  // Async iterator protocol compliance\n  [Symbol.asyncIterator](): AsyncIterator<T>;\n  next(): Promise<IteratorResult<T>>;\n}\n\nexport interface PeekableAsyncIter<T> extends AsyncIter<T> {\n  // Peekable (for multi-line parsing)\n  peek(): Promise<Option<T>>;\n}\n\n// ============================================================================\n// Internal Implementation\n// ============================================================================\n\n/**\n * Core async iterator implementation using idiomatic TypeScript.\n * Uses async generator functions internally for lazy evaluation.\n */\nclass AsyncIterImpl<T> implements AsyncIter<T> {\n  private readonly source: AsyncIterator<T>;\n  private peeked: Promise<IteratorResult<T>> | null = null;\n\n  constructor(source: AsyncIterator<T>) {\n    this.source = source;\n  }\n\n  // -------------------------------------------------------------------------\n  // Core transformation\n  // -------------------------------------------------------------------------\n\n  map<U>(fn: (value: T) => U | Promise<U>): AsyncIter<U> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const value of source) {\n          yield await fn(value);\n        }\n      })(),\n    );\n  }\n\n  filter(pred: (value: T) => boolean | Promise<boolean>): AsyncIter<T> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const value of source) {\n          if (await pred(value)) {\n            yield value;\n          }\n        }\n      })(),\n    );\n  }\n\n  flatMap<U>(fn: (value: T) => Iterable<U> | AsyncIterable<U>): AsyncIter<U> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const value of source) {\n          const inner = fn(value);\n          if (Symbol.asyncIterator in inner) {\n            for await (const item of inner) {\n              yield item;\n            }\n          } else {\n            for (const item of inner) {\n              yield item;\n            }\n          }\n        }\n      })(),\n    );\n  }\n\n  inspect(fn: (value: T) => void | Promise<void>): AsyncIter<T> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const value of source) {\n          await fn(value);\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  peekable(): PeekableAsyncIter<T> {\n    return this as PeekableAsyncIter<T>;\n  }\n\n  // -------------------------------------------------------------------------\n  // Search\n  // -------------------------------------------------------------------------\n\n  async find(pred: (value: T) => boolean | Promise<boolean>): Promise<Option<T>> {\n    for await (const value of this) {\n      if (await pred(value)) {\n        return Some(value);\n      }\n    }\n    return None;\n  }\n\n  async findMap<U>(fn: (value: T) => Option<U> | Promise<Option<U>>): Promise<Option<U>> {\n    for await (const value of this) {\n      const result = await fn(value);\n      if (result.isSome()) {\n        return result;\n      }\n    }\n    return None;\n  }\n\n  async any(pred: (value: T) => boolean | Promise<boolean>): Promise<boolean> {\n    for await (const value of this) {\n      if (await pred(value)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  async all(pred: (value: T) => boolean | Promise<boolean>): Promise<boolean> {\n    for await (const value of this) {\n      if (!(await pred(value))) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  async position(pred: (value: T) => boolean | Promise<boolean>): Promise<Option<number>> {\n    let index = 0;\n    for await (const value of this) {\n      if (await pred(value)) {\n        return Some(index);\n      }\n      index++;\n    }\n    return None;\n  }\n\n  // -------------------------------------------------------------------------\n  // Aggregation\n  // -------------------------------------------------------------------------\n\n  async fold<U>(init: U, fn: (acc: U, value: T) => U | Promise<U>): Promise<U> {\n    let acc = init;\n    for await (const value of this) {\n      acc = await fn(acc, value);\n    }\n    return acc;\n  }\n\n  async reduce(fn: (acc: T, value: T) => T | Promise<T>): Promise<Option<T>> {\n    const first = await this.next();\n    if (first.done) {\n      return None;\n    }\n    let acc = first.value;\n    for await (const value of this) {\n      acc = await fn(acc, value);\n    }\n    return Some(acc);\n  }\n\n  async tryFold<U, E>(\n    init: U,\n    fn: (acc: U, value: T) => Result<U, E> | Promise<Result<U, E>>,\n  ): Promise<Result<U, E>> {\n    let acc = init;\n    for await (const value of this) {\n      const result = await fn(acc, value);\n      if (result.isErr()) {\n        return result;\n      }\n      acc = result.value;\n    }\n    return Ok(acc);\n  }\n\n  async count(): Promise<number> {\n    let n = 0;\n    for await (const _value of this) {\n      n++;\n    }\n    return n;\n  }\n\n  async last(): Promise<Option<T>> {\n    let last: Option<T> = None;\n    for await (const value of this) {\n      last = Some(value);\n    }\n    return last;\n  }\n\n  async nth(n: number): Promise<Option<T>> {\n    if (n < 0) return None;\n    let index = 0;\n    for await (const value of this) {\n      if (index === n) {\n        return Some(value);\n      }\n      index++;\n    }\n    return None;\n  }\n\n  async partition(pred: (value: T) => boolean | Promise<boolean>): Promise<[T[], T[]]> {\n    const matching: T[] = [];\n    const rest: T[] = [];\n    for await (const value of this) {\n      if (await pred(value)) {\n        matching.push(value);\n      } else {\n        rest.push(value);\n      }\n    }\n    return [matching, rest];\n  }\n\n  // -------------------------------------------------------------------------\n  // Result integration\n  // -------------------------------------------------------------------------\n\n  tryMap<U, E>(fn: (value: T) => Result<U, E> | Promise<Result<U, E>>): AsyncIter<Result<U, E>> {\n    return this.map(fn);\n  }\n\n  // -------------------------------------------------------------------------\n  // Limiting & skipping\n  // -------------------------------------------------------------------------\n\n  take(n: number): AsyncIter<T> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        let count = 0;\n        const iterator = source[Symbol.asyncIterator]();\n        while (count < n) {\n          const result = await iterator.next();\n          if (result.done) break;\n          yield result.value;\n          count++;\n        }\n      })(),\n    );\n  }\n\n  skip(n: number): AsyncIter<T> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        let count = 0;\n        for await (const value of source) {\n          if (count < n) {\n            count++;\n            continue;\n          }\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  stepBy(step: number): AsyncIter<T> {\n    if (step <= 0) {\n      throw new Error(\"AsyncIter.stepBy: step must be positive\");\n    }\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        let index = 0;\n        for await (const value of source) {\n          if (index % step === 0) {\n            yield value;\n          }\n          index++;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Enumerating\n  // -------------------------------------------------------------------------\n\n  enumerate(): AsyncIter<readonly [number, T]> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        let index = 0;\n        for await (const value of source) {\n          yield [index, value] as const;\n          index++;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Combining iterators\n  // -------------------------------------------------------------------------\n\n  zip<U>(other: AsyncIterable<U>): AsyncIter<readonly [T, U]> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        const otherIter = other[Symbol.asyncIterator]();\n        for await (const value of source) {\n          const otherResult = await otherIter.next();\n          if (otherResult.done) break;\n          yield [value, otherResult.value] as const;\n        }\n      })(),\n    );\n  }\n\n  chain(other: AsyncIterable<T>): AsyncIter<T> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const value of source) {\n          yield value;\n        }\n        for await (const value of other) {\n          yield value;\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Flattening nested iterators\n  // -------------------------------------------------------------------------\n\n  flatten<U>(this: AsyncIter<AsyncIterable<U> | Iterable<U>>): AsyncIter<U> {\n    const source = this;\n    return new AsyncIterImpl(\n      (async function* () {\n        for await (const inner of source) {\n          // Handle both sync and async iterables\n          if (Symbol.asyncIterator in inner) {\n            for await (const value of inner) {\n              yield value;\n            }\n          } else {\n            for (const value of inner) {\n              yield value;\n            }\n          }\n        }\n      })(),\n    );\n  }\n\n  // -------------------------------------------------------------------------\n  // Peekable\n  // -------------------------------------------------------------------------\n\n  async peek(): Promise<Option<T>> {\n    this.peeked ??= this.source.next();\n    const result = await this.peeked;\n    if (result.done) {\n      return None;\n    }\n    return Some(result.value);\n  }\n\n  // -------------------------------------------------------------------------\n  // Result collection\n  // -------------------------------------------------------------------------\n\n  async collectResult<U, E>(this: AsyncIter<Result<U, E>>): Promise<Result<U[], E>> {\n    const out: U[] = [];\n    for await (const item of this) {\n      if (item.isErr()) {\n        return Err(item.error);\n      }\n      out.push(item.value);\n    }\n    return Ok(out);\n  }\n\n  // -------------------------------------------------------------------------\n  // Consumption\n  // -------------------------------------------------------------------------\n\n  async forEach(fn: (value: T) => void | Promise<void>): Promise<void> {\n    for await (const value of this) {\n      await fn(value);\n    }\n  }\n\n  async collect(): Promise<T[]> {\n    const result: T[] = [];\n    for await (const value of this) {\n      result.push(value);\n    }\n    return result;\n  }\n\n  // -------------------------------------------------------------------------\n  // Async iterator protocol\n  // -------------------------------------------------------------------------\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  next(): Promise<IteratorResult<T>> {\n    if (this.peeked) {\n      const promise = this.peeked;\n      this.peeked = null;\n      return promise;\n    }\n    return this.source.next();\n  }\n}\n\n// ============================================================================\n// Factory Functions (Public API)\n// ============================================================================\n\n/**\n * Create an AsyncIter from an async iterator or async iterable source.\n *\n * @example\n * const items = asyncIter(fetchPages());\n * const processed = await items.map(processPage).collect();\n */\nexport function asyncIter<T>(source: AsyncIterator<T> | AsyncIterable<T>): AsyncIter<T> {\n  if (Symbol.asyncIterator in source) {\n    return new AsyncIterImpl(source[Symbol.asyncIterator]());\n  }\n  return new AsyncIterImpl(source);\n}\n\n/**\n * Create an AsyncIter from a sync iterable.\n * Useful for lifting sync data into async pipelines.\n *\n * @example\n * const items = asyncIterFromIterable([1, 2, 3]);\n */\nexport function asyncIterFromIterable<T>(source: Iterable<T>): AsyncIter<T> {\n  return new AsyncIterImpl(\n    (async function* () {\n      for (const value of source) {\n        yield value;\n      }\n    })(),\n  );\n}\n\n/**\n * Create an AsyncIter from an array.\n * Convenience function for the common case.\n *\n * @example\n * const items = asyncIterFromArray(['a', 'b', 'c']);\n */\nexport function asyncIterFromArray<T>(arr: readonly T[]): AsyncIter<T> {\n  return asyncIterFromIterable(arr);\n}\n\n/**\n * Create an AsyncIter from an async generator function.\n * Useful for creating custom lazy async sequences.\n *\n * @example\n * const pages = asyncIterFromGenerator(async function* () {\n *   let page = 1;\n *   while (true) {\n *     const data = await fetchPage(page++);\n *     if (data.length === 0) break;\n *     yield data;\n *   }\n * });\n */\nexport function asyncIterFromGenerator<T>(gen: () => AsyncGenerator<T>): AsyncIter<T> {\n  return new AsyncIterImpl(gen());\n}\n\n// ============================================================================\n// AsyncIter Namespace (Static Helpers)\n// ============================================================================\n\nexport const AsyncIter = {\n  /**\n   * Create an AsyncIter from an async iterator or async iterable source.\n   */\n  from: asyncIter,\n\n  /**\n   * Create an AsyncIter from a sync iterable.\n   */\n  fromIterable: asyncIterFromIterable,\n\n  /**\n   * Create an AsyncIter from an array.\n   */\n  fromArray: asyncIterFromArray,\n\n  /**\n   * Create an AsyncIter from an async generator function.\n   */\n  fromGenerator: asyncIterFromGenerator,\n\n  /**\n   * Create an empty async iterator.\n   */\n  empty: <T>(): AsyncIter<T> => new AsyncIterImpl((async function* () {})()),\n\n  /**\n   * Create an async iterator that yields a single value.\n   */\n  once: <T>(value: T): AsyncIter<T> =>\n    new AsyncIterImpl(\n      (async function* () {\n        yield value;\n      })(),\n    ),\n\n  /**\n   * Create an async iterator that repeats a value n times.\n   */\n  repeat: <T>(value: T, n: number): AsyncIter<T> =>\n    new AsyncIterImpl(\n      (async function* () {\n        for (let i = 0; i < n; i++) {\n          yield value;\n        }\n      })(),\n    ),\n\n  /**\n   * Create an async iterator over a range of numbers.\n   */\n  range: (start: number, end: number, step = 1): AsyncIter<number> =>\n    new AsyncIterImpl(\n      (async function* () {\n        if (step === 0) {\n          throw new Error(\"AsyncIter.range: step must be non-zero\");\n        }\n        for (let i = start; step > 0 ? i < end : i > end; i += step) {\n          yield i;\n        }\n      })(),\n    ),\n\n  /**\n   * Sum all numbers in an async iterator.\n   */\n  sum: (iterator: AsyncIter<number>): Promise<number> => iterator.fold(0, (acc, x) => acc + x),\n\n  /**\n   * Multiply all numbers in an async iterator.\n   */\n  product: (iterator: AsyncIter<number>): Promise<number> => iterator.fold(1, (acc, x) => acc * x),\n\n  /**\n   * Return the minimum value, or None for empty iterators.\n   */\n  min: (iterator: AsyncIter<number>): Promise<Option<number>> =>\n    iterator.reduce((a, b) => (a <= b ? a : b)),\n\n  /**\n   * Return the maximum value, or None for empty iterators.\n   */\n  max: (iterator: AsyncIter<number>): Promise<Option<number>> =>\n    iterator.reduce((a, b) => (a >= b ? a : b)),\n} as const;\n"],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,477 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_async_iter = require('./async-iter-3iu4aRtf.cjs');
+
+//#region src/async.ts
+/**
+* AsyncResult<T, E> - Handling asynchronous Results chaining
+*/
+var AsyncResult = class AsyncResult {
+	constructor(promise) {
+		this.promise = promise;
+	}
+	/**
+	* Create an AsyncResult from a Promise<Result<T, E>>
+	*/
+	static fromPromise(promise) {
+		return new AsyncResult(promise);
+	}
+	/**
+	* Create an AsyncResult that resolves to Ok(value)
+	*/
+	static ok(value) {
+		return new AsyncResult(Promise.resolve(require_async_iter.Ok(value)));
+	}
+	/**
+	* Create an AsyncResult that resolves to Err(error)
+	*/
+	static err(error) {
+		return new AsyncResult(Promise.resolve(require_async_iter.Err(error)));
+	}
+	/**
+	* Wrap an async function that might reject into an AsyncResult.
+	* This is the async equivalent of Result.fromThrowable().
+	*
+	* @example
+	* const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));
+	* // AsyncResult<Response, unknown>
+	*/
+	static fromThrowable(fn) {
+		try {
+			return new AsyncResult(fn().then((value) => require_async_iter.Ok(value)).catch((error) => require_async_iter.Err(error)));
+		} catch (e) {
+			return new AsyncResult(Promise.resolve(require_async_iter.Err(e)));
+		}
+	}
+	/**
+	* Map the inner Ok value using a synchronous or asynchronous function.
+	* If the function returns a Promise, it is awaited.
+	*/
+	map(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) return res;
+			return require_async_iter.Ok(await fn(res.value));
+		}));
+	}
+	/**
+	* Map the inner Err value using a synchronous or asynchronous function.
+	*/
+	mapErr(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) return res;
+			return require_async_iter.Err(await fn(res.error));
+		}));
+	}
+	/**
+	* Chain another Result-returning operation (sync or async).
+	* Supports returning: Result, AsyncResult, or Promise<Result>.
+	*/
+	andThen(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) return res;
+			const next = fn(res.value);
+			if (next instanceof AsyncResult) return await next.toPromise();
+			return await next;
+		}));
+	}
+	/**
+	* Handle the error case with another Result-returning operation.
+	*/
+	orElse(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) return res;
+			const next = fn(res.error);
+			if (next instanceof AsyncResult) return await next.toPromise();
+			return await next;
+		}));
+	}
+	/**
+	* Inspect the Ok value if present, without modifying it.
+	* The callback can be synchronous or asynchronous.
+	*/
+	inspect(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isOk()) await fn(res.value);
+			return res;
+		}));
+	}
+	/**
+	* Inspect the Err value if present, without modifying it.
+	* The callback can be synchronous or asynchronous.
+	*/
+	inspectErr(fn) {
+		return new AsyncResult(this.promise.then(async (res) => {
+			if (res.isErr()) await fn(res.error);
+			return res;
+		}));
+	}
+	/**
+	* Pattern match on the result (async).
+	*/
+	match(handlers) {
+		return this.promise.then((res) => res.match(handlers));
+	}
+	/**
+	* Unwrap the value or throw (reject).
+	*/
+	async unwrap() {
+		return (await this.promise).unwrap();
+	}
+	/**
+	* Unwrap or return default.
+	*/
+	async unwrapOr(defaultValue) {
+		return (await this.promise).unwrapOr(defaultValue);
+	}
+	/**
+	* Unwrap or compute default.
+	*/
+	async unwrapOrElse(fn) {
+		const res = await this.promise;
+		if (res.isOk()) return res.value;
+		return await fn(res.error);
+	}
+	/**
+	* Returns true if the result is Ok and contains the given value.
+	*/
+	contains(value) {
+		return this.promise.then((r) => r.contains(value));
+	}
+	/**
+	* Returns true if the result is Err and contains the given error.
+	*/
+	containsErr(error) {
+		return this.promise.then((r) => r.containsErr(error));
+	}
+	/**
+	* Returns `other` if the result is Ok, otherwise returns the Err value of self.
+	*/
+	and(other) {
+		return new AsyncResult(this.promise.then((r) => r.isOk() ? other.promise : Promise.resolve(r)));
+	}
+	/**
+	* Returns `other` if the result is Err, otherwise returns the Ok value of self.
+	*/
+	or(other) {
+		return new AsyncResult(this.promise.then((r) => r.isErr() ? other.promise : Promise.resolve(r)));
+	}
+	/**
+	* Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.
+	*/
+	flatten() {
+		return new AsyncResult(this.promise.then((r) => r.flatten()));
+	}
+	/**
+	* Converts from Result<T, E> to Option<T>, discarding the error if any.
+	*/
+	toOption() {
+		return this.promise.then((r) => r.toOption());
+	}
+	/**
+	* Converts from Result<T, E> to Option<E>, discarding the success value if any.
+	*/
+	err() {
+		return this.promise.then((r) => r.err());
+	}
+	/**
+	* Returns the contained Ok value, or throws with the provided message.
+	*/
+	expect(message) {
+		return this.promise.then((r) => r.expect(message));
+	}
+	/**
+	* Returns the contained Err value, or throws if Ok.
+	*/
+	unwrapErr() {
+		return this.promise.then((r) => r.unwrapErr());
+	}
+	/**
+	* Returns the contained Err value, or throws with the provided message.
+	*/
+	expectErr(message) {
+		return this.promise.then((r) => r.expectErr(message));
+	}
+	/**
+	* Get the underlying Promise<Result<T, E>>
+	*/
+	toPromise() {
+		return this.promise;
+	}
+	/**
+	* Implement PromiseLike to allow `await asyncResult`
+	*/
+	then(onfulfilled, onrejected) {
+		return this.promise.then(onfulfilled, onrejected);
+	}
+};
+
+//#endregion
+//#region src/match.ts
+/**
+* Exhaustive pattern matching utilities
+*
+* Ensures all cases are handled in discriminated unions.
+*/
+/**
+* Use in the default case of a switch to ensure exhaustiveness.
+* If the switch is not exhaustive, TypeScript will error because
+* the unhandled case type cannot be assigned to 'never'.
+*
+* @example
+* type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };
+*
+* function area(s: Shape): number {
+*   switch (s.kind) {
+*     case 'circle': return Math.PI * s.radius ** 2;
+*     case 'rect': return s.w * s.h;
+*     default: return assertNever(s);
+*   }
+* }
+*/
+function assertNever(x, message) {
+	if (message) throw new Error(message);
+	throw new Error(`Unexpected value: ${require_async_iter.toPanicString(x)}`);
+}
+/**
+* Type-safe exhaustive matching for discriminated unions.
+* Supports an optional catch-all '_' handler.
+*
+* @example
+* type Action =
+*   | { type: 'increment'; amount: number }
+*   | { type: 'decrement'; amount: number }
+*   | { type: 'reset' };
+*
+* const result = match(action, 'type', {
+*   increment: (a) => state + a.amount,
+*   decrement: (a) => state - a.amount,
+*   reset: () => 0,
+* });
+*
+* // With catch-all
+* const result = match(action, 'type', {
+*   increment: (a) => state + a.amount,
+*   _: () => state // catch-all
+* });
+*/
+function match(value, discriminant, handlers) {
+	const key = value[discriminant];
+	const handlersRecord = handlers;
+	const handler = handlersRecord[key];
+	if (handler) return handler(value);
+	const catchAll = handlersRecord._;
+	if (catchAll) return catchAll(value);
+	return assertNever(value, `Unhandled variant: ${key}`);
+}
+/**
+* Match on a discriminated union using the 'kind' discriminant (common pattern).
+*
+* @example
+* type Shape =
+*   | { kind: 'circle'; radius: number }
+*   | { kind: 'rect'; w: number; h: number };
+*
+* const area = matchKind(shape, {
+*   circle: (s) => Math.PI * s.radius ** 2,
+*   rect: (s) => s.w * s.h,
+* });
+*
+* // With catch-all
+* const isCircle = matchKind(shape, {
+*   circle: () => true,
+*   _: () => false
+* });
+*/
+function matchKind(value, handlers) {
+	return match(value, "kind", handlers);
+}
+/**
+* Match on a discriminated union using the 'type' discriminant (common pattern).
+*
+* @example
+* type Action =
+*   | { type: 'add'; item: string }
+*   | { type: 'remove'; id: number };
+*
+* const result = matchType(action, {
+*   add: (a) => [...items, a.item],
+*   remove: (a) => items.filter((_, i) => i !== a.id),
+* });
+*/
+function matchType(value, handlers) {
+	return match(value, "type", handlers);
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Immutability and utility types for Rust-like TypeScript
+*/
+/**
+* Create a branded type constructor
+*
+* @example
+* const UserId = brand<number, 'UserId'>();
+* const id = UserId(42); // type is Brand<number, 'UserId'>
+*/
+const brand = () => (value) => value;
+/**
+* Check if array is non-empty (type guard)
+*/
+const isNonEmpty = (arr) => arr.length > 0;
+/**
+* Create a non-empty array from values
+*/
+const nonEmpty = (first, ...rest) => [first, ...rest];
+/**
+* Get the first element of a non-empty array (guaranteed to exist)
+*/
+const head = (arr) => arr[0];
+/**
+* Create a newtype with validation (Rust's newtype pattern + smart constructor).
+* Implements the "parse, don't validate" pattern - make invalid states unrepresentable.
+*
+* @example
+* const EmailAddress = newtype<string, 'Email'>(
+*   (s) => s.includes('@'),
+*   "Invalid email"
+* );
+*
+* const email = EmailAddress.parse(userInput);
+* // Result<Brand<string, 'Email'>, string>
+*
+* @example
+* const PositiveNumber = newtype<number, 'Positive'>(
+*   (n) => n > 0,
+*   (n) => `Expected positive, got ${n}`
+* );
+*/
+const newtype = (validate, error) => {
+	const getError = (value) => {
+		if (typeof error === "function") return error(value);
+		return error;
+	};
+	return {
+		parse: (value) => {
+			if (validate(value)) return require_async_iter.Ok(value);
+			return require_async_iter.Err(getError(value));
+		},
+		unsafe: (value) => value
+	};
+};
+
+//#endregion
+//#region src/interop.ts
+/**
+* Interop helpers for wrapping third-party and standard library code
+*/
+/**
+* One-shot: wrap a single throwing operation in a Result.
+* Use {@link safeTry} to create a reusable safe wrapper instead.
+*
+* @example
+* const result = tryCatch(() => JSON.parse(userInput));
+* // Result<unknown, unknown>
+*/
+const tryCatch = (fn) => {
+	try {
+		return require_async_iter.Ok(fn());
+	} catch (e) {
+		return require_async_iter.Err(e);
+	}
+};
+/**
+* Wrap any async function that might reject to return Result
+*
+* @example
+* const result = await tryAsync(() => axios.get('/api/users'));
+* // Result<AxiosResponse, AxiosError>
+*/
+const tryAsync = async (fn) => {
+	try {
+		return require_async_iter.Ok(await fn());
+	} catch (e) {
+		return require_async_iter.Err(e);
+	}
+};
+/**
+* Create a reusable Option-returning version of any function that may return
+* T | null | undefined or throw. Returns None on null, undefined, or throw.
+*
+* @example
+* const safeFind = safeCall((id: number) => users.find(u => u.id === id));
+* const user = safeFind(42); // Option<User>
+*/
+const safeCall = (fn) => (...args) => {
+	try {
+		return require_async_iter.Option.from(fn(...args));
+	} catch {
+		return require_async_iter.None;
+	}
+};
+/**
+* Create a reusable Option-returning version of any async function that may return
+* T | null | undefined or reject. Returns None on null, undefined, or rejection.
+*
+* @example
+* const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));
+* const response = await safeFetch('/api'); // Option<Response>
+*/
+const safeCallAsync = (fn) => async (...args) => {
+	try {
+		return require_async_iter.Option.from(await fn(...args));
+	} catch {
+		return require_async_iter.None;
+	}
+};
+/**
+* Reusable: wrap a throwing function so every call returns a Result.
+* Use {@link tryCatch} for one-shot operations instead.
+*
+* @example
+* const safeJsonParse = safeTry(JSON.parse);
+* const data = safeJsonParse(input); // Result<unknown, unknown>
+*/
+const safeTry = (fn) => (...args) => {
+	try {
+		return require_async_iter.Ok(fn(...args));
+	} catch (e) {
+		return require_async_iter.Err(e);
+	}
+};
+
+//#endregion
+exports.AsyncIter = require_async_iter.AsyncIter;
+exports.AsyncResult = AsyncResult;
+exports.Err = require_async_iter.Err;
+exports.Iter = require_async_iter.Iter;
+exports.None = require_async_iter.None;
+exports.Ok = require_async_iter.Ok;
+exports.Option = require_async_iter.Option;
+exports.Result = require_async_iter.Result;
+exports.Some = require_async_iter.Some;
+exports.assertNever = assertNever;
+exports.asyncIter = require_async_iter.asyncIter;
+exports.asyncIterFromArray = require_async_iter.asyncIterFromArray;
+exports.asyncIterFromGenerator = require_async_iter.asyncIterFromGenerator;
+exports.asyncIterFromIterable = require_async_iter.asyncIterFromIterable;
+exports.brand = brand;
+exports.head = head;
+exports.isErr = require_async_iter.isErr;
+exports.isNonEmpty = isNonEmpty;
+exports.isNone = require_async_iter.isNone;
+exports.isOk = require_async_iter.isOk;
+exports.isSome = require_async_iter.isSome;
+exports.iter = require_async_iter.iter;
+exports.iterFromArray = require_async_iter.iterFromArray;
+exports.iterFromGenerator = require_async_iter.iterFromGenerator;
+exports.match = match;
+exports.matchKind = matchKind;
+exports.matchType = matchType;
+exports.newtype = newtype;
+exports.nonEmpty = nonEmpty;
+exports.safeCall = safeCall;
+exports.safeCallAsync = safeCallAsync;
+exports.safeTry = safeTry;
+exports.tryAsync = tryAsync;
+exports.tryCatch = tryCatch;
+//# sourceMappingURL=index.cjs.map