linqx 0.2.1 → 0.3.2

package/README.md

@@ -4,7 +4,7 @@ Modern fork of the original [linq](https://github.com/mihaifm/linq) for JavaScri
 
 linqx keeps the familiar LINQ-style API while adding modern exports, new utility methods, improved TypeScript support, and active maintenance.
 
-Written in pure JavaScript with no runtime dependencies.
+Written in TypeScript with no runtime dependencies.
 
 ---
 
@@ -66,6 +66,18 @@ chunk(size)
 index()
 position()
 withNeighbors()
+append(element)
+prepend(element)
+skipLast(count)
+takeLast(count)
+distinctBy(keySelector)
+exceptBy(keys, keySelector)
+intersectBy(keys, keySelector)
+unionBy(sequence, keySelector)
+countBy(keySelector)
+aggregateBy(keySelector, seed, accumulator)
+rightJoin(sequence, outerKeySelector, innerKeySelector, resultSelector)
+toSet()
 ```
 
 ---
@@ -80,7 +92,7 @@ npm install linqx
 
 # Usage
 
-## ES Modules 
+## ES Modules
 
 ```ts
 import Enumerable from "linqx";
@@ -111,6 +123,15 @@ import Enumerable from "linqx";
 
 const items: Enumerable.IEnumerable<number> = Enumerable.from([1, 2, 3]);
 ```
+
+## Tutorial
+
+Build the package and run the TypeScript tutorial:
+
+```bash
+pnpm tutorial
+```
+
 ---
 
 ## New API Examples
@@ -134,9 +155,54 @@ for (const { prev, item, next } of Enumerable.from([10, 20, 30]).withNeighbors()
 }
 
 // position
-for (const { index, item, isFirst, isLast } of Enumerable.from(["a", "b", "c"]).position()) {  
+for (const { index, item, isFirst, isLast } of Enumerable.from(["a", "b", "c"]).position()) {
 }
+
+// Standard sequence helpers
+Enumerable.from([2, 3]).prepend(1).append(4).toArray();
+// result: [1, 2, 3, 4]
+
+Enumerable.from([1, 2, 3, 4]).skipLast(2).toArray();
+// result: [1, 2]
+
+Enumerable.from([1, 2, 3, 4]).takeLast(2).toArray();
+// result: [3, 4]
+
+// Key-based set operations
+Enumerable
+  .from([{ id: 1, name: "first" }, { id: 1, name: "second" }])
+  .distinctBy(item => item.id)
+  .toArray();
+// result: [{ id: 1, name: "first" }]
+
+Enumerable
+  .from([{ id: 1 }, { id: 2 }, { id: 3 }])
+  .exceptBy([2], item => item.id)
+  .toArray();
+// result: [{ id: 1 }, { id: 3 }]
+
+// Per-key aggregation
+Enumerable
+  .from(["a", "b", "a"])
+  .countBy(value => value)
+  .toArray();
+// result: [{ key: "a", value: 2 }, { key: "b", value: 1 }]
+
+Enumerable
+  .from([{ category: "a", amount: 2 }, { category: "a", amount: 3 }])
+  .aggregateBy(item => item.category, 0, (sum, item) => sum + item.amount)
+  .toArray();
+// result: [{ key: "a", value: 5 }]
+
+// Native Set materialization
+Enumerable.from([1, 1, 2]).toSet();
 ```
+
+`countBy` and `aggregateBy` return
+`Enumerable.IEnumerable<Enumerable.KeyValuePair<TKey, TValue>>`. Key-based methods accept an
+optional final comparison selector when keys need normalization, such as
+`key => key.toLowerCase()` for case-insensitive string keys.
+
 ---
 
 # Migration from linq
@@ -148,6 +214,16 @@ Most projects can switch directly:
 +import Enumerable from "linqx";
 ```
 
+The original string Lambda syntax is no longer supported. Pass JavaScript functions instead:
+
+```ts
+// supported
+Enumerable.from([1, 2, 3, 4]).where(value => value % 2 === 0);
+
+// not supported
+Enumerable.from([1, 2, 3, 4]).where("value => value % 2 === 0");
+```
+
 ---
 
 # Repository

package/dist/core/dictionary.d.ts

@@ -0,0 +1,14 @@
+import type { IDictionary, IEnumerable, KeyValuePair } from '../types.js';
+export declare class Dictionary<TKey, TValue> implements IDictionary<TKey, TValue> {
+    private readonly compareSelector;
+    private readonly entries;
+    constructor(compareSelector?: (key: TKey) => unknown);
+    add(key: TKey, value: TValue): void;
+    get(key: TKey): TValue;
+    set(key: TKey, value: TValue): boolean;
+    contains(key: TKey): boolean;
+    clear(): void;
+    remove(key: TKey): void;
+    count(): number;
+    toEnumerable(): IEnumerable<KeyValuePair<TKey, TValue>>;
+}

package/dist/core/enumerable.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable, IEnumerator } from '../types.js';
+export declare class EnumerableSequence<T> implements Iterable<T> {
+    private readonly iteratorFactory;
+    constructor(iteratorFactory: () => Iterator<T>);
+    [Symbol.iterator](): Iterator<T>;
+    getEnumerator(): IEnumerator<T>;
+}
+export interface EnumerableSequence<T> extends IEnumerable<T> {
+}

package/dist/core/enumerator.d.ts

@@ -0,0 +1,10 @@
+import type { IEnumerator } from '../types.js';
+export declare class Enumerator<T> implements IEnumerator<T> {
+    private readonly iterator;
+    private value;
+    private done;
+    constructor(iterator: Iterator<T>);
+    current(): T;
+    moveNext(): boolean;
+    dispose(): void;
+}

package/dist/core/grouping.d.ts

@@ -0,0 +1,11 @@
+import { EnumerableSequence } from './enumerable.js';
+import type { IGrouping } from '../types.js';
+export declare class Grouping<TKey, TElement> extends EnumerableSequence<TElement> {
+    private readonly groupKey;
+    private readonly source;
+    constructor(groupKey: TKey, source: TElement[]);
+    key(): TKey;
+    getSource(): TElement[];
+}
+export interface Grouping<TKey, TElement> extends IGrouping<TKey, TElement> {
+}

package/dist/core/lookup.d.ts

@@ -0,0 +1,12 @@
+import type { IEnumerable, ILookup } from '../types.js';
+import { Grouping } from './grouping.js';
+export declare class Lookup<TKey, TElement> implements ILookup<TKey, TElement> {
+    private readonly compareSelector;
+    private readonly entries;
+    constructor(compareSelector?: (key: TKey) => unknown);
+    add(key: TKey, element: TElement): void;
+    count(): number;
+    get(key: TKey): IEnumerable<TElement>;
+    contains(key: TKey): boolean;
+    toEnumerable(): IEnumerable<Grouping<TKey, TElement>>;
+}

package/dist/core/memoized-enumerable.d.ts

@@ -0,0 +1,12 @@
+import type { IDisposableEnumerable } from '../types.js';
+import { EnumerableSequence } from './enumerable.js';
+export declare class MemoizedEnumerable<T> extends EnumerableSequence<T> {
+    private readonly sourceIterator;
+    private readonly cache;
+    private completed;
+    constructor(source: Iterable<T>);
+    private nextAt;
+    dispose(): void;
+}
+export interface MemoizedEnumerable<T> extends IDisposableEnumerable<T> {
+}

package/dist/core/ordered-enumerable.d.ts

@@ -0,0 +1,14 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+import { EnumerableSequence } from './enumerable.js';
+export interface SortCriterion<T> {
+    keySelector: (element: T) => unknown;
+    comparer: Comparer<unknown>;
+    descending: boolean;
+}
+export declare class OrderedEnumerable<T> extends EnumerableSequence<T> {
+    readonly source: Iterable<T>;
+    readonly criteria: readonly SortCriterion<T>[];
+    constructor(source: Iterable<T>, criteria: readonly SortCriterion<T>[]);
+}
+export interface OrderedEnumerable<T> extends IOrderedEnumerable<T> {
+}

package/dist/core/shared-enumerable.d.ts

@@ -0,0 +1,10 @@
+import type { IDisposableEnumerable } from '../types.js';
+import { EnumerableSequence } from './enumerable.js';
+export declare class SharedEnumerable<T> extends EnumerableSequence<T> {
+    private readonly sourceIterator;
+    private disposed;
+    constructor(source: Iterable<T>);
+    dispose(): void;
+}
+export interface SharedEnumerable<T> extends IDisposableEnumerable<T> {
+}

package/dist/extensions.d.ts

@@ -0,0 +1,18 @@
+import { Enumerable } from '.';
+declare global {
+    interface Map<K, V> {
+        asEnumerable(): Enumerable.IEnumerable<[K, V]>;
+    }
+    interface Array<T> {
+        asEnumerable(): Enumerable.IEnumerable<T>;
+    }
+    interface NamedNodeMap {
+        asEnumerable(): Enumerable.IEnumerable<Attr>;
+    }
+    interface NodeList {
+        asEnumerable(): Enumerable.IEnumerable<Node>;
+    }
+    interface HTMLCollection {
+        asEnumerable(): Enumerable.IEnumerable<Element>;
+    }
+}

package/dist/extensions.js

@@ -0,0 +1,13 @@
+import { n as e, t } from "./src-D_Mk3oMP.js";
+e(Array.prototype, "asEnumerable", function() {
+	return t.from(this);
+}), e(Map.prototype, "asEnumerable", function() {
+	return t.from(this);
+}), typeof document < "u" && (e(NamedNodeMap.prototype, "asEnumerable", function() {
+	return t.from(this);
+}), e(NodeList.prototype, "asEnumerable", function() {
+	return t.from(this);
+}), e(HTMLCollection.prototype, "asEnumerable", function() {
+	return t.from(this);
+}));
+//#endregion

package/dist/factories/choice.d.ts

@@ -0,0 +1,8 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates a sequence that randomly selects from a fixed set with replacement.
+ *
+ * @param values The candidate values.
+ * @returns An infinite deferred sequence, or an empty sequence when no values are supplied.
+ */
+export declare function choice<T>(...values: T[]): IEnumerable<T>;

package/dist/factories/cycle.d.ts

@@ -0,0 +1,8 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates a sequence that repeatedly emits a fixed set of values in order.
+ *
+ * @param values The values in each cycle.
+ * @returns An infinite deferred sequence, or an empty sequence when no values are supplied.
+ */
+export declare function cycle<T>(...values: T[]): IEnumerable<T>;

package/dist/factories/defer.d.ts

@@ -0,0 +1,8 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Defers creation of a sequence until enumeration begins.
+ *
+ * @param factory Creates the sequence used by each enumeration.
+ * @returns A deferred sequence that invokes `factory` once per enumeration.
+ */
+export declare function defer<T>(factory: () => IEnumerable<T>): IEnumerable<T>;

package/dist/factories/empty.d.ts

@@ -0,0 +1,3 @@
+import type { IEnumerable } from '../types.js';
+/** @returns A reusable sequence containing no elements. */
+export declare function empty<T>(): IEnumerable<T>;

package/dist/factories/from.d.ts

@@ -0,0 +1,46 @@
+import type { IEnumerable } from '../types.js';
+/** @returns An empty sequence. */
+export declare function from(): IEnumerable<unknown>;
+/**
+ * Wraps a number as a single-element sequence.
+ *
+ * @param source The number to wrap.
+ * @returns A sequence containing `source`.
+ */
+export declare function from(source: number): IEnumerable<number>;
+/**
+ * Wraps a boolean as a single-element sequence.
+ *
+ * @param source The boolean to wrap.
+ * @returns A sequence containing `source`.
+ */
+export declare function from(source: boolean): IEnumerable<boolean>;
+/**
+ * Enumerates the characters in a string.
+ *
+ * @param source The string to enumerate.
+ * @returns A reusable sequence of Unicode code-point strings.
+ */
+export declare function from(source: string): IEnumerable<string>;
+/**
+ * Converts an iterable, iterator, array-like object, or source factory to a linqx sequence.
+ *
+ * A source factory is called once per enumeration. A bare iterator is forward-only and is not
+ * reset between enumerations.
+ *
+ * @param source The source to adapt or a function that creates one.
+ * @returns A sequence over the source values.
+ */
+export declare function from<T>(source: Iterable<T> | Iterator<T> | ArrayLike<T> | (() => Iterable<T> | Iterator<T>)): IEnumerable<T>;
+/**
+ * Enumerates an object's own enumerable string-keyed, non-function properties.
+ *
+ * @param source The object whose properties will be enumerated.
+ * @returns A deferred sequence of key-value entries.
+ */
+export declare function from<TKey extends PropertyKey, TValue>(source: Record<TKey, TValue>): IEnumerable<{
+    /** The property's key. */
+    key: TKey;
+    /** The property's value. */
+    value: TValue;
+}>;

package/dist/factories/generate.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Generates elements by repeatedly invoking a function.
+ *
+ * @param func Produces the next element.
+ * @param count The number of elements to produce. Omit it for an infinite sequence.
+ * @returns A deferred generated sequence.
+ */
+export declare function generate<T>(func: () => T, count?: number): IEnumerable<T>;

package/dist/factories/make.d.ts

@@ -0,0 +1,8 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates a sequence containing exactly one element.
+ *
+ * @param element The element to contain.
+ * @returns A reusable single-element sequence.
+ */
+export declare function make<T>(element: T): IEnumerable<T>;

package/dist/factories/matches.d.ts

@@ -0,0 +1,14 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Enumerates every regular-expression match in a string.
+ *
+ * A cloned expression is made global automatically, so the supplied `RegExp.lastIndex` is not
+ * read or modified.
+ *
+ * @param input The string to search.
+ * @param pattern A regular expression or pattern string.
+ * @param flags Flags used only when `pattern` is a string; `g` is added when absent.
+ * @returns A deferred sequence of regular-expression match arrays.
+ * @throws {SyntaxError} When a pattern string or its flags are invalid.
+ */
+export declare function matches<T extends RegExpMatchArray = RegExpMatchArray>(input: string, pattern: RegExp | string, flags?: string): IEnumerable<T>;

package/dist/factories/range-down.d.ts

@@ -0,0 +1,10 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates a counted descending arithmetic sequence.
+ *
+ * @param start The first value.
+ * @param count The number of values; non-positive values produce an empty sequence.
+ * @param step The absolute decrement between consecutive values; defaults to one.
+ * @returns A deferred descending numeric sequence.
+ */
+export declare function rangeDown(start: number, count: number, step?: number): IEnumerable<number>;

package/dist/factories/range-to.d.ts

@@ -0,0 +1,12 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates an arithmetic sequence between two inclusive endpoints.
+ *
+ * The direction is inferred from the endpoints and the absolute value of `step` is used.
+ *
+ * @param start The first value.
+ * @param to The inclusive endpoint.
+ * @param step The non-zero distance between consecutive values; defaults to one.
+ * @returns A deferred numeric sequence.
+ */
+export declare function rangeTo(start: number, to: number, step?: number): IEnumerable<number>;

package/dist/factories/range.d.ts

@@ -0,0 +1,10 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates a counted arithmetic sequence.
+ *
+ * @param start The first value.
+ * @param count The number of values; non-positive values produce an empty sequence.
+ * @param step The difference between consecutive values; defaults to one.
+ * @returns A deferred numeric sequence.
+ */
+export declare function range(start: number, count: number, step?: number): IEnumerable<number>;

package/dist/factories/repeat-with-finalize.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Initializes one value, repeats it indefinitely, and finalizes it when enumeration stops.
+ *
+ * @param initializer Creates the value once per enumeration.
+ * @param finalizer Releases the value after completion, failure, or early termination.
+ * @returns An infinite deferred sequence with deterministic finalization.
+ */
+export declare function repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): IEnumerable<T>;

package/dist/factories/repeat.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Repeats one element.
+ *
+ * @param element The value to repeat.
+ * @param count The number of repetitions. Omit it for an infinite sequence.
+ * @returns A deferred repeated sequence.
+ */
+export declare function repeat<T>(element: T, count?: number): IEnumerable<T>;

package/dist/factories/to-infinity.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates an infinite ascending arithmetic sequence.
+ *
+ * @param start The first value; defaults to zero.
+ * @param step The amount added after each element; defaults to one.
+ * @returns An infinite deferred numeric sequence.
+ */
+export declare function toInfinity(start?: number, step?: number): IEnumerable<number>;

package/dist/factories/to-negative-infinity.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates an infinite descending arithmetic sequence.
+ *
+ * @param start The first value; defaults to zero.
+ * @param step The amount subtracted after each element; defaults to one.
+ * @returns An infinite deferred numeric sequence.
+ */
+export declare function toNegativeInfinity(start?: number, step?: number): IEnumerable<number>;

package/dist/factories/unfold.d.ts

@@ -0,0 +1,9 @@
+import type { IEnumerable } from '../types.js';
+/**
+ * Creates an infinite sequence by repeatedly transforming the previous value.
+ *
+ * @param seed The first value.
+ * @param func Produces the next value from the current value.
+ * @returns An infinite deferred sequence beginning with `seed`.
+ */
+export declare function unfold<T>(seed: T, func: (value: T) => T): IEnumerable<T>;

package/dist/index.d.ts

@@ -1,4 +1,88 @@
-import Enumerable from "./linq.js";
-import "./linqx.js";
+import { choice } from './factories/choice.js';
+import { cycle } from './factories/cycle.js';
+import { defer } from './factories/defer.js';
+import { empty } from './factories/empty.js';
+import { from } from './factories/from.js';
+import { generate } from './factories/generate.js';
+import { make } from './factories/make.js';
+import { matches } from './factories/matches.js';
+import { range } from './factories/range.js';
+import { rangeDown } from './factories/range-down.js';
+import { rangeTo } from './factories/range-to.js';
+import { repeat } from './factories/repeat.js';
+import { repeatWithFinalize } from './factories/repeat-with-finalize.js';
+import { toInfinity } from './factories/to-infinity.js';
+import { toNegativeInfinity } from './factories/to-negative-infinity.js';
+import { unfold } from './factories/unfold.js';
+import type { IDictionary as DictionaryInterface, IDisposableEnumerable as DisposableEnumerableInterface, IEnumerable as EnumerableInterface, IEnumerator as EnumeratorInterface, IGrouping as GroupingInterface, ILookup as LookupInterface, IOrderedEnumerable as OrderedEnumerableInterface, IPageInfo as PageInfo, Indexed as IndexedValue, KeyValuePair as Pair, Neighbors as NeighborValues, Positioned as PositionedValue } from './types.js';
+/** Entry point for creating and working with LINQ-style sequences. */
+export declare class Enumerable {
+    /** Low-level helpers for creating enumerables and extending iterable prototypes. */
+    static readonly Utils: import("./utils.js").EnumerableUtils;
+    /** Creates an infinite sequence that randomly chooses from the supplied values. */
+    static readonly choice: typeof choice;
+    /** Creates an infinite sequence that repeatedly emits the supplied values in order. */
+    static readonly cycle: typeof cycle;
+    /** Defers sequence creation until each enumeration begins. */
+    static readonly defer: typeof defer;
+    /** Creates an empty sequence. */
+    static readonly empty: typeof empty;
+    /** Converts an enumerable source, iterator, array-like value, object, or scalar to a sequence. */
+    static readonly from: typeof from;
+    /** Generates values by repeatedly invoking a function. */
+    static readonly generate: typeof generate;
+    /** Creates a sequence containing one element. */
+    static readonly make: typeof make;
+    /** Enumerates all regular-expression matches in a string. */
+    static readonly matches: typeof matches;
+    /** Creates a counted numeric sequence. */
+    static readonly range: typeof range;
+    /** Creates a counted descending numeric sequence. */
+    static readonly rangeDown: typeof rangeDown;
+    /** Creates an inclusive numeric sequence between two endpoints. */
+    static readonly rangeTo: typeof rangeTo;
+    /** Repeats an element a specified number of times or indefinitely. */
+    static readonly repeat: typeof repeat;
+    /** Repeats an initialized resource until enumeration stops, then finalizes it. */
+    static readonly repeatWithFinalize: typeof repeatWithFinalize;
+    /** Creates an infinite ascending numeric sequence. */
+    static readonly toInfinity: typeof toInfinity;
+    /** Creates an infinite descending numeric sequence. */
+    static readonly toNegativeInfinity: typeof toNegativeInfinity;
+    /** Creates an infinite sequence by repeatedly transforming the previous value. */
+    static readonly unfold: typeof unfold;
+}
+/** Type contracts exposed through the `Enumerable` namespace. */
+export declare namespace Enumerable {
+    /** A composable iterable sequence with LINQ-style query operators. */
+    type IEnumerable<T> = EnumerableInterface<T>;
+    /** An imperative cursor over a sequence. */
+    type IEnumerator<T> = EnumeratorInterface<T>;
+    /** A sequence with one or more stable ordering criteria. */
+    type IOrderedEnumerable<T> = OrderedEnumerableInterface<T>;
+    /** A sequence whose backing iterator can be explicitly released. */
+    type IDisposableEnumerable<T> = DisposableEnumerableInterface<T>;
+    /** A mutable key-value collection with optional normalized-key comparison. */
+    type IDictionary<TKey, TValue> = DictionaryInterface<TKey, TValue>;
+    /** A read-only one-to-many mapping. */
+    type ILookup<TKey, TElement> = LookupInterface<TKey, TElement>;
+    /** A sequence of elements associated with a key. */
+    type IGrouping<TKey, TElement> = GroupingInterface<TKey, TElement>;
+    /** A one-based page number and page size. */
+    type IPageInfo = PageInfo;
+    /** A key associated with one value. */
+    type KeyValuePair<TKey, TValue> = Pair<TKey, TValue>;
+    /** A sequence element paired with its zero-based index. */
+    type Indexed<T> = IndexedValue<T>;
+    /** A sequence element annotated with index and boundary information. */
+    type Positioned<T> = PositionedValue<T>;
+    /** A sequence element paired with its immediate neighbors. */
+    type Neighbors<T> = NeighborValues<T>;
+    /** @deprecated Use {@link Indexed} instead. */
+    type IndexedItem<T> = Indexed<T>;
+    /** @deprecated Use {@link Positioned} instead. */
+    type PositionedItem<T> = Positioned<T>;
+    /** @deprecated Use {@link Neighbors} instead. */
+    type ItemWithNeighbors<T> = Neighbors<T>;
+}
 export default Enumerable;
-export { Enumerable };

package/dist/index.js

@@ -1,4 +1,2 @@
-import Enumerable from "./linq.js";
-import "./linqx.js";
-export default Enumerable;
-export { Enumerable };
+import { t as e } from "./src-D_Mk3oMP.js";
+export { e as Enumerable, e as default };

package/dist/internal/create-enumerable.d.ts

@@ -0,0 +1,3 @@
+import type { IEnumerable } from '../types.js';
+export declare function createEnumerable<T>(iteratorFactory: () => Iterator<T>): IEnumerable<T>;
+export declare function fromGenerator<T>(generatorFactory: () => Generator<T>): IEnumerable<T>;

package/dist/internal/functions.d.ts

@@ -0,0 +1,6 @@
+import type { Comparer } from '../types.js';
+export declare const identity: <T>(value: T) => T;
+export declare function defaultComparer<T>(first: T, second: T): number;
+export declare function reverseComparer<T>(comparer: Comparer<T>): Comparer<T>;
+export declare function isIterable(value: unknown): value is Iterable<unknown>;
+export declare function isArrayLike(value: unknown): value is ArrayLike<unknown>;

package/dist/internal/to-iterable.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput } from '../types.js';
+export declare function toIterable<T>(source: EnumerableInput<T>): Iterable<T>;

package/dist/operators/aggregate-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, KeyValuePair } from '../types.js';
+export declare function aggregateBy<T, TKey, TAccumulate>(this: IEnumerable<T>, keySelector: (element: T) => TKey, seed: TAccumulate, accumulator: (accumulate: TAccumulate, element: T) => TAccumulate, compareSelector?: (key: TKey) => unknown): IEnumerable<KeyValuePair<TKey, TAccumulate>>;

package/dist/operators/aggregate.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function aggregate<T, TAccumulate, TResult>(this: IEnumerable<T>, seedOrFunc: TAccumulate | ((prev: T, current: T) => T), func?: (prev: TAccumulate, current: T) => TAccumulate, resultSelector?: (last: TAccumulate) => TResult): T | TAccumulate | TResult;

package/dist/operators/all.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function all<T>(this: IEnumerable<T>, predicate: (element: T) => boolean): boolean;

package/dist/operators/alternate.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function alternate<T>(this: IEnumerable<T>, alternateValue: T | EnumerableInput<T>): IEnumerable<T>;

package/dist/operators/any.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function any<T>(this: IEnumerable<T>, predicate?: (element: T) => boolean): boolean;

package/dist/operators/append.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function append<T>(this: IEnumerable<T>, element: T): IEnumerable<T>;

package/dist/operators/as-enumerable.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function asEnumerable<T>(this: IEnumerable<T>): IEnumerable<T>;

package/dist/operators/average.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function average<T>(this: IEnumerable<T>, selector?: (element: T) => number): number;

package/dist/operators/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function buffer<T>(this: IEnumerable<T>, count: number): IEnumerable<T[]>;

package/dist/operators/cast.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function cast<T, TResult>(this: IEnumerable<T>): IEnumerable<TResult>;

package/dist/operators/catch-error.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function catchError<T>(this: IEnumerable<T>, handler: (exception: unknown) => void): IEnumerable<T>;

package/dist/operators/choose.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function choose<T>(this: IEnumerable<T>, selector: (element: T, index: number) => T): IEnumerable<T>;