tyneq 1.0.0 → 1.0.1

package/README.md

@@ -169,7 +169,73 @@ Two registration styles: functional (generators, factories, terminals) and class
 npm install tyneq
 ```
 
-TypeScript 5.x with `"strictNullChecks": true`. No `@types` package needed.
+## Requirements
+
+- TypeScript 5.0 or higher
+- `"strictNullChecks": true` in your tsconfig
+
+No `@types` package needed.
+
+## Stage 3 Decorators
+
+tyneq is implemented with TC39 Stage 3 decorators - the standardized decorator proposal
+that shipped in TypeScript 5.0 and requires no extra tsconfig flags. This is a different
+model from the legacy `experimentalDecorators` syntax used by NestJS, Angular, and
+InversifyJS.
+
+**Using built-in operators requires nothing from you.** The decorator machinery lives
+entirely inside tyneq's compiled output. Calling `.where()`, `.select()`, or any terminal
+is just calling a plain method. No decorator support is needed on your side at all.
+
+**Using the class-based plugin API does require Stage 3 decorators in your project.**
+If you write custom operators using `@operator`, `@terminal`, `@orderedOperator`, or
+`@cachedOperator`, your tsconfig must not have `experimentalDecorators: true`, because
+TypeScript supports only one decorator model at a time. If your project already uses
+the legacy model, the functional plugin API is fully equivalent and has no such constraint.
+
+### How the dist handles decorators
+
+The published `dist` is compiled by tsup (esbuild) targeting `es2017`. esbuild
+transforms Stage 3 decorator syntax into plain helper functions (`__decorateClass`,
+`__decorateElement`) at build time, so the output works in every Node version, bundler,
+and consumer project - including those with no native decorator support at all.
+
+| Aspect | Detail |
+|---|---|
+| Raw `@decorator` syntax in dist | No - compiled to helper functions |
+| Node 18+ | Works |
+| Projects with `experimentalDecorators: true` | Works (built-ins and functional plugin API) |
+| Extra bundle overhead | Small - one shared set of helpers per entry point |
+
+**Trade-offs to be aware of:**
+
+- Helper-function output is slightly larger than native decorator syntax would be. The
+  helpers are small and shared across all operators within an entry point, so in practice
+  the impact is minimal.
+- Tools that understand Stage 3 decorator syntax natively (newer runtimes, bundlers) do
+  not get any advantage from the raw syntax - they just run the helper functions instead.
+- This is the correct approach for a published package right now. Shipping raw `@decorator`
+  syntax would silently break consumers on Node versions or bundlers that do not handle it.
+
+**Future:** When TC39 Stage 3 decorators are universally supported in all target runtimes
+and bundlers, the build toolchain will be updated to pass decorator syntax through natively,
+removing the helper-function overhead. Until that point, the helper-based output is the safe
+and correct choice.
+
+## Compatibility
+
+**All projects:** Built-in operators and sequences work without any decorator support. Import
+and use normally.
+
+**Projects with `experimentalDecorators: true`** (NestJS, Angular, InversifyJS): The built-in
+operators and the functional plugin API (`createGeneratorOperator`, `createOperator`, and
+related helpers) work without any changes. The class-based decorator plugin API (`@operator`,
+`@terminal`, and related decorators) cannot be used because TypeScript supports only one
+decorator model at a time. Use the functional API instead - it is fully equivalent and the
+recommended path in these projects.
+
+**Projects with TypeScript 5.0+ and no `experimentalDecorators`:** Full access to everything,
+including the class-based plugin API decorators.
 
 ---
 

package/dist/{TyneqCachedTerminalOperator.d.ts → TyneqCachedTerminalOperator-DTVuBGMn.d.ts}

@@ -1,6 +1,5 @@
-import { L as Constructor, M as tyneqQueryNode, S as TyneqEnumerableBase, T as QueryPlanNode, Z as Nullable, _ as TyneqCachedSequence, a as Enumerator, b as TyneqSequence, i as Enumerable, m as OrderedEnumerable, n as CachedEnumerable, o as EnumeratorFactory, p as OperatorSource, r as Comparer, t as CacheResult, tt as BaseEnumerableSorter, y as TyneqOrderedSequence } from "./core.js";
+import { k as Constructor, l as Enumerable, m as EnumeratorFactory, O as OperatorSource, $ as TyneqEnumerableBase, X as TyneqOrderedSequence, T as TyneqSequence, N as Nullable, D as OrderedEnumerable, _ as tyneqQueryNode, e as QueryPlanNode, C as Comparer, E as Enumerator, a0 as BaseEnumerableSorter, V as TyneqCachedSequence, i as CachedEnumerable, h as CacheResult } from './core-DR17XN89.js';
 
-//#region src/plugin/decorators/operator.d.ts
 /**
  * Class decorator that registers a `TyneqEnumerator` subclass as an operator on every sequence.
  *
@@ -34,8 +33,7 @@ import { L as Constructor, M as tyneqQueryNode, S as TyneqEnumerableBase, T as Q
  * @group Decorators
  */
 declare function operator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends new (...args: any[]) => any>(target: TClass, _context: ClassDecoratorContext) => TClass;
-//#endregion
-//#region src/plugin/decorators/orderedOperator.d.ts
+
 /**
  * Class decorator that registers a `TyneqOrderedEnumerator` subclass as an operator
  * available only on ordered sequences.
@@ -70,8 +68,7 @@ declare function operator<TArgs extends unknown[] = never>(name: string, categor
  * @group Decorators
  */
 declare function orderedOperator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends Constructor<any>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/cachedOperator.d.ts
+
 /**
  * Class decorator that registers a `TyneqCachedEnumerator` subclass as an operator
  * available only on cached sequences.
@@ -104,8 +101,7 @@ declare function orderedOperator<TArgs extends unknown[] = never>(name: string,
  * @group Decorators
  */
 declare function cachedOperator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends Constructor<any>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/terminal.d.ts
+
 /**
  * Class decorator that registers a class as a terminal operator.
  *
@@ -134,10 +130,9 @@ declare function cachedOperator<TArgs extends unknown[] = never>(name: string, c
  * @group Decorators
  */
 declare function terminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends new (...args: any[]) => {
-  process(): unknown;
+    process(): unknown;
 }>(target: TClass, _context: ClassDecoratorContext) => TClass;
-//#endregion
-//#region src/plugin/decorators/orderedTerminal.d.ts
+
 /**
  * Class decorator that registers a `TyneqOrderedTerminalOperator` subclass as a terminal
  * operator available only on ordered sequences.
@@ -165,10 +160,9 @@ declare function terminal<TArgs extends unknown[] = never>(name: string, validat
  * @group Decorators
  */
 declare function orderedTerminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends Constructor<{
-  process(): unknown;
+    process(): unknown;
 }>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/cachedTerminal.d.ts
+
 /**
  * Class decorator that registers a `TyneqCachedTerminalOperator` subclass as a terminal
  * operator available only on cached sequences.
@@ -192,10 +186,9 @@ declare function orderedTerminal<TArgs extends unknown[] = never>(name: string,
  * @group Decorators
  */
 declare function cachedTerminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends Constructor<{
-  process(): unknown;
+    process(): unknown;
 }>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/registration/createOperator.d.ts
+
 /**
  * Registers a streaming or buffering operator using a factory function.
  *
@@ -238,14 +231,13 @@ declare function cachedTerminal<TArgs extends unknown[] = never>(name: string, v
  * @group Factory Functions
  */
 declare function createOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: Enumerable<TSource>, ...args: TArgs) => EnumeratorFactory<TResult>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: Enumerable<TSource>, ...args: TArgs) => EnumeratorFactory<TResult>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createGeneratorOperator.d.ts
+
 /**
  * Registers an operator using a generator function.
  *
@@ -299,14 +291,13 @@ declare function createOperator<TSource, TArgs extends unknown[], TResult>(confi
  * @group Factory Functions
  */
 declare function createGeneratorOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  category?: "streaming" | "buffer";
-  generator: (source: Iterable<TSource>, ...args: TArgs) => IterableIterator<TResult>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category?: "streaming" | "buffer";
+    generator: (source: Iterable<TSource>, ...args: TArgs) => IterableIterator<TResult>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/ordering/TyneqOrderedEnumerable.d.ts
+
 /**
  * Concrete implementation of {@link TyneqOrderedSequence}.
  *
@@ -317,25 +308,24 @@ declare function createGeneratorOperator<TSource, TArgs extends unknown[], TResu
  * @internal
  */
 declare class TyneqOrderedEnumerable<TSource, TKey> extends TyneqEnumerableBase<TSource> implements TyneqOrderedSequence<TSource> {
-  private readonly keySelector;
-  private readonly comparer;
-  private readonly descending;
-  readonly source: TyneqSequence<TSource>;
-  readonly parent: Nullable<OrderedEnumerable<TSource>>;
-  readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
-  constructor(source: TyneqSequence<TSource>, keySelector: (item: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, parent?: OrderedEnumerable<TSource>, node?: Nullable<QueryPlanNode>);
-  asc(): TyneqOrderedSequence<TSource>;
-  desc(): TyneqOrderedSequence<TSource>;
-  getEnumerator(): Enumerator<TSource>;
-  getSorter(next: Nullable<BaseEnumerableSorter<TSource>>): BaseEnumerableSorter<TSource>;
-  thenBy<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
-  thenByDescending<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
-  protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
-  protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
-  protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
+    private readonly keySelector;
+    private readonly comparer;
+    private readonly descending;
+    readonly source: TyneqSequence<TSource>;
+    readonly parent: Nullable<OrderedEnumerable<TSource>>;
+    readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
+    constructor(source: TyneqSequence<TSource>, keySelector: (item: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, parent?: OrderedEnumerable<TSource>, node?: Nullable<QueryPlanNode>);
+    asc(): TyneqOrderedSequence<TSource>;
+    desc(): TyneqOrderedSequence<TSource>;
+    getEnumerator(): Enumerator<TSource>;
+    getSorter(next: Nullable<BaseEnumerableSorter<TSource>>): BaseEnumerableSorter<TSource>;
+    thenBy<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
+    thenByDescending<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
+    protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
+    protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
+    protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
 }
-//#endregion
-//#region src/plugin/registration/createOrderedOperator.d.ts
+
 /**
  * Registers a factory function as an operator available only on ordered sequences,
  * where the factory fully controls the return type.
@@ -376,14 +366,13 @@ declare class TyneqOrderedEnumerable<TSource, TKey> extends TyneqEnumerableBase<
  * @group Factory Functions
  */
 declare function createOrderedOperator<TSource, TArgs extends unknown[]>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: TyneqOrderedEnumerable<TSource, unknown>, node: QueryPlanNode, ...args: TArgs) => TyneqOrderedSequence<TSource>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: TyneqOrderedEnumerable<TSource, unknown>, node: QueryPlanNode, ...args: TArgs) => TyneqOrderedSequence<TSource>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/TyneqCachedEnumerable.d.ts
+
 /**
  * Concrete implementation of {@link TyneqCachedSequence} - caches elements incrementally.
  *
@@ -395,21 +384,20 @@ declare function createOrderedOperator<TSource, TArgs extends unknown[]>(config:
  * @internal
  */
 declare class TyneqCachedEnumerable<TSource> extends TyneqEnumerableBase<TSource> implements TyneqCachedSequence<TSource>, CachedEnumerable<TSource> {
-  private source;
-  private cache;
-  private done;
-  private sourceEnumerator;
-  readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
-  constructor(source: TyneqSequence<TSource>, node?: Nullable<QueryPlanNode>);
-  getEnumerator(): Enumerator<TSource>;
-  refresh(): TyneqCachedSequence<TSource>;
-  tryGetAtFromCache(index: number): CacheResult<TSource>;
-  protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
-  protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
-  protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
+    private source;
+    private cache;
+    private done;
+    private sourceEnumerator;
+    readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
+    constructor(source: TyneqSequence<TSource>, node?: Nullable<QueryPlanNode>);
+    getEnumerator(): Enumerator<TSource>;
+    refresh(): TyneqCachedSequence<TSource>;
+    tryGetAtFromCache(index: number): CacheResult<TSource>;
+    protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
+    protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
+    protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
 }
-//#endregion
-//#region src/plugin/registration/createCachedOperator.d.ts
+
 /**
  * Registers a factory function as an operator available only on cached sequences,
  * where the factory fully controls the return type.
@@ -443,14 +431,13 @@ declare class TyneqCachedEnumerable<TSource> extends TyneqEnumerableBase<TSource
  * @group Factory Functions
  */
 declare function createCachedOperator<TSource, TArgs extends unknown[]>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: TyneqCachedEnumerable<TSource>, node: QueryPlanNode, ...args: TArgs) => TyneqCachedSequence<TSource>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: TyneqCachedEnumerable<TSource>, node: QueryPlanNode, ...args: TArgs) => TyneqCachedSequence<TSource>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator using a plain function.
  *
@@ -478,13 +465,12 @@ declare function createCachedOperator<TSource, TArgs extends unknown[]>(config:
  * @group Factory Functions
  */
 declare function createTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: Enumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: Enumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createOrderedTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator available only on ordered sequences.
  *
@@ -512,13 +498,12 @@ declare function createTerminalOperator<TSource, TArgs extends unknown[], TResul
  * @group Factory Functions
  */
 declare function createOrderedTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: OrderedEnumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: OrderedEnumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createCachedTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator available only on cached sequences.
  *
@@ -542,13 +527,12 @@ declare function createOrderedTerminalOperator<TSource, TArgs extends unknown[],
  * @group Factory Functions
  */
 declare function createCachedTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: CachedEnumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: CachedEnumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/enumerators/TyneqBaseEnumerator.d.ts
+
 /**
  * Abstract base class implementing the pull-iterator lifecycle for all Tyneq enumerators.
  *
@@ -569,50 +553,49 @@ declare function createCachedTerminalOperator<TSource, TArgs extends unknown[],
  * @group Plugin
  */
 declare abstract class TyneqBaseEnumerator<TInput, TOutput = TInput> implements Enumerator<TOutput> {
-  private _initialized;
-  private _completed;
-  constructor();
-  /** Advances the iterator, calling `initialize()` on first call. Idempotent after completion. */
-  next(): IteratorResult<TOutput>;
-  /** Terminates iteration early, disposes resources, and marks completed. Idempotent. */
-  return(value?: unknown): IteratorResult<TOutput>;
-  /** Called once before the first `handleNext()` invocation. Override to set up state. */
-  protected initialize(): void;
-  /** Wraps `value` in a non-done `IteratorResult`. */
-  protected yield(value: TOutput): IteratorResult<TOutput>;
-  /** Returns a done `IteratorResult`. */
-  protected done(): IteratorResult<TOutput>;
-  /**
-   * Marks the enumerator completed and yields `value` as the final element.
-   *
-   * @remarks
-   * Use when the last element must be emitted together with completion in one step.
-   */
-  protected doneWithYield(value: TOutput): IteratorResult<TOutput>;
-  /**
-   * Disposes resources, marks completed, and returns a done result.
-   *
-   * @remarks
-   * Use inside `handleNext()` to terminate iteration before the source is exhausted.
-   */
-  protected earlyComplete(reason?: unknown): IteratorResult<TOutput>;
-  /** Calls `disposeSource()` then `disposeAdditional()`. */
-  protected dispose(value?: unknown): void;
-  /** Override to dispose the upstream source enumerator. */
-  protected disposeSource(): void;
-  /**
-   * Override to release any additional resources.
-   *
-   * @remarks
-   * Called after `disposeSource()`. `value` is the return value passed to `return()`.
-   * Must be idempotent and must not throw.
-   */
-  protected disposeAdditional(_value?: unknown): void;
-  /** Produces the next element. Return `{ done: true }` to signal exhaustion. */
-  protected abstract handleNext(): IteratorResult<TOutput>;
+    private _initialized;
+    private _completed;
+    constructor();
+    /** Advances the iterator, calling `initialize()` on first call. Idempotent after completion. */
+    next(): IteratorResult<TOutput>;
+    /** Terminates iteration early, disposes resources, and marks completed. Idempotent. */
+    return(value?: unknown): IteratorResult<TOutput>;
+    /** Called once before the first `handleNext()` invocation. Override to set up state. */
+    protected initialize(): void;
+    /** Wraps `value` in a non-done `IteratorResult`. */
+    protected yield(value: TOutput): IteratorResult<TOutput>;
+    /** Returns a done `IteratorResult`. */
+    protected done(): IteratorResult<TOutput>;
+    /**
+     * Marks the enumerator completed and yields `value` as the final element.
+     *
+     * @remarks
+     * Use when the last element must be emitted together with completion in one step.
+     */
+    protected doneWithYield(value: TOutput): IteratorResult<TOutput>;
+    /**
+     * Disposes resources, marks completed, and returns a done result.
+     *
+     * @remarks
+     * Use inside `handleNext()` to terminate iteration before the source is exhausted.
+     */
+    protected earlyComplete(reason?: unknown): IteratorResult<TOutput>;
+    /** Calls `disposeSource()` then `disposeAdditional()`. */
+    protected dispose(value?: unknown): void;
+    /** Override to dispose the upstream source enumerator. */
+    protected disposeSource(): void;
+    /**
+     * Override to release any additional resources.
+     *
+     * @remarks
+     * Called after `disposeSource()`. `value` is the return value passed to `return()`.
+     * Must be idempotent and must not throw.
+     */
+    protected disposeAdditional(_value?: unknown): void;
+    /** Produces the next element. Return `{ done: true }` to signal exhaustion. */
+    protected abstract handleNext(): IteratorResult<TOutput>;
 }
-//#endregion
-//#region src/core/enumerators/TyneqEnumerator.d.ts
+
 /**
  * Base class for all pipeline operator enumerators (streaming and buffering).
  *
@@ -626,13 +609,12 @@ declare abstract class TyneqBaseEnumerator<TInput, TOutput = TInput> implements
  * @group Plugin
  */
 declare abstract class TyneqEnumerator<TInput, TOutput = TInput> extends TyneqBaseEnumerator<TInput, TOutput> {
-  protected readonly sourceEnumerator: Enumerator<TInput>;
-  private sourceDisposed;
-  constructor(sourceEnumerator: Enumerator<TInput>);
-  protected disposeSource(): void;
+    protected readonly sourceEnumerator: Enumerator<TInput>;
+    private sourceDisposed;
+    constructor(sourceEnumerator: Enumerator<TInput>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/enumerators/TyneqOrderedEnumerator.d.ts
+
 /**
  * Base class for enumerators that need the full ordered sequence (not just an Enumerator<T>).
  * Lifecycle of the source is owned by the sequence, not the enumerator.
@@ -641,12 +623,11 @@ declare abstract class TyneqEnumerator<TInput, TOutput = TInput> extends TyneqBa
  * @internal
  */
 declare abstract class TyneqOrderedEnumerator<TSource> extends TyneqBaseEnumerator<TSource> {
-  protected readonly orderedSource: OrderedEnumerable<TSource>;
-  constructor(orderedSource: OrderedEnumerable<TSource>);
-  protected disposeSource(): void;
+    protected readonly orderedSource: OrderedEnumerable<TSource>;
+    constructor(orderedSource: OrderedEnumerable<TSource>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/enumerators/TyneqCachedEnumerator.d.ts
+
 /**
  * Base class for enumerators that need the full cached sequence (not just an Enumerator<T>).
  * Lifecycle of the source is owned by the sequence, not the enumerator.
@@ -655,12 +636,11 @@ declare abstract class TyneqOrderedEnumerator<TSource> extends TyneqBaseEnumerat
  * @internal
  */
 declare abstract class TyneqCachedEnumerator<TSource> extends TyneqBaseEnumerator<TSource> {
-  protected readonly cachedSource: CachedEnumerable<TSource>;
-  constructor(cachedSource: CachedEnumerable<TSource>);
-  protected disposeSource(): void;
+    protected readonly cachedSource: CachedEnumerable<TSource>;
+    constructor(cachedSource: CachedEnumerable<TSource>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/terminal/TyneqTerminalOperator.d.ts
+
 /**
  * Abstract base for all terminal operators.
  *
@@ -674,13 +654,12 @@ declare abstract class TyneqCachedEnumerator<TSource> extends TyneqBaseEnumerato
  * @group Plugin
  */
 declare abstract class TyneqTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: Enumerable<TSource>;
-  constructor(source: Enumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: Enumerable<TSource>;
+    constructor(source: Enumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-//#region src/core/terminal/TyneqOrderedTerminalOperator.d.ts
+
 /**
  * Abstract base for terminal operators that require a fully ordered sequence.
  *
@@ -694,13 +673,12 @@ declare abstract class TyneqTerminalOperator<TSource, TResult = TSource> {
  * @group Plugin
  */
 declare abstract class TyneqOrderedTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: OrderedEnumerable<TSource>;
-  constructor(source: OrderedEnumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: OrderedEnumerable<TSource>;
+    constructor(source: OrderedEnumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-//#region src/core/terminal/TyneqCachedTerminalOperator.d.ts
+
 /**
  * Abstract base for terminal operators that require a fully cached sequence.
  *
@@ -714,11 +692,10 @@ declare abstract class TyneqOrderedTerminalOperator<TSource, TResult = TSource>
  * @group Plugin
  */
 declare abstract class TyneqCachedTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: CachedEnumerable<TSource>;
-  constructor(source: CachedEnumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: CachedEnumerable<TSource>;
+    constructor(source: CachedEnumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-export { operator as S, cachedTerminal as _, TyneqOrderedEnumerator as a, cachedOperator as b, createCachedTerminalOperator as c, createCachedOperator as d, TyneqCachedEnumerable as f, createOperator as g, createGeneratorOperator as h, TyneqCachedEnumerator as i, createOrderedTerminalOperator as l, TyneqOrderedEnumerable as m, TyneqOrderedTerminalOperator as n, TyneqEnumerator as o, createOrderedOperator as p, TyneqTerminalOperator as r, TyneqBaseEnumerator as s, TyneqCachedTerminalOperator as t, createTerminalOperator as u, orderedTerminal as v, orderedOperator as x, terminal as y };
-//# sourceMappingURL=TyneqCachedTerminalOperator.d.ts.map
+
+export { TyneqBaseEnumerator as T, TyneqCachedEnumerator as a, TyneqCachedTerminalOperator as b, TyneqEnumerator as c, TyneqOrderedEnumerator as d, TyneqOrderedTerminalOperator as e, TyneqTerminalOperator as f, cachedOperator as g, cachedTerminal as h, createCachedOperator as i, createCachedTerminalOperator as j, createGeneratorOperator as k, createOperator as l, createOrderedOperator as m, createOrderedTerminalOperator as n, createTerminalOperator as o, operator as p, orderedOperator as q, orderedTerminal as r, TyneqCachedEnumerable as s, terminal as t, TyneqOrderedEnumerable as u };