linqx 0.2.0 → 0.3.2

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>;

package/dist/operators/chunk.d.ts

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

package/dist/operators/concat.d.ts

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

package/dist/operators/contains.d.ts

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

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

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

package/dist/operators/count.d.ts

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

package/dist/operators/create-ordered-enumerable.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function createOrderedEnumerable<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>, descending?: boolean): IOrderedEnumerable<T>;

package/dist/operators/default-if-empty.d.ts

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

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

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

package/dist/operators/distinct-until-changed.d.ts

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

package/dist/operators/distinct.d.ts

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

package/dist/operators/do-action.d.ts

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

package/dist/operators/element-at-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function elementAtOrDefault<T>(this: IEnumerable<T>, index: number, defaultValue?: T): T | undefined;

package/dist/operators/element-at.d.ts

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

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

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function exceptBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<TKey>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/except.d.ts

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

package/dist/operators/finally-action.d.ts

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

package/dist/operators/first-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function firstOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/first.d.ts

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

package/dist/operators/flatten.d.ts

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

package/dist/operators/for-each.d.ts

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

package/dist/operators/force.d.ts

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

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

@@ -0,0 +1,2 @@
+import type { IEnumerable, IGrouping } from '../types.js';
+export declare function groupBy<T, TKey, TElement = T, TResult = IGrouping<TKey, TElement>>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, resultSelector?: ((key: TKey, elements: IEnumerable<TElement>) => TResult) | undefined, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/group-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function groupJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: IEnumerable<TInner>) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/index-of.d.ts

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

package/dist/operators/index.d.ts

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

package/dist/operators/insert.d.ts

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

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

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function intersectBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<TKey>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/intersect.d.ts

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

package/dist/operators/is-empty.d.ts

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

package/dist/operators/join-with.d.ts

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

package/dist/operators/join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function join<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/last-index-of.d.ts

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

package/dist/operators/last-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function lastOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/last.d.ts

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

package/dist/operators/left-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function leftJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner | null) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/let-bind.d.ts

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

package/dist/operators/log.d.ts

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

package/dist/operators/map.d.ts

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

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

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

package/dist/operators/max.d.ts

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

package/dist/operators/memoize.d.ts

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

package/dist/operators/merge.d.ts

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

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

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

package/dist/operators/min.d.ts

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

package/dist/operators/of-type.d.ts

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

package/dist/operators/operators.d.ts

@@ -0,0 +1,208 @@
+import { aggregate } from './aggregate.js';
+import { aggregateBy } from './aggregate-by.js';
+import { all } from './all.js';
+import { alternate } from './alternate.js';
+import { any } from './any.js';
+import { append } from './append.js';
+import { asEnumerable } from './as-enumerable.js';
+import { average } from './average.js';
+import { buffer } from './buffer.js';
+import { cast } from './cast.js';
+import { catchError } from './catch-error.js';
+import { choose } from './choose.js';
+import { chunk } from './chunk.js';
+import { concat } from './concat.js';
+import { contains } from './contains.js';
+import { count } from './count.js';
+import { countBy } from './count-by.js';
+import { createOrderedEnumerable } from './create-ordered-enumerable.js';
+import { defaultIfEmpty } from './default-if-empty.js';
+import { distinct } from './distinct.js';
+import { distinctBy } from './distinct-by.js';
+import { distinctUntilChanged } from './distinct-until-changed.js';
+import { doAction } from './do-action.js';
+import { elementAt } from './element-at.js';
+import { elementAtOrDefault } from './element-at-or-default.js';
+import { except } from './except.js';
+import { exceptBy } from './except-by.js';
+import { finallyAction } from './finally-action.js';
+import { first } from './first.js';
+import { firstOrDefault } from './first-or-default.js';
+import { flatten } from './flatten.js';
+import { force } from './force.js';
+import { forEach } from './for-each.js';
+import { groupBy } from './group-by.js';
+import { groupJoin } from './group-join.js';
+import { index } from './index.js';
+import { indexOf } from './index-of.js';
+import { insert } from './insert.js';
+import { intersect } from './intersect.js';
+import { intersectBy } from './intersect-by.js';
+import { isEmpty } from './is-empty.js';
+import { join } from './join.js';
+import { joinWith } from './join-with.js';
+import { last } from './last.js';
+import { lastIndexOf } from './last-index-of.js';
+import { lastOrDefault } from './last-or-default.js';
+import { leftJoin } from './left-join.js';
+import { letBind } from './let-bind.js';
+import { log } from './log.js';
+import { map } from './map.js';
+import { max } from './max.js';
+import { maxBy } from './max-by.js';
+import { memoize } from './memoize.js';
+import { merge } from './merge.js';
+import { min } from './min.js';
+import { minBy } from './min-by.js';
+import { ofType } from './of-type.js';
+import { orderBy } from './order-by.js';
+import { orderByDescending } from './order-by-descending.js';
+import { page } from './page.js';
+import { pairwise } from './pairwise.js';
+import { partitionBy } from './partition-by.js';
+import { position } from './position.js';
+import { prepend } from './prepend.js';
+import { reverse } from './reverse.js';
+import { rightJoin } from './right-join.js';
+import { scan } from './scan.js';
+import { select } from './select.js';
+import { selectMany } from './select-many.js';
+import { sequenceEqual } from './sequence-equal.js';
+import { share } from './share.js';
+import { shuffle } from './shuffle.js';
+import { single } from './single.js';
+import { singleOrDefault } from './single-or-default.js';
+import { skip } from './skip.js';
+import { skipLast } from './skip-last.js';
+import { skipWhile } from './skip-while.js';
+import { sum } from './sum.js';
+import { take } from './take.js';
+import { takeExceptLast } from './take-except-last.js';
+import { takeFromLast } from './take-from-last.js';
+import { takeLast } from './take-last.js';
+import { takeWhile } from './take-while.js';
+import { thenBy } from './then-by.js';
+import { thenByDescending } from './then-by-descending.js';
+import { toArray } from './to-array.js';
+import { toDictionary } from './to-dictionary.js';
+import { toJoinedString } from './to-joined-string.js';
+import { toJSONString } from './to-json-string.js';
+import { toLookup } from './to-lookup.js';
+import { toMap } from './to-map.js';
+import { toObject } from './to-object.js';
+import { toSet } from './to-set.js';
+import { trace } from './trace.js';
+import { traverseBreadthFirst } from './traverse-breadth-first.js';
+import { traverseDepthFirst } from './traverse-depth-first.js';
+import { union } from './union.js';
+import { unionBy } from './union-by.js';
+import { weightedSample } from './weighted-sample.js';
+import { where } from './where.js';
+import { whereIf } from './where-if.js';
+import { withNeighbors } from './with-neighbors.js';
+import { zip } from './zip.js';
+export declare const instanceOperators: {
+    aggregate: typeof aggregate;
+    aggregateBy: typeof aggregateBy;
+    all: typeof all;
+    alternate: typeof alternate;
+    any: typeof any;
+    append: typeof append;
+    asEnumerable: typeof asEnumerable;
+    average: typeof average;
+    buffer: typeof buffer;
+    cast: typeof cast;
+    catchError: typeof catchError;
+    choose: typeof choose;
+    chunk: typeof chunk;
+    concat: typeof concat;
+    contains: typeof contains;
+    count: typeof count;
+    countBy: typeof countBy;
+    createOrderedEnumerable: typeof createOrderedEnumerable;
+    defaultIfEmpty: typeof defaultIfEmpty;
+    distinct: typeof distinct;
+    distinctBy: typeof distinctBy;
+    distinctUntilChanged: typeof distinctUntilChanged;
+    doAction: typeof doAction;
+    elementAt: typeof elementAt;
+    elementAtOrDefault: typeof elementAtOrDefault;
+    except: typeof except;
+    exceptBy: typeof exceptBy;
+    finallyAction: typeof finallyAction;
+    first: typeof first;
+    firstOrDefault: typeof firstOrDefault;
+    flatten: typeof flatten;
+    force: typeof force;
+    forEach: typeof forEach;
+    groupBy: typeof groupBy;
+    groupJoin: typeof groupJoin;
+    index: typeof index;
+    indexOf: typeof indexOf;
+    insert: typeof insert;
+    intersect: typeof intersect;
+    intersectBy: typeof intersectBy;
+    isEmpty: typeof isEmpty;
+    join: typeof join;
+    joinWith: typeof joinWith;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    lastOrDefault: typeof lastOrDefault;
+    leftJoin: typeof leftJoin;
+    letBind: typeof letBind;
+    log: typeof log;
+    map: typeof map;
+    max: typeof max;
+    maxBy: typeof maxBy;
+    memoize: typeof memoize;
+    merge: typeof merge;
+    min: typeof min;
+    minBy: typeof minBy;
+    ofType: typeof ofType;
+    orderBy: typeof orderBy;
+    orderByDescending: typeof orderByDescending;
+    page: typeof page;
+    pairwise: typeof pairwise;
+    partitionBy: typeof partitionBy;
+    position: typeof position;
+    prepend: typeof prepend;
+    reverse: typeof reverse;
+    rightJoin: typeof rightJoin;
+    scan: typeof scan;
+    select: typeof select;
+    selectMany: typeof selectMany;
+    sequenceEqual: typeof sequenceEqual;
+    share: typeof share;
+    shuffle: typeof shuffle;
+    single: typeof single;
+    singleOrDefault: typeof singleOrDefault;
+    skip: typeof skip;
+    skipLast: typeof skipLast;
+    skipWhile: typeof skipWhile;
+    sum: typeof sum;
+    take: typeof take;
+    takeExceptLast: typeof takeExceptLast;
+    takeFromLast: typeof takeFromLast;
+    takeLast: typeof takeLast;
+    takeWhile: typeof takeWhile;
+    thenBy: typeof thenBy;
+    thenByDescending: typeof thenByDescending;
+    toArray: typeof toArray;
+    toDictionary: typeof toDictionary;
+    toJoinedString: typeof toJoinedString;
+    toJSONString: typeof toJSONString;
+    toLookup: typeof toLookup;
+    toMap: typeof toMap;
+    toObject: typeof toObject;
+    toSet: typeof toSet;
+    trace: typeof trace;
+    traverseBreadthFirst: typeof traverseBreadthFirst;
+    traverseDepthFirst: typeof traverseDepthFirst;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    weightedSample: typeof weightedSample;
+    where: typeof where;
+    whereIf: typeof whereIf;
+    withNeighbors: typeof withNeighbors;
+    zip: typeof zip;
+};

package/dist/operators/order-by-descending.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IEnumerable, IOrderedEnumerable } from '../types.js';
+export declare function orderByDescending<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

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

@@ -0,0 +1,2 @@
+import type { Comparer, IEnumerable, IOrderedEnumerable } from '../types.js';
+export declare function orderBy<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/page.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, IPageInfo } from '../types.js';
+export declare function page<T>(this: IEnumerable<T>, pageNumberOrInfo: number | IPageInfo, pageSize?: number): IEnumerable<T>;

package/dist/operators/pairwise.d.ts

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