linqx 0.2.1 → 0.3.3

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,79 @@ import Enumerable from "linqx";
 
 const items: Enumerable.IEnumerable<number> = Enumerable.from([1, 2, 3]);
 ```
+
+## Repeated Enumeration
+
+You can enumerate an `IEnumerable<T>` again only if its source supports it. With arrays,
+maps, and sets, each enumeration starts a new iterator. This also applies to the
+`asEnumerable()` extensions for arrays, maps, and DOM collections.
+
+A generator object or an existing iterator has a consumption position. Wrapping it with
+`Enumerable.from()` does not reset that position:
+
+```ts
+import Enumerable from "linqx";
+
+function* numbers() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+const once = Enumerable.from(numbers());
+
+once.toArray(); // [1, 2, 3]
+once.toArray(); // []: the generator object is exhausted
+```
+
+**For repeated enumeration of a generator or iterator, use the factory overload:
+`Enumerable.from(() => ...)`. Create a new generator or iterator inside the callback.**
+
+```ts
+const reusable = Enumerable.from(() => numbers());
+
+reusable.toArray(); // [1, 2, 3]
+reusable.toArray(); // [1, 2, 3]
+
+const query = reusable.where(value => value > 1).select(value => value * 10);
+
+query.toArray(); // [20, 30]
+query.toArray(); // [20, 30]
+
+const values = new Set([1, 2, 3]);
+const entries = Enumerable.from(() => values.entries());
+
+entries.toArray(); // [[1, 1], [2, 2], [3, 3]]
+entries.toArray(); // [[1, 1], [2, 2], [3, 3]]
+```
+
+Returning an existing iterator from the callback still shares its consumption position:
+
+```ts
+const iterator = numbers();
+const stillOnce = Enumerable.from(() => iterator);
+
+stillOnce.toArray(); // [1, 2, 3]
+stillOnce.toArray(); // []: the callback returns the same iterator
+```
+
+Early termination matters too: calling `any()`, `first()`, or `take(1).toArray()` on a
+wrapped generator object closes that generator, so later enumeration returns no values.
+Use a factory if you need to enumerate again after these operations.
+
+With a factory, you rerun the generator and query callbacks on each enumeration, including
+their side effects. Results can change if the underlying data changes. To reuse cached
+values, call `memoize()` before consuming the sequence. Calling `share()` instead opts
+into sharing one forward-only iterator among consumers.
+
+## Tutorial
+
+Build the package and run the TypeScript tutorial:
+
+```bash
+pnpm tutorial
+```
+
 ---
 
 ## New API Examples
@@ -134,9 +219,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 +278,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,15 @@
+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>>;
+}
+//# sourceMappingURL=dictionary.d.ts.map

package/dist/core/dictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary.d.ts","sourceRoot":"","sources":["../../src/core/dictionary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAS1E,qBAAa,UAAU,CAAC,IAAI,EAAE,MAAM,CAAE,YAAW,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;IAG5D,OAAO,CAAC,QAAQ,CAAC,eAAe;IAF5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IAEnE,YAA6B,eAAe,GAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAkB,EAAI;IAEnF,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAElC;IAED,GAAG,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM,CAErB;IAED,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAKrC;IAED,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAE3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,MAAM,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAEtB;IAED,KAAK,IAAI,MAAM,CAEd;IAED,YAAY,IAAI,WAAW,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAUtD;CACF"}

package/dist/core/enumerable.d.ts

@@ -0,0 +1,10 @@
+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> {
+}
+//# sourceMappingURL=enumerable.d.ts.map

package/dist/core/enumerable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumerable.d.ts","sourceRoot":"","sources":["../../src/core/enumerable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG5D,qBAAa,kBAAkB,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe;IAA5C,YAA6B,eAAe,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,EAAI;IAEnE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAE/B;IAED,aAAa,IAAI,WAAW,CAAC,CAAC,CAAC,CAE9B;CACF;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;CAAG"}

package/dist/core/enumerator.d.ts

@@ -0,0 +1,11 @@
+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;
+}
+//# sourceMappingURL=enumerator.d.ts.map

package/dist/core/enumerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumerator.d.ts","sourceRoot":"","sources":["../../src/core/enumerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAItC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAHrC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,IAAI,CAAS;IAErB,YAA6B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAI;IAEtD,OAAO,IAAI,CAAC,CAEX;IAED,QAAQ,IAAI,OAAO,CAalB;IAED,OAAO,IAAI,IAAI,CAGd;CACF"}

package/dist/core/grouping.d.ts

@@ -0,0 +1,12 @@
+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> {
+}
+//# sourceMappingURL=grouping.d.ts.map

package/dist/core/grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouping.d.ts","sourceRoot":"","sources":["../../src/core/grouping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,qBAAa,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAE,SAAQ,kBAAkB,CAAC,QAAQ,CAAC;IAC5D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAAQ,OAAO,CAAC,QAAQ,CAAC,MAAM;IAApE,YAA6B,QAAQ,EAAE,IAAI,EAAmB,MAAM,EAAE,QAAQ,EAAE,EAE/E;IAED,GAAG,IAAI,IAAI,CAEV;IAED,SAAS,IAAI,QAAQ,EAAE,CAEtB;CACF;AAED,MAAM,WAAW,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAE,SAAQ,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC;CAAG"}

package/dist/core/lookup.d.ts

@@ -0,0 +1,13 @@
+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>>;
+}
+//# sourceMappingURL=lookup.d.ts.map

package/dist/core/lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../src/core/lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AASzC,qBAAa,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAE,YAAW,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;IAGxD,OAAO,CAAC,QAAQ,CAAC,eAAe;IAF5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmD;IAE3E,YAA6B,eAAe,GAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAkB,EAAI;IAEnF,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI,CAStC;IAED,KAAK,IAAI,MAAM,CAEd;IAED,GAAG,CAAC,GAAG,EAAE,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,CAGpC;IAED,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAE3B;IAED,YAAY,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAOpD;CACF"}

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

@@ -0,0 +1,13 @@
+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> {
+}
+//# sourceMappingURL=memoized-enumerable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoized-enumerable.d.ts","sourceRoot":"","sources":["../../src/core/memoized-enumerable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC9D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IACjC,OAAO,CAAC,SAAS,CAAS;IAE1B,YAAY,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAY9B;IAED,OAAO,CAAC,MAAM;IAmBd,OAAO,IAAI,IAAI,CAOd;CACF;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,qBAAqB,CAAC,CAAC,CAAC;CAAG"}

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

@@ -0,0 +1,15 @@
+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> {
+}
+//# sourceMappingURL=ordered-enumerable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ordered-enumerable.d.ts","sourceRoot":"","sources":["../../src/core/ordered-enumerable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,iBAAiB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,CAAC,CAAC,CAAC,EAAE;IAAxF,YAAqB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAW,QAAQ,EAAE,SAAS,aAAa,CAAC,CAAC,CAAC,EAAE,EAmBvF;CACF;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;CAAG"}

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

@@ -0,0 +1,11 @@
+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> {
+}
+//# sourceMappingURL=shared-enumerable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared-enumerable.d.ts","sourceRoot":"","sources":["../../src/core/shared-enumerable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAC7C,OAAO,CAAC,QAAQ,CAAS;IAEzB,YAAY,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAa9B;IAED,OAAO,IAAI,IAAI,CAOd;CACF;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,qBAAqB,CAAC,CAAC,CAAC;CAAG"}

package/dist/extensions.d.ts

@@ -0,0 +1,19 @@
+import { Enumerable } from './index.js';
+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>;
+    }
+}
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC;QAChB,YAAY,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAChD;IAED,UAAU,KAAK,CAAC,CAAC;QACf,YAAY,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;KAC3C;IAED,UAAU,YAAY;QACpB,YAAY,IAAI,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;KAC9C;IAED,UAAU,QAAQ;QAChB,YAAY,IAAI,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;KAC9C;IAED,UAAU,cAAc;QACtB,YAAY,IAAI,UAAU,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;KACjD;CACF"}

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,9 @@
+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>;
+//# sourceMappingURL=choice.d.ts.map

package/dist/factories/choice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice.d.ts","sourceRoot":"","sources":["../../src/factories/choice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAOxD"}

package/dist/factories/cycle.d.ts

@@ -0,0 +1,9 @@
+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>;
+//# sourceMappingURL=cycle.d.ts.map

package/dist/factories/cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.d.ts","sourceRoot":"","sources":["../../src/factories/cycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAMvD"}

package/dist/factories/defer.d.ts

@@ -0,0 +1,9 @@
+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>;
+//# sourceMappingURL=defer.d.ts.map

package/dist/factories/defer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.d.ts","sourceRoot":"","sources":["../../src/factories/defer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAEtE"}

package/dist/factories/empty.d.ts

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

package/dist/factories/empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["../../src/factories/empty.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,2DAA2D;AAC3D,wBAAgB,KAAK,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAEzC"}

package/dist/factories/from.d.ts

@@ -0,0 +1,47 @@
+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;
+}>;
+//# sourceMappingURL=from.d.ts.map

package/dist/factories/from.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from.d.ts","sourceRoot":"","sources":["../../src/factories/from.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,kCAAkC;AAClC,wBAAgB,IAAI,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,GACnF,WAAW,CAAC,CAAC,CAAC,CAAC;AAElB;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,IAAI,SAAS,WAAW,EAAE,MAAM,EACnD,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,WAAW,CAAC;IACb,0BAA0B;IAC1B,GAAG,EAAE,IAAI,CAAC;IACV,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAAC"}

package/dist/factories/generate.d.ts

@@ -0,0 +1,10 @@
+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>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/factories/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/factories/generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAMzE"}

package/dist/factories/make.d.ts

@@ -0,0 +1,9 @@
+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>;
+//# sourceMappingURL=make.d.ts.map

package/dist/factories/make.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make.d.ts","sourceRoot":"","sources":["../../src/factories/make.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAIlD"}

package/dist/factories/matches.d.ts

@@ -0,0 +1,15 @@
+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>;
+//# sourceMappingURL=matches.d.ts.map

package/dist/factories/matches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.d.ts","sourceRoot":"","sources":["../../src/factories/matches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EACnE,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,WAAW,CAAC,CAAC,CAAC,CA0BhB"}

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

@@ -0,0 +1,11 @@
+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>;
+//# sourceMappingURL=range-down.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range-down.d.ts","sourceRoot":"","sources":["../../src/factories/range-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,WAAW,CAAC,MAAM,CAAC,CAErF"}

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

@@ -0,0 +1,13 @@
+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>;
+//# sourceMappingURL=range-to.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range-to.d.ts","sourceRoot":"","sources":["../../src/factories/range-to.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,WAAW,CAAC,MAAM,CAAC,CAahF"}

package/dist/factories/range.d.ts

@@ -0,0 +1,11 @@
+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>;
+//# sourceMappingURL=range.d.ts.map

package/dist/factories/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/factories/range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,WAAW,CAAC,MAAM,CAAC,CAMjF"}

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

@@ -0,0 +1,10 @@
+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>;
+//# sourceMappingURL=repeat-with-finalize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repeat-with-finalize.d.ts","sourceRoot":"","sources":["../../src/factories/repeat-with-finalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,WAAW,EAAE,MAAM,CAAC,EACpB,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,GAC9B,WAAW,CAAC,CAAC,CAAC,CAYhB"}

package/dist/factories/repeat.d.ts

@@ -0,0 +1,10 @@
+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>;
+//# sourceMappingURL=repeat.d.ts.map

package/dist/factories/repeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../src/factories/repeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAMpE"}

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

@@ -0,0 +1,10 @@
+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>;
+//# sourceMappingURL=to-infinity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-infinity.d.ts","sourceRoot":"","sources":["../../src/factories/to-infinity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAI,EAAE,IAAI,SAAI,GAAG,WAAW,CAAC,MAAM,CAAC,CAMnE"}

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

@@ -0,0 +1,10 @@
+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>;
+//# sourceMappingURL=to-negative-infinity.d.ts.map