tyneq 1.0.0 → 1.0.2

package/dist/chunk-VJAICXA6.cjs

@@ -0,0 +1,3788 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkOWKUE3ACcjs = require('./chunk-OWKUE3AC.cjs');
+
+// src/core/enumerators/TyneqBaseEnumerator.ts
+var TyneqBaseEnumerator = class {
+  constructor() {
+    this._initialized = false;
+    this._completed = false;
+  }
+  /** Advances the iterator, calling `initialize()` on first call. Idempotent after completion. */
+  next() {
+    if (this._completed) {
+      return this.done();
+    }
+    if (!this._initialized) {
+      this.initialize();
+      this._initialized = true;
+    }
+    const result = this.handleNext();
+    if (result.done) {
+      if (!this._completed) {
+        this.dispose();
+        this._completed = true;
+      }
+      return this.done();
+    }
+    return result;
+  }
+  /** Terminates iteration early, disposes resources, and marks completed. Idempotent. */
+  return(value) {
+    if (!this._completed) {
+      this.dispose(value);
+      this._completed = true;
+    }
+    return this.done();
+  }
+  /** Called once before the first `handleNext()` invocation. Override to set up state. */
+  initialize() {
+  }
+  /** Wraps `value` in a non-done `IteratorResult`. */
+  yield(value) {
+    return { done: false, value };
+  }
+  /** Returns a done `IteratorResult`. */
+  done() {
+    return { done: true, value: void 0 };
+  }
+  /**
+   * 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.
+   */
+  doneWithYield(value) {
+    this.dispose();
+    this._completed = true;
+    return this.yield(value);
+  }
+  /**
+   * Disposes resources, marks completed, and returns a done result.
+   *
+   * @remarks
+   * Use inside `handleNext()` to terminate iteration before the source is exhausted.
+   */
+  earlyComplete(reason) {
+    this.dispose(reason);
+    this._completed = true;
+    return this.done();
+  }
+  /** Calls `disposeSource()` then `disposeAdditional()`. */
+  dispose(value) {
+    this.disposeSource();
+    this.disposeAdditional(value);
+  }
+  /** Override to dispose the upstream source enumerator. */
+  disposeSource() {
+  }
+  /**
+   * 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.
+   */
+  disposeAdditional(_value) {
+  }
+};
+
+// src/core/TyneqComparer.ts
+var TyneqComparer = class {
+  constructor() {
+  }
+  /**
+   * Natural-order comparer using `<` and `>`.
+   *
+   * @remarks
+   * Works correctly for numbers, strings, dates, and any type that supports the relational operators.
+   *
+   * @returns Negative if `a < b`, positive if `a > b`, `0` if equal.
+   */
+  static defaultComparer(a, b) {
+    return a > b ? 1 : a < b ? -1 : 0;
+  }
+  /** Strict equality comparer using `===`. */
+  static defaultEqualityComparer(a, b) {
+    return a === b;
+  }
+  /**
+   * Returns a comparer that reverses the order of `comparer`.
+   *
+   * @remarks
+   * Use this to invert any custom comparer - for example, to sort by a locale-aware comparer
+   * in descending order without rewriting it.
+   *
+   * @example
+   * ```ts
+   * const desc = TyneqComparer.reverse(TyneqComparer.createLocaleComparer("en"));
+   * seq.orderBy((s) => s, desc);
+   * ```
+   */
+  static reverse(comparer) {
+    return (a, b) => comparer(b, a);
+  }
+  /**
+   * Returns a locale-aware string comparer backed by `Intl.Collator`.
+   *
+   * @remarks
+   * Pass a `locale` and optional `options` for deterministic cross-environment ordering.
+   * Without arguments the comparer uses the runtime locale, which may vary across environments.
+   *
+   * @example
+   * ```ts
+   * seq.orderBy((s) => s, TyneqComparer.createLocaleComparer("en"));
+   * ```
+   *
+   * @param locale - BCP 47 language tag(s) passed to `Intl.Collator`.
+   * @param options - `Intl.CollatorOptions` passed to `Intl.Collator`.
+   *
+   * @see {@link caseInsensitiveComparer} for a locale-independent case-insensitive ordering comparer.
+   */
+  static createLocaleComparer(locale, options) {
+    const collator = new Intl.Collator(locale, options);
+    return (a, b) => collator.compare(a, b);
+  }
+  /**
+   * Case-insensitive string equality comparer.
+   *
+   * @remarks
+   * Converts both values to lower-case with `toLowerCase()` before comparing with `===`.
+   * Locale-independent: results are consistent across environments.
+   *
+   * Use {@link createLocaleComparer} with `{ sensitivity: "base" }` for locale-aware
+   * case-insensitive equality.
+   *
+   * @see {@link caseInsensitiveComparer} for the ordering (negative/zero/positive) counterpart.
+   */
+  static caseInsensitiveEqualityComparer(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  /**
+   * Case-insensitive ordering comparer.
+   *
+   * @remarks
+   * Converts both values to lower-case with `toLowerCase()` and compares with `<` / `>`.
+   * Locale-independent: results are consistent across environments and match
+   * {@link caseInsensitiveEqualityComparer} - strings that compare equal here return `true`
+   * there, and vice versa.
+   *
+   * Use {@link createLocaleComparer} when you need locale-aware case-insensitive ordering.
+   *
+   * @example
+   * ```ts
+   * seq.orderBy((s) => s, TyneqComparer.caseInsensitiveComparer)
+   * ```
+   *
+   * @see {@link caseInsensitiveEqualityComparer} for the boolean equality counterpart.
+   * @see {@link createLocaleComparer} for locale-aware ordering.
+   */
+  static caseInsensitiveComparer(a, b) {
+    const la = a.toLowerCase();
+    const lb = b.toLowerCase();
+    return la > lb ? 1 : la < lb ? -1 : 0;
+  }
+};
+
+// src/types/queryplan.ts
+var tyneqQueryNode = /* @__PURE__ */ Symbol("tyneq.queryNode");
+function isSourceNode(node) {
+  return node.category === "source";
+}
+
+// src/queryplan/QueryNode.ts
+var QueryNode = class {
+  constructor(operatorName, args, source2, category, sourceKind) {
+    this.operatorName = operatorName;
+    this.args = args;
+    this.source = source2;
+    this.category = category;
+    this.sourceKind = sourceKind;
+  }
+  accept(visitor) {
+    return visitor.visit(this);
+  }
+};
+
+// src/core/errors/PluginError.ts
+var PluginError = class extends _chunkOWKUE3ACcjs.TyneqError {
+  constructor(message, decoratorName, targetName, inner) {
+    super(message, { inner });
+    this.decoratorName = decoratorName;
+    this.targetName = targetName;
+  }
+};
+
+// src/plugin/decorators/builtin.ts
+var builtinMeta = /* @__PURE__ */ Symbol("tyneq.builtinMetadata");
+function builtin(options) {
+  return function(value, context) {
+    value[builtinMeta] = {
+      name: context.name,
+      kind: options.kind
+    };
+    return value;
+  };
+}
+
+// src/core/errors/RegistryError.ts
+var RegistryError = class extends _chunkOWKUE3ACcjs.TyneqError {
+  constructor(message, operatorName, kind, conflict, inner) {
+    super(message, { inner });
+    this.operatorName = operatorName;
+    this.kind = kind;
+    this.conflictingKind = conflict == null ? void 0 : conflict.kind;
+    this.conflictingSource = conflict == null ? void 0 : conflict.source;
+  }
+};
+
+// src/core/registry/TyneqOperatorRegistry.ts
+var OperatorRegistry = class {
+  /**
+   * Registers an operator entry and patches the method onto `entry.metadata.targetClass.prototype`.
+   *
+   * @throws {RegistryError} When an operator with the same name is already registered on the same targetClass.
+   */
+  static register(input) {
+    const { name } = input.metadata;
+    if (input.metadata.targetClass === void 0) {
+      throw new RegistryError(
+        `Cannot register "${name}": targetClass is required for prototype-patching operators. Use registerSource() for source operators.`,
+        name,
+        input.metadata.kind
+      );
+    }
+    const targetMap = this._operators.get(name);
+    if (targetMap == null ? void 0 : targetMap.has(input.metadata.targetClass)) {
+      const existing = targetMap.get(input.metadata.targetClass).metadata;
+      throw new RegistryError(
+        `Cannot register "${name}" (${input.metadata.kind}) on ${input.metadata.targetClass.name}: already registered as "${existing.kind}" from source "${existing.source}".`,
+        name,
+        input.metadata.kind,
+        { kind: existing.kind, source: existing.source }
+      );
+    }
+    for (const guard of this._registrationGuards) {
+      guard(input);
+    }
+    if (!this._operators.has(name)) {
+      this._operators.set(name, /* @__PURE__ */ new Map());
+    }
+    this._operators.get(name).set(input.metadata.targetClass, input);
+    input.metadata.targetClass.prototype[name] = input.impl;
+    for (const hook of this._registrationHooks) {
+      hook(input);
+    }
+  }
+  /**
+   * Removes an operator registration and deletes the prototype method for external operators.
+   *
+   * Checks the instance operator namespace first, then the source namespace.
+   *
+   * @returns `true` if the operator was found and removed; `false` if no operator with that name existed.
+   * @remarks
+   * Internal operators (source `"internal"`) are not removed from the prototype - only
+   * their registry entry is deleted.
+   *
+   * For targeted removal use {@link unregisterOperator} or {@link unregisterSource}.
+   */
+  static unregister(name) {
+    if (this._operators.has(name)) {
+      const targetMap = this._operators.get(name);
+      for (const [targetClass, entry] of targetMap) {
+        if (entry.metadata.source !== "internal" && targetClass !== void 0) {
+          delete targetClass.prototype[name];
+        }
+      }
+      this._operators.delete(name);
+      return true;
+    }
+    if (this._sources.has(name)) {
+      this._sources.delete(name);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Removes a specific instance operator registration for a given (name, targetClass) pair
+   * and deletes the prototype method for external operators.
+   *
+   * @returns `true` if the entry was found and removed; `false` otherwise.
+   */
+  static unregisterOperator(name, targetClass) {
+    const targetMap = this._operators.get(name);
+    if (!(targetMap == null ? void 0 : targetMap.has(targetClass))) {
+      return false;
+    }
+    const entry = targetMap.get(targetClass);
+    if (entry.metadata.source !== "internal") {
+      delete targetClass.prototype[name];
+    }
+    targetMap.delete(targetClass);
+    if (targetMap.size === 0) {
+      this._operators.delete(name);
+    }
+    return true;
+  }
+  /**
+   * Removes a source factory registration.
+   *
+   * @returns `true` if the source was found and removed; `false` otherwise.
+   */
+  static unregisterSource(name) {
+    return this._sources.delete(name);
+  }
+  /**
+   * Registers a hook called after every successful operator registration (both namespaces).
+   *
+   * @returns A function that removes the hook when called.
+   */
+  static onRegister(hook) {
+    this._registrationHooks.push(hook);
+    return () => {
+      const i = this._registrationHooks.indexOf(hook);
+      if (i !== -1) this._registrationHooks.splice(i, 1);
+    };
+  }
+  /**
+   * Registers a guard called before every registration (both namespaces).
+   * Throw from the guard to reject the registration.
+   *
+   * @returns A function that removes the guard when called.
+   */
+  static addGuard(guard) {
+    this._registrationGuards.push(guard);
+    return () => {
+      const i = this._registrationGuards.indexOf(guard);
+      if (i !== -1) this._registrationGuards.splice(i, 1);
+    };
+  }
+  /**
+   * Returns `true` if a name exists in either the source or instance operator namespace.
+   * Use {@link hasSource} or {@link hasOperator} for namespace-specific checks.
+   */
+  static has(name) {
+    return this._sources.has(name) || this._operators.has(name);
+  }
+  /**
+   * Returns `true` if a source factory with `name` is registered.
+   */
+  static hasSource(name) {
+    return this._sources.has(name);
+  }
+  /**
+   * Returns `true` if an instance operator with `name` is registered.
+   * When `targetClass` is provided, checks only that specific (name, targetClass) pair.
+   * When omitted, returns `true` if any target has an operator with that name.
+   */
+  static hasOperator(name, targetClass) {
+    var _a6, _b3;
+    if (targetClass !== void 0) {
+      return (_b3 = (_a6 = this._operators.get(name)) == null ? void 0 : _a6.has(targetClass)) != null ? _b3 : false;
+    }
+    return this._operators.has(name);
+  }
+  /**
+   * Returns the operator entry for `name` from either namespace, or `undefined` if not found.
+   * Checks the instance operator namespace first, then the source namespace.
+   * For namespace-specific retrieval use {@link getSource} or {@link getOperator}.
+   */
+  static get(name) {
+    const targetMap = this._operators.get(name);
+    if (targetMap !== void 0) {
+      return targetMap.values().next().value;
+    }
+    return this._sources.get(name);
+  }
+  /**
+   * Returns the source factory entry for `name`, or `undefined` if not registered.
+   */
+  static getSource(name) {
+    return this._sources.get(name);
+  }
+  /**
+   * Returns the instance operator entry for `name` on `targetClass`, or `undefined`.
+   * When `targetClass` is omitted, returns the first entry found across all targets.
+   */
+  static getOperator(name, targetClass) {
+    const targetMap = this._operators.get(name);
+    if (targetMap === void 0) {
+      return void 0;
+    }
+    if (targetClass !== void 0) {
+      return targetMap.get(targetClass);
+    }
+    return targetMap.values().next().value;
+  }
+  /**
+   * Returns the metadata for `name` from either namespace, or `undefined` if not found.
+   * Checks instance operators first, then sources.
+   */
+  static getMetadata(name) {
+    var _a6;
+    return (_a6 = this.get(name)) == null ? void 0 : _a6.metadata;
+  }
+  /**
+   * Returns metadata for all registered operators and source factories.
+   * Use {@link listOperators} or {@link listSources} for namespace-specific lists.
+   */
+  static list() {
+    return [...this.listSources(), ...this.listOperators()];
+  }
+  /**
+   * Returns metadata for all registered source factories.
+   */
+  static listSources() {
+    return [...this._sources.values()].map((e) => e.metadata);
+  }
+  /**
+   * Returns metadata for all registered instance operators.
+   * When `targetClass` is provided, returns only entries for that specific target class.
+   */
+  static listOperators(targetClass) {
+    const all = [];
+    for (const targetMap of this._operators.values()) {
+      if (targetClass !== void 0) {
+        const entry = targetMap.get(targetClass);
+        if (entry !== void 0) {
+          all.push(entry.metadata);
+        }
+      } else {
+        for (const entry of targetMap.values()) {
+          all.push(entry.metadata);
+        }
+      }
+    }
+    return all;
+  }
+  /** Returns metadata for all operators of `kind` across both namespaces. */
+  static listByKind(kind) {
+    return this.list().filter((m) => m.kind === kind);
+  }
+  /** Returns metadata for all operators from `source` across both namespaces. */
+  static listBySource(source2) {
+    return this.list().filter((m) => m.source === source2);
+  }
+  /** Returns the total number of registered operators across both namespaces. */
+  static count() {
+    let operatorCount = 0;
+    for (const targetMap of this._operators.values()) {
+      operatorCount += targetMap.size;
+    }
+    return this._sources.size + operatorCount;
+  }
+  /**
+   * Registers a source operator (a static factory, not a prototype method).
+   *
+   * @remarks
+   * Source operators differ from prototype operators in two ways:
+   * - They are called with `null` as `this` - they have no instance.
+   * - They are looked up by the compiler via {@link getSource} rather than
+   *   being patched onto a prototype.
+   *
+   * The entry is stored in the source namespace and is never patched onto any prototype.
+   * Registration guards run for `"external"` sources (same policy as {@link register}).
+  * Guards are skipped for `"internal"` sources (same policy used for internal builtins).
+   *
+   * Third-party source operators registered here are automatically compiled by
+   * `QueryPlanCompiler` without any changes to the compiler.
+   *
+   * @param name - The operator name, matching the `operatorName` on the `QueryPlanNode`.
+   * @param factory - The factory function; receives the node args in order, `this` is `null`.
+   * @param source - Whether this is a built-in or external source operator. Defaults to `"external"`.
+   *
+   * @example
+   * ```ts
+   * import { OperatorRegistry } from "tyneq/plugin";
+   * import { Tyneq } from "tyneq";
+   *
+   * OperatorRegistry.registerSource("fibonacci", (count) => {
+   *     // return a Tyneq sequence of fibonacci numbers
+   * });
+   * ```
+   *
+   * @group Classes
+   */
+  static registerSource(name, factory, source2 = "external") {
+    if (this._sources.has(name)) {
+      const existing = this._sources.get(name).metadata;
+      throw new RegistryError(
+        `Cannot register source "${name}": already registered as "${existing.kind}" from source "${existing.source}".`,
+        name,
+        "source",
+        { kind: existing.kind, source: existing.source }
+      );
+    }
+    const entry = {
+      metadata: OperatorMetadata.source(name, source2),
+      impl: function(...args) {
+        return factory(...args);
+      }
+    };
+    if (source2 !== "internal") {
+      for (const guard of this._registrationGuards) {
+        guard(entry);
+      }
+    }
+    this._sources.set(name, entry);
+    for (const hook of this._registrationHooks) {
+      hook(entry);
+    }
+  }
+  /**
+   * Records a built-in operator in the instance operator namespace without patching the prototype.
+   * Built-in operators already live as direct methods on their target class.
+   *
+   * @remarks
+   * Registration guards are intentionally skipped - builtins are internal and
+   * trusted; guards exist to validate external plugin registrations only.
+   *
+   * @internal
+   */
+  static registerBuiltin(name, kind, targetClass) {
+    const targetMap = this._operators.get(name);
+    if (targetMap == null ? void 0 : targetMap.has(targetClass)) {
+      const existing = targetMap.get(targetClass).metadata;
+      throw new RegistryError(
+        `Cannot register builtin "${name}" (${kind}) on ${targetClass.name}: already registered as "${existing.kind}" from source "${existing.source}".`,
+        name,
+        kind,
+        { kind: existing.kind, source: existing.source }
+      );
+    }
+    const lazyMethod = new (0, _chunkOWKUE3ACcjs.Lazy)(() => {
+      var _a6;
+      return (_a6 = _chunkOWKUE3ACcjs.reflect.call(void 0, targetClass.prototype).tryGetMethod(name)) == null ? void 0 : _a6.value;
+    });
+    const lazyMetadata = new (0, _chunkOWKUE3ACcjs.Lazy)(() => new OperatorMetadata(name, kind, "internal", targetClass));
+    const entry = {
+      get metadata() {
+        return lazyMetadata.value;
+      },
+      impl: function(...args) {
+        const method = lazyMethod.value;
+        if (!method) {
+          throw new RegistryError(
+            `Cannot invoke builtin "${name}" (${kind}): method not found on prototype. Ensure the method exists on the target class before registering.`,
+            name,
+            kind
+          );
+        }
+        return method.apply(this, args);
+      }
+    };
+    if (!this._operators.has(name)) {
+      this._operators.set(name, /* @__PURE__ */ new Map());
+    }
+    this._operators.get(name).set(targetClass, entry);
+    for (const hook of this._registrationHooks) {
+      hook(entry);
+    }
+  }
+};
+OperatorRegistry._sources = /* @__PURE__ */ new Map();
+OperatorRegistry._operators = /* @__PURE__ */ new Map();
+OperatorRegistry._registrationHooks = [];
+OperatorRegistry._registrationGuards = [];
+
+// src/plugin/decorators/sequence.ts
+function sequence(target, _context) {
+  var _a6;
+  for (const key of Object.getOwnPropertyNames(target.prototype)) {
+    const method = (_a6 = _chunkOWKUE3ACcjs.reflect.call(void 0, target.prototype).tryGetMethod(key)) == null ? void 0 : _a6.value;
+    if (method && builtinMeta in method) {
+      const metadata = method[builtinMeta];
+      OperatorRegistry.registerBuiltin(metadata.name, metadata.kind, target);
+    }
+  }
+}
+
+// src/core/TyneqEnumerableCore.ts
+var _pipe_dec, _memoize_dec, _orderByDescending_dec, _orderBy_dec, _a, _TyneqEnumerableCore_decorators, _init;
+_TyneqEnumerableCore_decorators = [sequence];
+var TyneqEnumerableCore = class {
+  constructor() {
+    _chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init, 5, this);
+  }
+  [(_a = Symbol.iterator, _orderBy_dec = [builtin({ kind: "buffer" })], _orderByDescending_dec = [builtin({ kind: "buffer" })], _memoize_dec = [builtin({ kind: "cache" })], _pipe_dec = [builtin({ kind: "extension" })], _a)]() {
+    return this.getEnumerator();
+  }
+  orderBy(keySelector, comparer) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    const orderByArgs = comparer !== void 0 ? [keySelector, comparer] : [keySelector];
+    return this.createOrderedEnumerable(
+      keySelector,
+      comparer != null ? comparer : TyneqComparer.defaultComparer,
+      false,
+      this.createNode("orderBy", "buffer", orderByArgs)
+    );
+  }
+  orderByDescending(keySelector, comparer) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    const orderByDescArgs = comparer !== void 0 ? [keySelector, comparer] : [keySelector];
+    return this.createOrderedEnumerable(
+      keySelector,
+      comparer != null ? comparer : TyneqComparer.defaultComparer,
+      true,
+      this.createNode("orderByDescending", "buffer", orderByDescArgs)
+    );
+  }
+  memoize() {
+    return this.createCachedEnumerable(this, this.createNode("memoize", "buffer"));
+  }
+  pipe(factory) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ factory });
+    const self = this;
+    return this.createSequence(
+      () => factory(self),
+      this.createNode("pipe", "streaming", [factory])
+    );
+  }
+  /**
+   * Helper that creates a new sequence with the provided enumerator factory and query node.
+   * @param factory The factory function that produces an enumerator for the new sequence.
+   * @param node The query plan node associated with the new sequence.
+   * @returns A new TyneqSequence instance.
+   */
+  createSequence(factory, node) {
+    return this.createEnumerable({ getEnumerator: factory }, node);
+  }
+  /**
+   * Helper for creating a query node with the current sequence's node as its parent.
+   * @param name The name of the query node.
+   * @param category The category of the operator.
+   * @param args The arguments for the query node.
+   * @returns A new QueryNode instance.
+   */
+  createNode(name, category, args = []) {
+    return new QueryNode(name, args, this[tyneqQueryNode], category);
+  }
+};
+_init = _chunkOWKUE3ACcjs.__decoratorStart.call(void 0, null);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init, 1, "orderBy", _orderBy_dec, TyneqEnumerableCore);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init, 1, "orderByDescending", _orderByDescending_dec, TyneqEnumerableCore);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init, 1, "memoize", _memoize_dec, TyneqEnumerableCore);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init, 1, "pipe", _pipe_dec, TyneqEnumerableCore);
+TyneqEnumerableCore = _chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init, 0, "TyneqEnumerableCore", _TyneqEnumerableCore_decorators, TyneqEnumerableCore);
+_chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init, 1, TyneqEnumerableCore);
+
+// src/core/terminal/TyneqTerminalOperator.ts
+var TyneqTerminalOperator = class {
+  constructor(source2) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ source: source2 });
+    this.source = source2;
+  }
+};
+
+// src/operators/aggregate.ts
+var AggregateOperator = class extends TyneqTerminalOperator {
+  constructor(source2, seed, func, resultSelector) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ func });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ resultSelector });
+    this.seed = seed;
+    this.func = func;
+    this.resultSelector = resultSelector;
+  }
+  process() {
+    let accumulate = this.seed;
+    for (const item of this.source) {
+      accumulate = this.func(accumulate, item);
+    }
+    return this.resultSelector(accumulate);
+  }
+};
+
+// src/operators/all.ts
+var AllOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let index = 0;
+    for (const item of this.source) {
+      if (!this.predicate(item, index++)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/operators/any.ts
+var AnyOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let index = 0;
+    for (const item of this.source) {
+      if (this.predicate(item, index++)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/operators/average.ts
+var AverageOperator = class extends TyneqTerminalOperator {
+  constructor(source2, selector) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    this.selector = selector;
+  }
+  process() {
+    let count = 0;
+    let sum = 0;
+    for (const item of this.source) {
+      sum += this.selector(item);
+      count++;
+    }
+    return count === 0 ? 0 : sum / count;
+  }
+};
+
+// src/operators/consume.ts
+var ConsumeOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    for (const _ of this.source) {
+    }
+  }
+};
+
+// src/operators/contains.ts
+var ContainsOperator = class extends TyneqTerminalOperator {
+  constructor(source2, value, equalityComparer) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotNull({ equalityComparer });
+    this.value = value;
+    this.equalityComparer = equalityComparer != null ? equalityComparer : TyneqComparer.defaultEqualityComparer;
+  }
+  process() {
+    for (const item of this.source) {
+      if (this.equalityComparer(item, this.value)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/operators/count.ts
+var CountOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    if (Array.isArray(this.source)) {
+      return this.source.length;
+    }
+    let count = 0;
+    for (const _ of this.source) {
+      count++;
+    }
+    return count;
+  }
+};
+
+// src/operators/countBy.ts
+var CountByOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let count = 0;
+    let index = 0;
+    for (const item of this.source) {
+      if (this.predicate(item, index++)) {
+        count++;
+      }
+    }
+    return count;
+  }
+};
+
+// src/operators/elementAt.ts
+var ElementAtOperator = class extends TyneqTerminalOperator {
+  constructor(source2, index) {
+    super(source2);
+    this.index = index;
+  }
+  process() {
+    const index = this.index;
+    let currentIndex = 0;
+    for (const element of this.source) {
+      if (currentIndex === index) {
+        return element;
+      }
+      currentIndex++;
+    }
+    throw new (0, _chunkOWKUE3ACcjs.ArgumentOutOfRangeError)(_chunkOWKUE3ACcjs.nameof.call(void 0, { index })[0]);
+  }
+};
+
+// src/operators/elementAtOrDefault.ts
+var ElementAtOrDefaultOperator = class extends TyneqTerminalOperator {
+  constructor(source2, index, defaultValue) {
+    super(source2);
+    this.index = index;
+    this.defaultValue = defaultValue;
+  }
+  process() {
+    const index = this.index;
+    let currentIndex = 0;
+    for (const element of this.source) {
+      if (currentIndex === index) {
+        return element;
+      }
+      currentIndex++;
+    }
+    return this.defaultValue;
+  }
+};
+
+// src/core/errors/InvalidOperationError.ts
+var InvalidOperationError = class extends _chunkOWKUE3ACcjs.TyneqError {
+  constructor(message = "The operation is invalid in the current state.", inner) {
+    super(message, { inner });
+  }
+};
+
+// src/operators/first.ts
+var FirstOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        return element;
+      }
+    }
+    throw new InvalidOperationError("Sequence contains no matching element");
+  }
+};
+
+// src/operators/firstOrDefault.ts
+var FirstOrDefaultOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate, defaultValue) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+    this.defaultValue = defaultValue;
+  }
+  process() {
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        return element;
+      }
+    }
+    return this.defaultValue;
+  }
+};
+
+// src/operators/indexOf.ts
+var IndexOfOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate, startIndex = 0) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ startIndex });
+    this.predicate = predicate;
+    this.startIndex = startIndex;
+  }
+  process() {
+    let index = -1;
+    for (const item of this.source) {
+      index++;
+      if (index < this.startIndex) {
+        continue;
+      }
+      if (this.predicate(item, index)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+};
+
+// src/utility/EnumeratorUtility.ts
+var EnumeratorUtility = class {
+  constructor() {
+  }
+  /**
+   * Calls `enumerator.return()` if it exists, swallowing any error.
+   * Safe to call on `null` or `undefined`.
+   */
+  static tryDispose(enumerator) {
+    var _a6;
+    try {
+      (_a6 = enumerator == null ? void 0 : enumerator.return) == null ? void 0 : _a6.call(enumerator);
+    } catch (e) {
+    }
+  }
+  /** Wraps an `Enumerator<T>` in a minimal `Iterable<T>` adapter (no buffering). */
+  static toIterable(enumerator) {
+    return {
+      [Symbol.iterator]: () => enumerator
+    };
+  }
+  /** Gets an `Enumerator<T>` from any `Iterable<T>`. */
+  static fromIterable(iterable) {
+    return iterable[Symbol.iterator]();
+  }
+  /**
+   * Advances the enumerator by one position and returns `true` if that position was done.
+   *
+   * **Warning:** this calls `next()` and irrevocably consumes one element.
+   * If the enumerator is not exhausted, the yielded element is discarded.
+   * Only call this when advancing past the current position is intentional.
+   */
+  static checkAndConsume(enumerator) {
+    return enumerator.next().done === true;
+  }
+};
+
+// src/operators/isNullOrEmpty.ts
+var IsNullOrEmptyOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    const iterator = this.source[Symbol.iterator]();
+    const first = iterator.next();
+    EnumeratorUtility.tryDispose(iterator);
+    return first.done === true || first.value === null || first.value === void 0;
+  }
+};
+
+// src/operators/last.ts
+var LastOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let lastMatchingElement = null;
+    let found = false;
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        lastMatchingElement = element;
+        found = true;
+      }
+    }
+    if (!found) {
+      throw new InvalidOperationError("Sequence contains no matching element");
+    }
+    return lastMatchingElement;
+  }
+};
+
+// src/operators/lastOrDefault.ts
+var LastOrDefaultOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate, defaultValue) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+    this.defaultValue = defaultValue;
+  }
+  process() {
+    let lastMatchingElement = null;
+    let found = false;
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        lastMatchingElement = element;
+        found = true;
+      }
+    }
+    if (!found) {
+      return this.defaultValue;
+    }
+    return lastMatchingElement;
+  }
+};
+
+// src/core/errors/SequenceContainsNoElementsError.ts
+var SequenceContainsNoElementsError = class extends InvalidOperationError {
+  constructor(operatorName, inner) {
+    const message = operatorName ? `Sequence contains no elements (in "${operatorName}").` : "Sequence contains no elements.";
+    super(message, inner);
+    this.operatorName = operatorName;
+  }
+};
+
+// src/operators/extremum.ts
+var ExtremumOperator = class extends TyneqTerminalOperator {
+  constructor(source2, direction, operatorName, comparer) {
+    super(source2);
+    this.comparer = comparer != null ? comparer : TyneqComparer.defaultComparer;
+    this.direction = direction;
+    this.operatorName = operatorName;
+  }
+  process() {
+    let best = null;
+    let hasElement = false;
+    for (const element of this.source) {
+      if (!hasElement || this.comparer(element, best) * this.direction > 0) {
+        best = element;
+        hasElement = true;
+      }
+    }
+    if (!hasElement) {
+      throw new SequenceContainsNoElementsError(this.operatorName);
+    }
+    return best;
+  }
+};
+var ExtremumByOperator = class extends TyneqTerminalOperator {
+  constructor(source2, keySelector, direction, operatorName, comparer) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    this.comparer = comparer != null ? comparer : TyneqComparer.defaultComparer;
+    this.keySelector = keySelector;
+    this.direction = direction;
+    this.operatorName = operatorName;
+  }
+  process() {
+    let bestElement = null;
+    let bestKey = null;
+    let hasElement = false;
+    for (const element of this.source) {
+      const key = this.keySelector(element);
+      if (!hasElement || this.comparer(key, bestKey) * this.direction > 0) {
+        bestElement = element;
+        bestKey = key;
+        hasElement = true;
+      }
+    }
+    if (!hasElement) {
+      throw new SequenceContainsNoElementsError(this.operatorName);
+    }
+    return bestElement;
+  }
+};
+
+// src/operators/minMax.ts
+var MinMaxOperator = class extends TyneqTerminalOperator {
+  constructor(source2, comparer) {
+    super(source2);
+    this.comparer = comparer != null ? comparer : TyneqComparer.defaultComparer;
+  }
+  process() {
+    let min;
+    let max;
+    let hasElements = false;
+    for (const item of this.source) {
+      if (!hasElements) {
+        min = item;
+        max = item;
+        hasElements = true;
+      } else {
+        if (this.comparer(item, min) < 0) min = item;
+        if (this.comparer(item, max) > 0) max = item;
+      }
+    }
+    if (!hasElements) {
+      throw new SequenceContainsNoElementsError("minMax");
+    }
+    return { min, max };
+  }
+};
+
+// src/operators/sequenceEqual.ts
+var SequenceEqualOperator = class extends TyneqTerminalOperator {
+  constructor(source2, other, equalityComparer) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ other });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotNull({ equalityComparer });
+    this.equalityComparer = equalityComparer != null ? equalityComparer : TyneqComparer.defaultEqualityComparer;
+    this.other = other;
+  }
+  process() {
+    const sourceIterator = this.source[Symbol.iterator]();
+    const otherIterator = this.other[Symbol.iterator]();
+    while (true) {
+      const sourceNext = sourceIterator.next();
+      const otherNext = otherIterator.next();
+      if (sourceNext.done && otherNext.done) {
+        break;
+      }
+      if (sourceNext.done !== otherNext.done) {
+        return false;
+      }
+      if (!this.equalityComparer(sourceNext.value, otherNext.value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/operators/single.ts
+var SingleOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+  }
+  process() {
+    let found = false;
+    let single = null;
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        if (found) {
+          throw new InvalidOperationError("Sequence contains more than one matching element");
+        }
+        found = true;
+        single = element;
+      }
+    }
+    if (!found) {
+      throw new InvalidOperationError("Sequence contains no matching element");
+    }
+    return single;
+  }
+};
+
+// src/operators/singleOrDefault.ts
+var SingleOrDefaultOperator = class extends TyneqTerminalOperator {
+  constructor(source2, predicate, defaultValue) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    this.predicate = predicate;
+    this.defaultValue = defaultValue;
+  }
+  process() {
+    let found = false;
+    let single = null;
+    let index = 0;
+    for (const element of this.source) {
+      if (this.predicate(element, index++)) {
+        if (found) {
+          throw new InvalidOperationError("Sequence contains more than one matching element");
+        }
+        found = true;
+        single = element;
+      }
+    }
+    if (!found) {
+      return this.defaultValue;
+    }
+    return single;
+  }
+};
+
+// src/operators/endsWith.ts
+var EndsWithOperator = class extends TyneqTerminalOperator {
+  constructor(source2, sequence2, equalityComparer) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ sequence: sequence2 });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ sequence: sequence2 });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotNull({ equalityComparer });
+    this.sequence = sequence2;
+    this.equalityComparer = equalityComparer != null ? equalityComparer : TyneqComparer.defaultEqualityComparer;
+  }
+  process() {
+    const suffixElements = Array.from(this.sequence);
+    if (suffixElements.length === 0) {
+      return true;
+    }
+    const bufferResult = this.fillCircularBuffer(this.source, suffixElements.length);
+    if (bufferResult === null) {
+      return false;
+    }
+    const { buffer, readIndex } = bufferResult;
+    for (let i = 0; i < suffixElements.length; i++) {
+      if (!this.equalityComparer(buffer[(readIndex + i) % buffer.length], suffixElements[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  fillCircularBuffer(elements, windowSize) {
+    const buffer = new Array(windowSize);
+    let writeIndex = 0;
+    for (const item of elements) {
+      buffer[writeIndex % windowSize] = item;
+      writeIndex++;
+    }
+    if (writeIndex < windowSize) {
+      return null;
+    }
+    return { buffer, readIndex: writeIndex % windowSize };
+  }
+};
+
+// src/operators/startsWith.ts
+var StartsWithOperator = class extends TyneqTerminalOperator {
+  constructor(source2, sequence2, equalityComparer) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ sequence: sequence2 });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ sequence: sequence2 });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotNull({ equalityComparer });
+    this.sequence = sequence2;
+    this.equalityComparer = equalityComparer != null ? equalityComparer : TyneqComparer.defaultEqualityComparer;
+  }
+  process() {
+    const sourceEnumerator = this.source[Symbol.iterator]();
+    const sequenceEnumerator = this.sequence[Symbol.iterator]();
+    while (true) {
+      const { value: sourceValue, done: sourceDone } = sourceEnumerator.next();
+      const { value: sequenceValue, done: sequenceDone } = sequenceEnumerator.next();
+      if (sequenceDone) {
+        return true;
+      }
+      if (sourceDone || !this.equalityComparer(sourceValue, sequenceValue)) {
+        return false;
+      }
+    }
+  }
+};
+
+// src/operators/sum.ts
+var SumOperator = class extends TyneqTerminalOperator {
+  constructor(source2, selector) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    this.selector = selector;
+  }
+  process() {
+    let sum = 0;
+    for (const item of this.source) {
+      sum += this.selector(item);
+    }
+    return sum;
+  }
+};
+
+// src/operators/toArray.ts
+var ToArrayOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    return Array.from(this.source);
+  }
+};
+
+// src/operators/toAsync.ts
+var ToAsyncOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    const source2 = this.source;
+    return {
+      [Symbol.asyncIterator]() {
+        return _chunkOWKUE3ACcjs.__asyncGenerator.call(void 0, this, null, function* () {
+          for (const item of source2) {
+            yield item;
+          }
+        });
+      }
+    };
+  }
+};
+
+// src/operators/toMap.ts
+var ToMapOperator = class extends TyneqTerminalOperator {
+  constructor(source2, selector) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    this.selector = selector;
+  }
+  process() {
+    return new Map(Array.from(this.source, (item) => {
+      const pair = this.selector(item);
+      return this.transformPairToTuple(pair);
+    }));
+  }
+  transformPairToTuple(pair) {
+    return [pair.key, pair.value];
+  }
+};
+
+// src/operators/toRecord.ts
+var ToRecordOperator = class extends TyneqTerminalOperator {
+  constructor(source2, selector) {
+    super(source2);
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    this.selector = selector;
+  }
+  process() {
+    const result = {};
+    for (const item of this.source) {
+      const pair = this.selector(item);
+      result[pair.key] = pair.value;
+    }
+    return result;
+  }
+};
+
+// src/operators/toSet.ts
+var ToSetOperator = class extends TyneqTerminalOperator {
+  constructor(source2) {
+    super(source2);
+  }
+  process() {
+    return new Set(this.source);
+  }
+};
+
+// src/core/enumerators/TyneqEnumerator.ts
+var TyneqEnumerator = class extends TyneqBaseEnumerator {
+  constructor(sourceEnumerator) {
+    super();
+    this.sourceDisposed = false;
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ sourceEnumerator });
+    this.sourceEnumerator = sourceEnumerator;
+  }
+  disposeSource() {
+    if (this.sourceDisposed) {
+      return;
+    }
+    this.sourceDisposed = true;
+    EnumeratorUtility.tryDispose(this.sourceEnumerator);
+  }
+};
+
+// src/enumerators/streaming/append.ts
+var AppendEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, item) {
+    super(sourceEnumerator);
+    this.isSourceDone = false;
+    this.appended = false;
+    this.item = item;
+  }
+  handleNext() {
+    if (!this.isSourceDone) {
+      const sourceNext = this.sourceEnumerator.next();
+      if (!sourceNext.done) {
+        return this.yield(sourceNext.value);
+      }
+      this.isSourceDone = true;
+    }
+    if (!this.appended) {
+      this.appended = true;
+      return this.yield(this.item);
+    }
+    return this.done();
+  }
+};
+
+// src/enumerators/streaming/chunk.ts
+var ChunkEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, size) {
+    super(sourceEnumerator);
+    this.currentChunk = [];
+    this.size = size;
+  }
+  handleNext() {
+    while (this.currentChunk.length < this.size) {
+      const next = this.sourceEnumerator.next();
+      if (next.done) break;
+      this.currentChunk.push(next.value);
+    }
+    if (this.currentChunk.length === 0) {
+      return this.done();
+    }
+    const chunk = this.currentChunk;
+    this.currentChunk = [];
+    return this.yield(chunk);
+  }
+};
+
+// src/enumerators/streaming/concat.ts
+var ConcatEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, other) {
+    super(sourceEnumerator);
+    this.isSourceDone = false;
+    this.otherEnumerator = other[Symbol.iterator]();
+  }
+  disposeAdditional() {
+    EnumeratorUtility.tryDispose(this.otherEnumerator);
+  }
+  handleNext() {
+    if (!this.isSourceDone) {
+      const next2 = this.sourceEnumerator.next();
+      if (!next2.done) {
+        return this.yield(next2.value);
+      }
+      this.isSourceDone = true;
+    }
+    const next = this.otherEnumerator.next();
+    if (!next.done) {
+      return this.yield(next.value);
+    }
+    return this.done();
+  }
+};
+
+// src/enumerators/streaming/flatten.ts
+var FlattenEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator) {
+    super(sourceEnumerator);
+    this.innerEnumerator = null;
+  }
+  handleNext() {
+    while (true) {
+      if (this.innerEnumerator !== null) {
+        const innerNext = this.innerEnumerator.next();
+        if (!innerNext.done) {
+          return this.yield(innerNext.value);
+        }
+        this.innerEnumerator = null;
+      }
+      const sourceNext = this.sourceEnumerator.next();
+      if (sourceNext.done) {
+        return this.done();
+      }
+      this.innerEnumerator = sourceNext.value[Symbol.iterator]();
+    }
+  }
+};
+
+// src/enumerators/streaming/defaultIfEmpty.ts
+var DefaultIfEmptyEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, defaultValue) {
+    super(sourceEnumerator);
+    this.sourceDone = false;
+    this.hasYieldedAny = false;
+    this.defaultYielded = false;
+    this.defaultValue = defaultValue;
+  }
+  handleNext() {
+    if (!this.sourceDone) {
+      const next = this.sourceEnumerator.next();
+      if (!next.done) {
+        this.hasYieldedAny = true;
+        return this.yield(next.value);
+      }
+      this.sourceDone = true;
+    }
+    if (!this.hasYieldedAny && !this.defaultYielded) {
+      this.defaultYielded = true;
+      return this.doneWithYield(this.defaultValue);
+    }
+    return this.done();
+  }
+};
+
+// src/enumerators/streaming/ofType.ts
+var OfTypeEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, guard) {
+    super(sourceEnumerator);
+    this.guard = guard;
+  }
+  handleNext() {
+    while (true) {
+      const { value, done } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      if (this.guard(value)) {
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/pairwise.ts
+var PairwiseEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator) {
+    super(sourceEnumerator);
+    this.hasPrevious = false;
+  }
+  handleNext() {
+    while (true) {
+      const next = this.sourceEnumerator.next();
+      if (next.done) {
+        return this.done();
+      }
+      if (!this.hasPrevious) {
+        this.previous = next.value;
+        this.hasPrevious = true;
+        continue;
+      }
+      const pair = [this.previous, next.value];
+      this.previous = next.value;
+      return this.yield(pair);
+    }
+  }
+};
+
+// src/enumerators/streaming/populate.ts
+var PopulateEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, value) {
+    super(sourceEnumerator);
+    this.value = value;
+  }
+  handleNext() {
+    while (true) {
+      const { done } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      return this.yield(this.value);
+    }
+  }
+};
+
+// src/enumerators/streaming/prepend.ts
+var PrependEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, item) {
+    super(sourceEnumerator);
+    this.prepended = false;
+    this.item = item;
+  }
+  handleNext() {
+    if (!this.prepended) {
+      this.prepended = true;
+      return this.yield(this.item);
+    }
+    const nextItem = this.sourceEnumerator.next();
+    if (!nextItem.done) {
+      return this.yield(nextItem.value);
+    }
+    return this.done();
+  }
+};
+
+// src/enumerators/streaming/scan.ts
+var ScanEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, seed, accumulator) {
+    super(sourceEnumerator);
+    this.current = seed;
+    this.accumulator = accumulator;
+  }
+  handleNext() {
+    const { value, done } = this.sourceEnumerator.next();
+    if (done) {
+      return this.done();
+    }
+    this.current = this.accumulator(this.current, value);
+    return this.yield(this.current);
+  }
+};
+
+// src/enumerators/streaming/select.ts
+var SelectEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, selector) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.selector = selector;
+  }
+  handleNext() {
+    const next = this.sourceEnumerator.next();
+    if (next.done) {
+      return this.done();
+    }
+    return this.yield(this.selector(next.value, this.index++));
+  }
+};
+
+// src/enumerators/streaming/selectMany.ts
+var SelectManyEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, selector) {
+    super(sourceEnumerator);
+    this.innerEnumerator = null;
+    this.selector = selector;
+  }
+  handleNext() {
+    while (true) {
+      if (this.innerEnumerator !== null) {
+        const innerNext = this.innerEnumerator.next();
+        if (!innerNext.done) {
+          return this.yield(innerNext.value);
+        }
+        this.innerEnumerator = null;
+      }
+      const sourceNext = this.sourceEnumerator.next();
+      if (sourceNext.done) {
+        return this.done();
+      }
+      this.innerEnumerator = this.selector(sourceNext.value)[Symbol.iterator]();
+    }
+  }
+};
+
+// src/enumerators/streaming/repeatSequence.ts
+var RepeatSequenceEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, source2, count) {
+    super(sourceEnumerator);
+    this.repetition = 0;
+    this.source = source2;
+    this.count = count;
+    this.currentEnumerator = sourceEnumerator;
+  }
+  disposeAdditional() {
+    if (this.currentEnumerator !== this.sourceEnumerator) {
+      EnumeratorUtility.tryDispose(this.currentEnumerator);
+    }
+  }
+  handleNext() {
+    while (this.repetition < this.count) {
+      const next = this.currentEnumerator.next();
+      if (!next.done) {
+        return this.yield(next.value);
+      }
+      this.repetition++;
+      if (this.repetition < this.count) {
+        const fresh = this.source[Symbol.iterator]();
+        const probe = fresh.next();
+        if (probe.done) {
+          this.repetition = this.count;
+          return this.done();
+        }
+        this.currentEnumerator = fresh;
+        return this.yield(probe.value);
+      }
+    }
+    return this.done();
+  }
+};
+
+// src/enumerators/streaming/skip.ts
+var SkipEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, count) {
+    super(sourceEnumerator);
+    this.skipped = false;
+    this.count = count;
+  }
+  handleNext() {
+    if (!this.skipped) {
+      let skippedCount = 0;
+      while (skippedCount < this.count) {
+        const sourceNext2 = this.sourceEnumerator.next();
+        if (sourceNext2.done) {
+          return this.done();
+        }
+        skippedCount++;
+      }
+      this.skipped = true;
+    }
+    const sourceNext = this.sourceEnumerator.next();
+    if (sourceNext.done) {
+      return this.done();
+    }
+    return this.yield(sourceNext.value);
+  }
+};
+
+// src/enumerators/streaming/skipLast.ts
+var SkipLastEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, count) {
+    super(sourceEnumerator);
+    this.writeIndex = 0;
+    this.filledCount = 0;
+    this.count = count;
+    this.buffer = new Array(this.count);
+  }
+  handleNext() {
+    if (this.count === 0) {
+      const current = this.sourceEnumerator.next();
+      if (current.done) {
+        return this.done();
+      } else {
+        return this.yield(current.value);
+      }
+    }
+    while (true) {
+      const current = this.sourceEnumerator.next();
+      if (current.done) {
+        return this.done();
+      }
+      if (this.filledCount < this.count) {
+        this.buffer[this.writeIndex] = current.value;
+        this.writeIndex = (this.writeIndex + 1) % this.count;
+        this.filledCount++;
+        continue;
+      }
+      const oldest = this.buffer[this.writeIndex];
+      this.buffer[this.writeIndex] = current.value;
+      this.writeIndex = (this.writeIndex + 1) % this.count;
+      return this.yield(oldest);
+    }
+  }
+};
+
+// src/enumerators/streaming/skipUntil.ts
+var SkipUntilEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.triggered = false;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    while (true) {
+      const next = this.sourceEnumerator.next();
+      if (next.done) {
+        return this.done();
+      }
+      if (!this.triggered) {
+        this.triggered = this.predicate(next.value, this.index++);
+      }
+      if (this.triggered) {
+        return this.yield(next.value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/skipWhile.ts
+var SkipWhileEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.isSkipping = true;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    while (true) {
+      const next = this.sourceEnumerator.next();
+      if (next.done) {
+        return this.done();
+      }
+      this.isSkipping = this.isSkipping && this.predicate(next.value, this.index++);
+      if (!this.isSkipping) {
+        return this.yield(next.value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/slice.ts
+var SliceEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, start, end) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.started = false;
+    this.start = start;
+    this.end = end;
+  }
+  handleNext() {
+    if (!this.started) {
+      this.started = true;
+      while (this.index < this.start) {
+        if (this.sourceEnumerator.next().done) {
+          return this.done();
+        }
+        this.index++;
+      }
+    }
+    if (this.index >= this.end) {
+      return this.earlyComplete();
+    }
+    const next = this.sourceEnumerator.next();
+    if (next.done) {
+      return this.done();
+    }
+    this.index++;
+    return this.yield(next.value);
+  }
+};
+
+// src/enumerators/streaming/split.ts
+var SplitEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, splitOn) {
+    super(sourceEnumerator);
+    this.splitOn = splitOn;
+  }
+  handleNext() {
+    const currentSplit = [];
+    while (true) {
+      const { value, done } = this.sourceEnumerator.next();
+      if (done) {
+        if (currentSplit.length > 0) {
+          return this.doneWithYield(currentSplit);
+        }
+        return this.done();
+      }
+      if (this.splitOn(value)) {
+        if (currentSplit.length > 0) {
+          return this.yield(currentSplit);
+        }
+      } else {
+        currentSplit.push(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/take.ts
+var TakeEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, count) {
+    super(sourceEnumerator);
+    this.takenCount = 0;
+    this.count = count;
+  }
+  handleNext() {
+    if (this.takenCount >= this.count) {
+      return this.earlyComplete();
+    }
+    const result = this.sourceEnumerator.next();
+    if (result.done) {
+      return this.done();
+    }
+    this.takenCount++;
+    return this.yield(result.value);
+  }
+};
+
+// src/enumerators/streaming/takeUntil.ts
+var TakeUntilEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    const next = this.sourceEnumerator.next();
+    if (next.done) {
+      return this.done();
+    }
+    if (this.predicate(next.value, this.index++)) {
+      return this.earlyComplete();
+    }
+    return this.yield(next.value);
+  }
+};
+
+// src/enumerators/streaming/takeWhile.ts
+var TakeWhileEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    const result = this.sourceEnumerator.next();
+    if (result.done) {
+      return this.done();
+    }
+    if (this.predicate(result.value, this.index++)) {
+      return this.yield(result.value);
+    }
+    return this.earlyComplete();
+  }
+};
+
+// src/enumerators/streaming/tap.ts
+var TapEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, action) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.action = action;
+  }
+  handleNext() {
+    const next = this.sourceEnumerator.next();
+    if (next.done) {
+      return this.done();
+    }
+    this.action(next.value, this.index++);
+    return this.yield(next.value);
+  }
+};
+
+// src/enumerators/streaming/tapIf.ts
+var TapIfEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, action, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.action = action;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    const next = this.sourceEnumerator.next();
+    if (next.done) {
+      return this.done();
+    }
+    if (this.predicate()) {
+      this.action(next.value, this.index);
+    }
+    this.index++;
+    return this.yield(next.value);
+  }
+};
+
+// src/enumerators/streaming/throttle.ts
+var ThrottleEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, count) {
+    super(sourceEnumerator);
+    this.index = -1;
+    this.count = count;
+  }
+  handleNext() {
+    while (true) {
+      const { value, done } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      this.index++;
+      if (this.index % this.count === 0) {
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/where.ts
+var WhereEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, predicate) {
+    super(sourceEnumerator);
+    this.index = 0;
+    this.predicate = predicate;
+  }
+  handleNext() {
+    while (true) {
+      const { value, done } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      if (this.predicate(value, this.index++)) {
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/streaming/window.ts
+var WindowEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, size, step) {
+    super(sourceEnumerator);
+    this.buffer = [];
+    this.started = false;
+    this.size = size;
+    this.step = step;
+  }
+  handleNext() {
+    if (!this.started) {
+      this.started = true;
+      while (this.buffer.length < this.size) {
+        const next = this.sourceEnumerator.next();
+        if (next.done) {
+          return this.done();
+        }
+        this.buffer.push(next.value);
+      }
+      return this.yield(this.buffer.slice());
+    }
+    if (this.step <= this.size) {
+      this.buffer = this.buffer.slice(this.step);
+    } else {
+      this.buffer = [];
+      const toSkip = this.step - this.size;
+      for (let i = 0; i < toSkip; i++) {
+        if (this.sourceEnumerator.next().done) {
+          return this.done();
+        }
+      }
+    }
+    while (this.buffer.length < this.size) {
+      const next = this.sourceEnumerator.next();
+      if (next.done) {
+        return this.done();
+      }
+      this.buffer.push(next.value);
+    }
+    return this.yield(this.buffer.slice());
+  }
+};
+
+// src/enumerators/streaming/zip.ts
+var ZipEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, other, selector) {
+    super(sourceEnumerator);
+    this.otherEnumerator = other[Symbol.iterator]();
+    this.selector = selector;
+  }
+  handleNext() {
+    const first = this.sourceEnumerator.next();
+    if (first.done) {
+      this.disposeAdditional();
+      return this.done();
+    }
+    const second = this.otherEnumerator.next();
+    if (second.done) {
+      return this.earlyComplete();
+    }
+    return this.yield(this.selector(first.value, second.value));
+  }
+  disposeAdditional() {
+    EnumeratorUtility.tryDispose(this.otherEnumerator);
+  }
+};
+
+// src/enumerators/buffer/backsert.ts
+var BacksertEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, backIndex, other) {
+    super(sourceEnumerator);
+    this.buffer = [];
+    this.current = 0;
+    this.backIndex = backIndex;
+    this.other = other;
+  }
+  initialize() {
+    const source2 = Array.from(EnumeratorUtility.toIterable(this.sourceEnumerator));
+    const other = Array.from(this.other);
+    const insertionIndex = Math.max(0, source2.length - this.backIndex);
+    this.buffer = [
+      ...source2.slice(0, insertionIndex),
+      ...other,
+      ...source2.slice(insertionIndex)
+    ];
+    this.current = 0;
+  }
+  handleNext() {
+    if (this.current >= this.buffer.length) {
+      return this.done();
+    }
+    return this.yield(this.buffer[this.current++]);
+  }
+};
+
+// src/enumerators/buffer/distinct.ts
+var DistinctEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator) {
+    super(sourceEnumerator);
+    this.seenValues = /* @__PURE__ */ new Set();
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      if (!this.seenValues.has(value)) {
+        this.seenValues.add(value);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/distinctBy.ts
+var DistinctByEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, keySelector) {
+    super(sourceEnumerator);
+    this.seenValues = /* @__PURE__ */ new Set();
+    this.keySelector = keySelector;
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      const key = this.keySelector(value);
+      if (!this.seenValues.has(key)) {
+        this.seenValues.add(key);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/except.ts
+var ExceptEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, excludedValues) {
+    super(sourceEnumerator);
+    this.excludeSet = /* @__PURE__ */ new Set();
+    this.excludedValues = excludedValues;
+  }
+  initialize() {
+    this.excludeSet = new Set(this.excludedValues);
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      if (!this.excludeSet.has(value)) {
+        this.excludeSet.add(value);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/exceptBy.ts
+var ExceptByEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, excludedKeys, keySelector) {
+    super(sourceEnumerator);
+    this.excludeSet = /* @__PURE__ */ new Set();
+    this.excludedKeys = excludedKeys;
+    this.keySelector = keySelector;
+  }
+  initialize() {
+    this.excludeSet = new Set(this.excludedKeys);
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      const key = this.keySelector(value);
+      if (!this.excludeSet.has(key)) {
+        this.excludeSet.add(key);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/utility/DefaultingMap.ts
+var DefaultingMap = class extends Map {
+  /** Returns the value for `key`, or initialises and stores it via `initValue()` if absent. */
+  getOrInit(key, initValue) {
+    if (!this.has(key)) {
+      this.set(key, initValue());
+    }
+    return this.get(key);
+  }
+  /** Sets `key` to `initValue` if absent; otherwise replaces the current value with `updateValue(current)`. */
+  setOrUpdate(key, updateValue, initValue) {
+    if (!this.has(key)) {
+      this.set(key, initValue);
+      return;
+    }
+    this.set(key, updateValue(this.get(key)));
+  }
+};
+
+// src/enumerators/buffer/groupBy.ts
+var GroupByEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, keySelector, valueSelector, resultSelector, groupFactory) {
+    super(sourceEnumerator);
+    this.lookup = new DefaultingMap();
+    this.keySelector = keySelector;
+    this.valueSelector = valueSelector;
+    this.resultSelector = resultSelector;
+    this.groupFactory = groupFactory;
+  }
+  initialize() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        break;
+      }
+      const key = this.keySelector(value);
+      const mappedValue = this.valueSelector(value);
+      const group = this.lookup.getOrInit(key, () => []);
+      group.push(mappedValue);
+    }
+    this.lookupEnumerator = this.lookup.entries();
+  }
+  handleNext() {
+    if (this.lookupEnumerator === void 0) {
+      return this.done();
+    }
+    const { done, value } = this.lookupEnumerator.next();
+    if (done) {
+      return this.done();
+    }
+    const [key, values] = value;
+    const result = this.resultSelector(key, this.groupFactory(values));
+    return this.yield(result);
+  }
+};
+
+// src/enumerators/buffer/groupJoin.ts
+var GroupJoinEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, innerSource, outerKeySelector, innerKeySelector, resultSelector, groupFactory) {
+    super(sourceEnumerator);
+    this.innerLookup = new DefaultingMap();
+    this.innerSource = innerSource;
+    this.outerKeySelector = outerKeySelector;
+    this.innerKeySelector = innerKeySelector;
+    this.resultSelector = resultSelector;
+    this.groupFactory = groupFactory;
+  }
+  initialize() {
+    for (const innerItem of this.innerSource) {
+      const key = this.innerKeySelector(innerItem);
+      const bucket = this.innerLookup.getOrInit(key, () => []);
+      bucket.push(innerItem);
+    }
+  }
+  handleNext() {
+    var _a6;
+    const { done, value: outerItem } = this.sourceEnumerator.next();
+    if (done) {
+      return this.done();
+    }
+    const outerKey = this.outerKeySelector(outerItem);
+    const innerItems = (_a6 = this.innerLookup.get(outerKey)) != null ? _a6 : [];
+    const resultItem = this.resultSelector(outerItem, this.groupFactory(innerItems));
+    return this.yield(resultItem);
+  }
+};
+
+// src/enumerators/buffer/intersect.ts
+var IntersectEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, otherValues) {
+    super(sourceEnumerator);
+    this.intersectionValues = /* @__PURE__ */ new Set();
+    this.bufferedValues = /* @__PURE__ */ new Set();
+    this.otherValues = otherValues;
+  }
+  initialize() {
+    this.intersectionValues = new Set(this.otherValues);
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      if (this.intersectionValues.has(value) && !this.bufferedValues.has(value)) {
+        this.bufferedValues.add(value);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/intersectBy.ts
+var IntersectByEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, otherValues, keySelector) {
+    super(sourceEnumerator);
+    this.intersectionKeys = /* @__PURE__ */ new Set();
+    this.bufferedKeys = /* @__PURE__ */ new Set();
+    this.otherValues = otherValues;
+    this.keySelector = keySelector;
+  }
+  initialize() {
+    this.intersectionKeys = new Set(this.otherValues);
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        return this.done();
+      }
+      const key = this.keySelector(value);
+      if (this.intersectionKeys.has(key) && !this.bufferedKeys.has(key)) {
+        this.bufferedKeys.add(key);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/join.ts
+var JoinEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, innerSource, outerKeySelector, innerKeySelector, resultSelector) {
+    super(sourceEnumerator);
+    this.innerLookup = new DefaultingMap();
+    this.pendingMatches = null;
+    this.pendingIndex = 0;
+    this.innerSource = innerSource;
+    this.outerKeySelector = outerKeySelector;
+    this.innerKeySelector = innerKeySelector;
+    this.resultSelector = resultSelector;
+  }
+  initialize() {
+    for (const innerItem of this.innerSource) {
+      const key = this.innerKeySelector(innerItem);
+      const bucket = this.innerLookup.getOrInit(key, () => []);
+      bucket.push(innerItem);
+    }
+  }
+  handleNext() {
+    while (true) {
+      if (this.pendingMatches !== null) {
+        if (this.pendingIndex < this.pendingMatches.length) {
+          return this.yield(this.resultSelector(this.pendingOuter, this.pendingMatches[this.pendingIndex++]));
+        }
+        this.pendingMatches = null;
+      }
+      const nextOuter = this.sourceEnumerator.next();
+      if (nextOuter.done) {
+        return this.done();
+      }
+      const outerItem = nextOuter.value;
+      const outerKey = this.outerKeySelector(outerItem);
+      const innerItems = this.innerLookup.get(outerKey);
+      if (innerItems === void 0 || innerItems.length === 0) {
+        continue;
+      }
+      this.pendingOuter = outerItem;
+      this.pendingMatches = innerItems;
+      this.pendingIndex = 0;
+    }
+  }
+};
+
+// src/enumerators/buffer/reverse.ts
+var ReverseEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator) {
+    super(sourceEnumerator);
+    this.buffer = [];
+    this.index = -1;
+  }
+  initialize() {
+    while (true) {
+      const { done, value } = this.sourceEnumerator.next();
+      if (done) {
+        this.index = this.buffer.length - 1;
+        break;
+      }
+      this.buffer.push(value);
+    }
+  }
+  handleNext() {
+    if (this.index < 0) {
+      return this.done();
+    }
+    return this.yield(this.buffer[this.index--]);
+  }
+};
+
+// src/enumerators/buffer/shuffle.ts
+var ShuffleEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator) {
+    super(sourceEnumerator);
+    this.buffer = [];
+    this.currentIndex = 0;
+  }
+  initialize() {
+    const buffer = Array.from(this.toIterable(this.sourceEnumerator));
+    this.shuffle(buffer);
+    this.buffer = buffer;
+  }
+  handleNext() {
+    if (this.buffer.length <= this.currentIndex) {
+      return this.done();
+    }
+    const result = this.buffer[this.currentIndex];
+    this.currentIndex++;
+    return this.yield(result);
+  }
+  shuffle(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+  }
+  toIterable(sourceEnumerator) {
+    return {
+      [Symbol.iterator]: () => sourceEnumerator
+    };
+  }
+};
+
+// src/enumerators/buffer/union.ts
+var UnionEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, otherValues) {
+    super(sourceEnumerator);
+    this.bufferedValues = /* @__PURE__ */ new Set();
+    this.isSourceDone = false;
+    this.otherValues = otherValues;
+    this.currentEnumerator = this.sourceEnumerator;
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.currentEnumerator.next();
+      if (done) {
+        if (this.isSourceDone) {
+          return this.done();
+        }
+        this.isSourceDone = true;
+        this.currentEnumerator = this.otherValues[Symbol.iterator]();
+        continue;
+      }
+      if (!this.bufferedValues.has(value)) {
+        this.bufferedValues.add(value);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/unionBy.ts
+var UnionByEnumerator = class extends TyneqEnumerator {
+  constructor(sourceEnumerator, otherValues, keySelector) {
+    super(sourceEnumerator);
+    this.bufferedKeys = /* @__PURE__ */ new Set();
+    this.isSourceDone = false;
+    this.otherValues = otherValues;
+    this.currentEnumerator = this.sourceEnumerator;
+    this.keySelector = keySelector;
+  }
+  handleNext() {
+    while (true) {
+      const { done, value } = this.currentEnumerator.next();
+      if (done) {
+        if (this.isSourceDone) {
+          return this.done();
+        }
+        this.isSourceDone = true;
+        this.currentEnumerator = this.otherValues[Symbol.iterator]();
+        continue;
+      }
+      const key = this.keySelector(value);
+      if (!this.bufferedKeys.has(key)) {
+        this.bufferedKeys.add(key);
+        return this.yield(value);
+      }
+    }
+  }
+};
+
+// src/enumerators/buffer/permutations.ts
+var PermutationsEnumerator = class extends TyneqEnumerator {
+  constructor() {
+    super(...arguments);
+    this.buffer = [];
+    this.c = [];
+    this.n = 0;
+    this.i = -1;
+  }
+  initialize() {
+    this.buffer = Array.from(EnumeratorUtility.toIterable(this.sourceEnumerator));
+    this.n = this.buffer.length;
+    this.c = new Array(this.n).fill(0);
+  }
+  handleNext() {
+    if (this.i === -1) {
+      this.i = 1;
+      return this.yield([...this.buffer]);
+    }
+    while (this.i < this.n) {
+      if (this.c[this.i] < this.i) {
+        const swapIndex = this.i % 2 === 0 ? 0 : this.c[this.i];
+        [this.buffer[swapIndex], this.buffer[this.i]] = [this.buffer[this.i], this.buffer[swapIndex]];
+        this.c[this.i]++;
+        this.i = 1;
+        return this.yield([...this.buffer]);
+      } else {
+        this.c[this.i] = 0;
+        this.i++;
+      }
+    }
+    return this.done();
+  }
+};
+
+// src/core/TyneqEnumerableBase.ts
+var _unionBy_dec, _union_dec, _shuffle_dec, _reverse_dec, _permutations_dec, _join_dec, _intersectBy_dec, _intersect_dec, _groupJoin_dec, _groupBy_dec, _exceptBy_dec, _except_dec, _distinctBy_dec, _distinct_dec, _backsert_dec, _zip_dec, _where_dec, _throttle_dec, _tapIf_dec, _tap_dec, _takeWhile_dec, _takeUntil_dec, _take_dec, _split_dec, _slice_dec, _skipWhile_dec, _skipUntil_dec, _skipLast_dec, _skip_dec, _repeat_dec, _window_dec, _selectMany_dec, _select_dec, _scan_dec, _prepend_dec, _populate_dec, _pairwise_dec, _flatten_dec, _defaultIfEmpty_dec, _concat_dec, _chunk_dec, _append_dec, _ofType_dec, _toSet_dec, _toRecord_dec, _toMap_dec, _toAsync_dec, _toArray_dec, _sum_dec, _startsWith_dec, _endsWith_dec, _singleOrDefault_dec, _single_dec, _sequenceEqual_dec, _minMax_dec, _minBy_dec, _min_dec, _maxBy_dec, _max_dec, _lastOrDefault_dec, _last_dec, _isNullOrEmpty_dec, _indexOf_dec, _firstOrDefault_dec, _first_dec, _elementAtOrDefault_dec, _elementAt_dec, _countBy_dec, _count_dec, _contains_dec, _consume_dec, _average_dec, _any_dec, _all_dec, _aggregate_dec, _a2, _TyneqEnumerableBase_decorators, _init2;
+_TyneqEnumerableBase_decorators = [sequence];
+var TyneqEnumerableBase = class extends (_a2 = TyneqEnumerableCore, _aggregate_dec = [builtin({ kind: "terminal" })], _all_dec = [builtin({ kind: "terminal" })], _any_dec = [builtin({ kind: "terminal" })], _average_dec = [builtin({ kind: "terminal" })], _consume_dec = [builtin({ kind: "terminal" })], _contains_dec = [builtin({ kind: "terminal" })], _count_dec = [builtin({ kind: "terminal" })], _countBy_dec = [builtin({ kind: "terminal" })], _elementAt_dec = [builtin({ kind: "terminal" })], _elementAtOrDefault_dec = [builtin({ kind: "terminal" })], _first_dec = [builtin({ kind: "terminal" })], _firstOrDefault_dec = [builtin({ kind: "terminal" })], _indexOf_dec = [builtin({ kind: "terminal" })], _isNullOrEmpty_dec = [builtin({ kind: "terminal" })], _last_dec = [builtin({ kind: "terminal" })], _lastOrDefault_dec = [builtin({ kind: "terminal" })], _max_dec = [builtin({ kind: "terminal" })], _maxBy_dec = [builtin({ kind: "terminal" })], _min_dec = [builtin({ kind: "terminal" })], _minBy_dec = [builtin({ kind: "terminal" })], _minMax_dec = [builtin({ kind: "terminal" })], _sequenceEqual_dec = [builtin({ kind: "terminal" })], _single_dec = [builtin({ kind: "terminal" })], _singleOrDefault_dec = [builtin({ kind: "terminal" })], _endsWith_dec = [builtin({ kind: "terminal" })], _startsWith_dec = [builtin({ kind: "terminal" })], _sum_dec = [builtin({ kind: "terminal" })], _toArray_dec = [builtin({ kind: "terminal" })], _toAsync_dec = [builtin({ kind: "terminal" })], _toMap_dec = [builtin({ kind: "terminal" })], _toRecord_dec = [builtin({ kind: "terminal" })], _toSet_dec = [builtin({ kind: "terminal" })], _ofType_dec = [builtin({ kind: "streaming" })], _append_dec = [builtin({ kind: "streaming" })], _chunk_dec = [builtin({ kind: "streaming" })], _concat_dec = [builtin({ kind: "streaming" })], _defaultIfEmpty_dec = [builtin({ kind: "streaming" })], _flatten_dec = [builtin({ kind: "streaming" })], _pairwise_dec = [builtin({ kind: "streaming" })], _populate_dec = [builtin({ kind: "streaming" })], _prepend_dec = [builtin({ kind: "streaming" })], _scan_dec = [builtin({ kind: "streaming" })], _select_dec = [builtin({ kind: "streaming" })], _selectMany_dec = [builtin({ kind: "streaming" })], _window_dec = [builtin({ kind: "streaming" })], _repeat_dec = [builtin({ kind: "streaming" })], _skip_dec = [builtin({ kind: "streaming" })], _skipLast_dec = [builtin({ kind: "streaming" })], _skipUntil_dec = [builtin({ kind: "streaming" })], _skipWhile_dec = [builtin({ kind: "streaming" })], _slice_dec = [builtin({ kind: "streaming" })], _split_dec = [builtin({ kind: "streaming" })], _take_dec = [builtin({ kind: "streaming" })], _takeUntil_dec = [builtin({ kind: "streaming" })], _takeWhile_dec = [builtin({ kind: "streaming" })], _tap_dec = [builtin({ kind: "streaming" })], _tapIf_dec = [builtin({ kind: "streaming" })], _throttle_dec = [builtin({ kind: "streaming" })], _where_dec = [builtin({ kind: "streaming" })], _zip_dec = [builtin({ kind: "streaming" })], _backsert_dec = [builtin({ kind: "buffer" })], _distinct_dec = [builtin({ kind: "buffer" })], _distinctBy_dec = [builtin({ kind: "buffer" })], _except_dec = [builtin({ kind: "buffer" })], _exceptBy_dec = [builtin({ kind: "buffer" })], _groupBy_dec = [builtin({ kind: "buffer" })], _groupJoin_dec = [builtin({ kind: "buffer" })], _intersect_dec = [builtin({ kind: "buffer" })], _intersectBy_dec = [builtin({ kind: "buffer" })], _join_dec = [builtin({ kind: "buffer" })], _permutations_dec = [builtin({ kind: "buffer" })], _reverse_dec = [builtin({ kind: "buffer" })], _shuffle_dec = [builtin({ kind: "buffer" })], _union_dec = [builtin({ kind: "buffer" })], _unionBy_dec = [builtin({ kind: "buffer" })], _a2) {
+  constructor() {
+    super(...arguments);
+    _chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init2, 5, this);
+  }
+  aggregate(seed, func, resultSelector) {
+    return new AggregateOperator(this, seed, func, resultSelector).process();
+  }
+  all(predicate) {
+    return new AllOperator(this, predicate).process();
+  }
+  any(predicate) {
+    return new AnyOperator(this, predicate).process();
+  }
+  average(selector) {
+    return new AverageOperator(this, selector).process();
+  }
+  consume() {
+    new ConsumeOperator(this).process();
+  }
+  contains(value, equalityComparer) {
+    return new ContainsOperator(this, value, equalityComparer).process();
+  }
+  count() {
+    return new CountOperator(this).process();
+  }
+  countBy(predicate) {
+    return new CountByOperator(this, predicate).process();
+  }
+  elementAt(index) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ index });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ index });
+    return new ElementAtOperator(this, index).process();
+  }
+  elementAtOrDefault(index, defaultValue) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ index });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ index });
+    return new ElementAtOrDefaultOperator(this, index, defaultValue).process();
+  }
+  first(predicate) {
+    return new FirstOperator(this, predicate).process();
+  }
+  firstOrDefault(predicate, defaultValue) {
+    return new FirstOrDefaultOperator(this, predicate, defaultValue).process();
+  }
+  indexOf(predicate, startIndex = 0) {
+    return new IndexOfOperator(this, predicate, startIndex).process();
+  }
+  isNullOrEmpty() {
+    return new IsNullOrEmptyOperator(this).process();
+  }
+  last(predicate) {
+    return new LastOperator(this, predicate).process();
+  }
+  lastOrDefault(predicate, defaultValue) {
+    return new LastOrDefaultOperator(this, predicate, defaultValue).process();
+  }
+  max(comparer) {
+    return new ExtremumOperator(this, 1, "max", comparer).process();
+  }
+  maxBy(keySelector, comparer) {
+    return new ExtremumByOperator(this, keySelector, 1, "maxBy", comparer).process();
+  }
+  min(comparer) {
+    return new ExtremumOperator(this, -1, "min", comparer).process();
+  }
+  minBy(keySelector, comparer) {
+    return new ExtremumByOperator(this, keySelector, -1, "minBy", comparer).process();
+  }
+  minMax(comparer) {
+    return new MinMaxOperator(this, comparer).process();
+  }
+  sequenceEqual(other, equalityComparer) {
+    return new SequenceEqualOperator(this, other, equalityComparer).process();
+  }
+  single(predicate) {
+    return new SingleOperator(this, predicate).process();
+  }
+  singleOrDefault(predicate, defaultValue) {
+    return new SingleOrDefaultOperator(this, predicate, defaultValue).process();
+  }
+  endsWith(sequence2, equalityComparer) {
+    return new EndsWithOperator(this, sequence2, equalityComparer).process();
+  }
+  startsWith(sequence2, equalityComparer) {
+    return new StartsWithOperator(this, sequence2, equalityComparer).process();
+  }
+  sum(selector) {
+    return new SumOperator(this, selector).process();
+  }
+  toArray() {
+    return new ToArrayOperator(this).process();
+  }
+  toAsync() {
+    return new ToAsyncOperator(this).process();
+  }
+  toMap(selector) {
+    return new ToMapOperator(this, selector).process();
+  }
+  toRecord(selector) {
+    return new ToRecordOperator(this, selector).process();
+  }
+  toSet() {
+    return new ToSetOperator(this).process();
+  }
+  ofType(guard) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ guard });
+    return this.createSequence(
+      () => new OfTypeEnumerator(this.getEnumerator(), guard),
+      this.createNode("ofType", "streaming", [guard])
+    );
+  }
+  append(item) {
+    return this.createSequence(
+      () => new AppendEnumerator(this.getEnumerator(), item),
+      this.createNode("append", "streaming", [item])
+    );
+  }
+  chunk(size) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ size });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkPositive({ size });
+    return this.createSequence(
+      () => new ChunkEnumerator(this.getEnumerator(), size),
+      this.createNode("chunk", "streaming", [size])
+    );
+  }
+  concat(other) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ other });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ other });
+    return this.createSequence(
+      () => new ConcatEnumerator(this.getEnumerator(), other),
+      this.createNode("concat", "streaming", [other])
+    );
+  }
+  defaultIfEmpty(defaultValue) {
+    return this.createSequence(
+      () => new DefaultIfEmptyEnumerator(this.getEnumerator(), defaultValue),
+      this.createNode("defaultIfEmpty", "streaming", [defaultValue])
+    );
+  }
+  flatten() {
+    const self = this;
+    return self.createSequence(
+      () => new FlattenEnumerator(self.getEnumerator()),
+      self.createNode("flatten", "streaming")
+    );
+  }
+  pairwise() {
+    return this.createSequence(
+      () => new PairwiseEnumerator(this.getEnumerator()),
+      this.createNode("pairwise", "streaming")
+    );
+  }
+  populate(value) {
+    return this.createSequence(
+      () => new PopulateEnumerator(this.getEnumerator(), value),
+      this.createNode("populate", "streaming", [value])
+    );
+  }
+  prepend(item) {
+    return this.createSequence(
+      () => new PrependEnumerator(this.getEnumerator(), item),
+      this.createNode("prepend", "streaming", [item])
+    );
+  }
+  scan(seed, accumulator) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ accumulator });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkFunction({ accumulator });
+    return this.createSequence(
+      () => new ScanEnumerator(this.getEnumerator(), seed, accumulator),
+      this.createNode("scan", "streaming", [seed, accumulator])
+    );
+  }
+  select(selector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    return this.createSequence(
+      () => new SelectEnumerator(this.getEnumerator(), selector),
+      this.createNode("select", "streaming", [selector])
+    );
+  }
+  selectMany(selector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    return this.createSequence(
+      () => new SelectManyEnumerator(this.getEnumerator(), selector),
+      this.createNode("selectMany", "streaming", [selector])
+    );
+  }
+  window(size, step = 1) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ size });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkPositive({ size });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ step });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkPositive({ step });
+    return this.createSequence(
+      () => new WindowEnumerator(this.getEnumerator(), size, step),
+      this.createNode("window", "streaming", [size, step])
+    );
+  }
+  repeat(count) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ count });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkInteger({ count });
+    return this.createSequence(
+      () => new RepeatSequenceEnumerator(this.getEnumerator(), this, count),
+      this.createNode("repeat", "streaming", [count])
+    );
+  }
+  skip(count) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ count });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ count });
+    return this.createSequence(
+      () => new SkipEnumerator(this.getEnumerator(), count),
+      this.createNode("skip", "streaming", [count])
+    );
+  }
+  skipLast(count) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ count });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ count });
+    return this.createSequence(
+      () => new SkipLastEnumerator(this.getEnumerator(), count),
+      this.createNode("skipLast", "streaming", [count])
+    );
+  }
+  skipUntil(predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new SkipUntilEnumerator(this.getEnumerator(), predicate),
+      this.createNode("skipUntil", "streaming", [predicate])
+    );
+  }
+  skipWhile(predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new SkipWhileEnumerator(this.getEnumerator(), predicate),
+      this.createNode("skipWhile", "streaming", [predicate])
+    );
+  }
+  slice(start, end) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ start });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ start });
+    if (end !== void 0) {
+      _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ end });
+      _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ end });
+      if (end < start) {
+        throw new (0, _chunkOWKUE3ACcjs.ArgumentOutOfRangeError)("end", "`end` must be greater than or equal to `start`.");
+      }
+    }
+    const resolvedEnd = end != null ? end : Number.MAX_SAFE_INTEGER;
+    return this.createSequence(
+      () => new SliceEnumerator(this.getEnumerator(), start, resolvedEnd),
+      this.createNode("slice", "streaming", [start, end])
+    );
+  }
+  split(splitOn) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ splitOn });
+    return this.createSequence(
+      () => new SplitEnumerator(this.getEnumerator(), splitOn),
+      this.createNode("split", "streaming", [splitOn])
+    );
+  }
+  take(count) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ count });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ count });
+    return this.createSequence(
+      () => new TakeEnumerator(this.getEnumerator(), count),
+      this.createNode("take", "streaming", [count])
+    );
+  }
+  takeUntil(predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new TakeUntilEnumerator(this.getEnumerator(), predicate),
+      this.createNode("takeUntil", "streaming", [predicate])
+    );
+  }
+  takeWhile(predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new TakeWhileEnumerator(this.getEnumerator(), predicate),
+      this.createNode("takeWhile", "streaming", [predicate])
+    );
+  }
+  tap(action) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ action });
+    return this.createSequence(
+      () => new TapEnumerator(this.getEnumerator(), action),
+      this.createNode("tap", "streaming", [action])
+    );
+  }
+  tapIf(action, predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ action });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new TapIfEnumerator(this.getEnumerator(), action, predicate),
+      this.createNode("tapIf", "streaming", [action, predicate])
+    );
+  }
+  throttle(count) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ count });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkPositive({ count });
+    return this.createSequence(
+      () => new ThrottleEnumerator(this.getEnumerator(), count),
+      this.createNode("throttle", "streaming", [count])
+    );
+  }
+  where(predicate) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ predicate });
+    return this.createSequence(
+      () => new WhereEnumerator(this.getEnumerator(), predicate),
+      this.createNode("where", "streaming", [predicate])
+    );
+  }
+  zip(other, selector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ other });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ other });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ selector });
+    return this.createSequence(
+      () => new ZipEnumerator(this.getEnumerator(), other, selector),
+      this.createNode("zip", "streaming", [other, selector])
+    );
+  }
+  backsert(index, other) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ other });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkSafeInteger({ index });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNonNegative({ index });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ other });
+    return this.createSequence(
+      () => new BacksertEnumerator(this.getEnumerator(), index, other),
+      this.createNode("backsert", "buffer", [index, other])
+    );
+  }
+  distinct() {
+    return this.createSequence(
+      () => new DistinctEnumerator(this.getEnumerator()),
+      this.createNode("distinct", "buffer")
+    );
+  }
+  distinctBy(keySelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    return this.createSequence(
+      () => new DistinctByEnumerator(this.getEnumerator(), keySelector),
+      this.createNode("distinctBy", "buffer", [keySelector])
+    );
+  }
+  except(excludedValues) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ excludedValues });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ excludedValues });
+    return this.createSequence(
+      () => new ExceptEnumerator(this.getEnumerator(), excludedValues),
+      this.createNode("except", "buffer", [excludedValues])
+    );
+  }
+  exceptBy(excludedKeys, keySelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ excludedKeys });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ excludedKeys });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    return this.createSequence(
+      () => new ExceptByEnumerator(this.getEnumerator(), excludedKeys, keySelector),
+      this.createNode("exceptBy", "buffer", [excludedKeys, keySelector])
+    );
+  }
+  groupBy(keySelector, valueSelector, resultSelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ valueSelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ resultSelector });
+    const groupFactory = (values) => this.createEnumerable({ getEnumerator: () => values[Symbol.iterator]() }, null);
+    return this.createSequence(
+      () => new GroupByEnumerator(
+        this.getEnumerator(),
+        keySelector,
+        valueSelector,
+        resultSelector,
+        groupFactory
+      ),
+      this.createNode("groupBy", "buffer", [keySelector, valueSelector, resultSelector])
+    );
+  }
+  groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ inner });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ inner });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ outerKeySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ innerKeySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ resultSelector });
+    const groupFactory = (values) => this.createEnumerable({ getEnumerator: () => values[Symbol.iterator]() }, null);
+    return this.createSequence(
+      () => new GroupJoinEnumerator(
+        this.getEnumerator(),
+        inner,
+        outerKeySelector,
+        innerKeySelector,
+        resultSelector,
+        groupFactory
+      ),
+      this.createNode("groupJoin", "buffer", [inner, outerKeySelector, innerKeySelector, resultSelector])
+    );
+  }
+  intersect(intersectedValues) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ intersectedValues });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ intersectedValues });
+    return this.createSequence(
+      () => new IntersectEnumerator(this.getEnumerator(), intersectedValues),
+      this.createNode("intersect", "buffer", [intersectedValues])
+    );
+  }
+  intersectBy(intersectedKeys, keySelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ intersectedKeys });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ intersectedKeys });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    return this.createSequence(
+      () => new IntersectByEnumerator(this.getEnumerator(), intersectedKeys, keySelector),
+      this.createNode("intersectBy", "buffer", [intersectedKeys, keySelector])
+    );
+  }
+  join(inner, outerKeySelector, innerKeySelector, resultSelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ inner });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ inner });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ outerKeySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ innerKeySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ resultSelector });
+    return this.createSequence(
+      () => new JoinEnumerator(
+        this.getEnumerator(),
+        inner,
+        outerKeySelector,
+        innerKeySelector,
+        resultSelector
+      ),
+      this.createNode("join", "buffer", [inner, outerKeySelector, innerKeySelector, resultSelector])
+    );
+  }
+  permutations() {
+    return this.createSequence(
+      () => new PermutationsEnumerator(this.getEnumerator()),
+      this.createNode("permutations", "buffer")
+    );
+  }
+  reverse() {
+    return this.createSequence(
+      () => new ReverseEnumerator(this.getEnumerator()),
+      this.createNode("reverse", "buffer")
+    );
+  }
+  shuffle() {
+    return this.createSequence(
+      () => new ShuffleEnumerator(this.getEnumerator()),
+      this.createNode("shuffle", "buffer")
+    );
+  }
+  union(otherValues) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ otherValues });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ otherValues });
+    return this.createSequence(
+      () => new UnionEnumerator(this.getEnumerator(), otherValues),
+      this.createNode("union", "buffer", [otherValues])
+    );
+  }
+  unionBy(otherValues, keySelector) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ otherValues });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkIterable({ otherValues });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    return this.createSequence(
+      () => new UnionByEnumerator(this.getEnumerator(), otherValues, keySelector),
+      this.createNode("unionBy", "buffer", [otherValues, keySelector])
+    );
+  }
+};
+_init2 = _chunkOWKUE3ACcjs.__decoratorStart.call(void 0, _a2);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "aggregate", _aggregate_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "all", _all_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "any", _any_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "average", _average_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "consume", _consume_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "contains", _contains_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "count", _count_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "countBy", _countBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "elementAt", _elementAt_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "elementAtOrDefault", _elementAtOrDefault_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "first", _first_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "firstOrDefault", _firstOrDefault_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "indexOf", _indexOf_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "isNullOrEmpty", _isNullOrEmpty_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "last", _last_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "lastOrDefault", _lastOrDefault_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "max", _max_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "maxBy", _maxBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "min", _min_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "minBy", _minBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "minMax", _minMax_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "sequenceEqual", _sequenceEqual_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "single", _single_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "singleOrDefault", _singleOrDefault_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "endsWith", _endsWith_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "startsWith", _startsWith_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "sum", _sum_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "toArray", _toArray_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "toAsync", _toAsync_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "toMap", _toMap_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "toRecord", _toRecord_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "toSet", _toSet_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "ofType", _ofType_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "append", _append_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "chunk", _chunk_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "concat", _concat_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "defaultIfEmpty", _defaultIfEmpty_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "flatten", _flatten_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "pairwise", _pairwise_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "populate", _populate_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "prepend", _prepend_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "scan", _scan_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "select", _select_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "selectMany", _selectMany_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "window", _window_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "repeat", _repeat_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "skip", _skip_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "skipLast", _skipLast_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "skipUntil", _skipUntil_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "skipWhile", _skipWhile_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "slice", _slice_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "split", _split_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "take", _take_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "takeUntil", _takeUntil_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "takeWhile", _takeWhile_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "tap", _tap_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "tapIf", _tapIf_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "throttle", _throttle_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "where", _where_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "zip", _zip_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "backsert", _backsert_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "distinct", _distinct_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "distinctBy", _distinctBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "except", _except_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "exceptBy", _exceptBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "groupBy", _groupBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "groupJoin", _groupJoin_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "intersect", _intersect_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "intersectBy", _intersectBy_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "join", _join_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "permutations", _permutations_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "reverse", _reverse_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "shuffle", _shuffle_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "union", _union_dec, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 1, "unionBy", _unionBy_dec, TyneqEnumerableBase);
+TyneqEnumerableBase = _chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init2, 0, "TyneqEnumerableBase", _TyneqEnumerableBase_decorators, TyneqEnumerableBase);
+_chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init2, 1, TyneqEnumerableBase);
+
+// src/core/OperatorMetadata.ts
+var OperatorMetadata = class _OperatorMetadata {
+  constructor(name, kind, source2 = "external", targetClass, extensions = {}) {
+    this.name = name;
+    this.kind = kind;
+    this.source = source2;
+    this.targetClass = arguments.length < 4 ? TyneqEnumerableBase : targetClass;
+    this.extensions = extensions;
+  }
+  /**
+   * Creates metadata for a source operator.
+   *
+   * @remarks
+   * `targetClass` is always `undefined` for source operators - they are static
+   * factories with no prototype and are never patched onto a class instance.
+   */
+  static source(name, src = "external") {
+    return new _OperatorMetadata(name, "source", src, void 0);
+  }
+  /** Creates metadata for a streaming operator. Defaults targetClass to TyneqEnumerableBase. */
+  static streaming(name, targetClass = TyneqEnumerableBase, source2, extensions) {
+    return new _OperatorMetadata(name, "streaming", source2 != null ? source2 : "external", targetClass, extensions);
+  }
+  /** Creates metadata for a buffering operator. Defaults targetClass to TyneqEnumerableBase. */
+  static buffer(name, targetClass = TyneqEnumerableBase, source2, extensions) {
+    return new _OperatorMetadata(name, "buffer", source2 != null ? source2 : "external", targetClass, extensions);
+  }
+  /** Creates metadata for a terminal operator. Defaults targetClass to TyneqEnumerableBase. */
+  static terminal(name, targetClass = TyneqEnumerableBase, source2, extensions) {
+    return new _OperatorMetadata(name, "terminal", source2 != null ? source2 : "external", targetClass, extensions);
+  }
+  /**
+   * Creates metadata for a streaming or buffer operator determined at runtime.
+   *
+   * @remarks
+   * Use when the category is a variable rather than a compile-time literal --
+   * for example in `@operator` and `@orderedOperator` whose `category` parameter
+   * is provided by the caller. For compile-time-known categories prefer the
+   * dedicated {@link streaming} / {@link buffer} / {@link terminal} statics.
+   *
+   * Only `"streaming"` and `"buffer"` are valid; passing `"terminal"` or `"source"` throws.
+   */
+  static forCategory(category, name, targetClass = TyneqEnumerableBase, source2, extensions) {
+    if (category === "streaming") {
+      return _OperatorMetadata.streaming(name, targetClass, source2, extensions);
+    }
+    if (category === "buffer") {
+      return _OperatorMetadata.buffer(name, targetClass, source2, extensions);
+    }
+    throw new PluginError(
+      `OperatorMetadata.forCategory: unsupported category "${category}". Use .terminal() or .source() directly.`,
+      "forCategory",
+      name
+    );
+  }
+};
+
+// src/core/ordering/BaseEnumerableSorter.ts
+var BaseEnumerableSorter = class {
+  /**
+   * Returns a stable sorted index map for `source[0..count-1]`.
+   *
+   * @returns An array of indices sorted by the key order defined by this sorter chain.
+   */
+  sort(source2, count) {
+    this.computeKeys([...source2], count);
+    const indexMap = Array.from({ length: count }, (_, i) => i);
+    indexMap.sort((a, b) => this.compareKeys(a, b));
+    return indexMap;
+  }
+};
+
+// src/core/ordering/TyneqEnumerableSorter.ts
+var TyneqEnumerableSorter = class extends BaseEnumerableSorter {
+  constructor(keySelector, comparer, descending, next) {
+    super();
+    this.keys = [];
+    this.next = null;
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ comparer });
+    this.keySelector = keySelector;
+    this.comparer = comparer;
+    this.descending = descending ? -1 : 1;
+    this.next = next != null ? next : null;
+  }
+  computeKeys(source2, count) {
+    var _a6;
+    this.keys = new Array(count);
+    for (let i = 0; i < count; i++) {
+      this.keys[i] = this.keySelector(source2[i]);
+    }
+    (_a6 = this.next) == null ? void 0 : _a6.computeKeys(source2, count);
+  }
+  compareKeys(i, j) {
+    const result = this.comparer(this.keys[i], this.keys[j]) * this.descending;
+    if (result !== 0) {
+      return result;
+    }
+    if (this.next === null) {
+      return this.stabilityCompare(i, j);
+    }
+    return this.next.compareKeys(i, j);
+  }
+  stabilityCompare(i, j) {
+    return i - j;
+  }
+};
+
+// src/enumerators/buffer/memoize.ts
+var MemoizeEnumerator = class extends TyneqBaseEnumerator {
+  constructor(cachedEnumerable) {
+    super();
+    this.index = 0;
+    this.cachedEnumerable = cachedEnumerable;
+  }
+  disposeSource() {
+  }
+  handleNext() {
+    const result = this.cachedEnumerable.tryGetAtFromCache(this.index);
+    if (!result.has) {
+      return this.done();
+    }
+    this.index++;
+    return this.yield(result.value);
+  }
+};
+
+// src/core/TyneqCachedEnumerable.ts
+var _refresh_dec, _a3, _b, _TyneqCachedEnumerable_decorators, _init3;
+_TyneqCachedEnumerable_decorators = [sequence];
+var _TyneqCachedEnumerable = class _TyneqCachedEnumerable extends (_b = TyneqEnumerableBase, _a3 = tyneqQueryNode, _refresh_dec = [builtin({ kind: "cache" })], _b) {
+  constructor(source2, node) {
+    super();
+    _chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init3, 5, this);
+    this.source = void 0;
+    this.cache = [];
+    this.done = false;
+    this.sourceEnumerator = null;
+    this[_a3] = void 0;
+    this.source = source2;
+    this[tyneqQueryNode] = node != null ? node : null;
+  }
+  getEnumerator() {
+    return new MemoizeEnumerator(this);
+  }
+  refresh() {
+    var _a6, _b3;
+    this.cache = [];
+    this.done = false;
+    (_b3 = (_a6 = this.sourceEnumerator) == null ? void 0 : _a6.return) == null ? void 0 : _b3.call(_a6);
+    this.sourceEnumerator = null;
+    return this;
+  }
+  tryGetAtFromCache(index) {
+    var _a6, _b3;
+    if (index < this.cache.length) {
+      return { has: true, value: this.cache[index] };
+    }
+    if (this.done) {
+      return { has: false };
+    }
+    if (this.sourceEnumerator === null) {
+      this.sourceEnumerator = this.source.getEnumerator();
+    }
+    const next = this.sourceEnumerator.next();
+    if (!next.done) {
+      const value = next.value;
+      this.cache.push(value);
+      return { has: true, value };
+    }
+    this.done = true;
+    (_b3 = (_a6 = this.sourceEnumerator).return) == null ? void 0 : _b3.call(_a6);
+    this.sourceEnumerator = null;
+    return { has: false };
+  }
+  createEnumerable(factory, node) {
+    return new TyneqEnumerable(factory, node);
+  }
+  createOrderedEnumerable(keySelector, comparer, descending, node) {
+    return new TyneqOrderedEnumerable(
+      this,
+      keySelector,
+      comparer,
+      descending,
+      void 0,
+      node
+    );
+  }
+  createCachedEnumerable(source2, node) {
+    return new _TyneqCachedEnumerable(source2, node);
+  }
+};
+_init3 = _chunkOWKUE3ACcjs.__decoratorStart.call(void 0, _b);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init3, 1, "refresh", _refresh_dec, _TyneqCachedEnumerable);
+_TyneqCachedEnumerable = _chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init3, 0, "TyneqCachedEnumerable", _TyneqCachedEnumerable_decorators, _TyneqCachedEnumerable);
+_chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init3, 1, _TyneqCachedEnumerable);
+var TyneqCachedEnumerable = _TyneqCachedEnumerable;
+
+// src/core/TyneqEnumerable.ts
+var _a4;
+var TyneqEnumerable = class _TyneqEnumerable extends (_a4 = TyneqEnumerableBase, tyneqQueryNode, _a4) {
+  constructor(enumeratorFactory, node) {
+    super();
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ enumeratorFactory });
+    this.enumeratorFactory = enumeratorFactory;
+    this[tyneqQueryNode] = node != null ? node : null;
+  }
+  getEnumerator() {
+    return this.enumeratorFactory.getEnumerator();
+  }
+  createEnumerable(factory, node) {
+    return new _TyneqEnumerable(factory, node);
+  }
+  createOrderedEnumerable(keySelector, comparer, descending, node) {
+    return new TyneqOrderedEnumerable(
+      this,
+      keySelector,
+      comparer,
+      descending,
+      void 0,
+      node
+    );
+  }
+  createCachedEnumerable(source2, node) {
+    return new TyneqCachedEnumerable(source2, node);
+  }
+};
+
+// src/enumerators/buffer/orderBy.ts
+var OrderByEnumerator = class extends TyneqBaseEnumerator {
+  constructor(orderedEnumerable) {
+    super();
+    this.buffer = [];
+    this.indexMap = [];
+    this.currentIndex = 0;
+    this.orderedEnumerable = orderedEnumerable;
+  }
+  initialize() {
+    this.buffer = Array.from(this.orderedEnumerable.source);
+    const sorter = this.getSorter(this.orderedEnumerable);
+    this.indexMap = sorter.sort(this.buffer, this.buffer.length);
+  }
+  handleNext() {
+    if (this.currentIndex >= this.indexMap.length) {
+      return this.done();
+    }
+    const index = this.indexMap[this.currentIndex++];
+    return this.yield(this.buffer[index]);
+  }
+  getSorter(base) {
+    let sorter = null;
+    for (let enumerable = base; enumerable !== null; enumerable = enumerable.parent) {
+      sorter = enumerable.getSorter(sorter);
+    }
+    return sorter;
+  }
+};
+
+// src/core/ordering/TyneqOrderedEnumerable.ts
+var ASC_TO_DESC = {
+  "orderBy": "orderByDescending",
+  "thenBy": "thenByDescending"
+};
+var DESC_TO_ASC = {
+  "orderByDescending": "orderBy",
+  "thenByDescending": "thenBy"
+};
+var _thenByDescending_dec, _thenBy_dec, _a5, _b2, _TyneqOrderedEnumerable_decorators, _init4;
+_TyneqOrderedEnumerable_decorators = [sequence];
+var _TyneqOrderedEnumerable = class _TyneqOrderedEnumerable extends (_b2 = TyneqEnumerableBase, _a5 = tyneqQueryNode, _thenBy_dec = [builtin({ kind: "buffer" })], _thenByDescending_dec = [builtin({ kind: "buffer" })], _b2) {
+  constructor(source2, keySelector, comparer, descending, parent, node) {
+    super();
+    _chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init4, 5, this);
+    this.keySelector = void 0;
+    this.comparer = void 0;
+    this.descending = void 0;
+    this.source = void 0;
+    this.parent = void 0;
+    this[_a5] = void 0;
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ source: source2 });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ keySelector });
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ comparer });
+    this.source = source2;
+    this.keySelector = keySelector;
+    this.comparer = comparer;
+    this.descending = descending;
+    this.parent = parent != null ? parent : null;
+    this[tyneqQueryNode] = node != null ? node : null;
+  }
+  asc() {
+    var _a6, _b3;
+    if (!this.descending) {
+      return this;
+    }
+    const currentNode = this[tyneqQueryNode];
+    const node = currentNode ? new QueryNode((_a6 = DESC_TO_ASC[currentNode.operatorName]) != null ? _a6 : currentNode.operatorName, currentNode.args, currentNode.source, currentNode.category, currentNode.sourceKind) : null;
+    return new _TyneqOrderedEnumerable(
+      this.source,
+      this.keySelector,
+      this.comparer,
+      false,
+      (_b3 = this.parent) != null ? _b3 : void 0,
+      node
+    );
+  }
+  desc() {
+    var _a6, _b3;
+    if (this.descending) {
+      return this;
+    }
+    const currentNode = this[tyneqQueryNode];
+    const node = currentNode ? new QueryNode((_a6 = ASC_TO_DESC[currentNode.operatorName]) != null ? _a6 : currentNode.operatorName, currentNode.args, currentNode.source, currentNode.category, currentNode.sourceKind) : null;
+    return new _TyneqOrderedEnumerable(
+      this.source,
+      this.keySelector,
+      this.comparer,
+      true,
+      (_b3 = this.parent) != null ? _b3 : void 0,
+      node
+    );
+  }
+  getEnumerator() {
+    return new OrderByEnumerator(this);
+  }
+  getSorter(next) {
+    return new TyneqEnumerableSorter(
+      this.keySelector,
+      this.comparer,
+      this.descending,
+      next != null ? next : void 0
+    );
+  }
+  thenBy(keySelector, comparer) {
+    const thenByArgs = comparer !== void 0 ? [keySelector, comparer] : [keySelector];
+    const node = new QueryNode("thenBy", thenByArgs, this[tyneqQueryNode], "buffer");
+    return new _TyneqOrderedEnumerable(
+      this.source,
+      keySelector,
+      comparer != null ? comparer : TyneqComparer.defaultComparer,
+      false,
+      this,
+      node
+    );
+  }
+  thenByDescending(keySelector, comparer) {
+    const thenByDescArgs = comparer !== void 0 ? [keySelector, comparer] : [keySelector];
+    const node = new QueryNode("thenByDescending", thenByDescArgs, this[tyneqQueryNode], "buffer");
+    return new _TyneqOrderedEnumerable(
+      this.source,
+      keySelector,
+      comparer != null ? comparer : TyneqComparer.defaultComparer,
+      true,
+      this,
+      node
+    );
+  }
+  createEnumerable(factory, node) {
+    return new TyneqEnumerable(factory, node);
+  }
+  createOrderedEnumerable(keySelector, comparer, descending, node) {
+    return new _TyneqOrderedEnumerable(
+      this.source,
+      keySelector,
+      comparer,
+      descending,
+      this,
+      node
+    );
+  }
+  createCachedEnumerable(source2, node) {
+    return new TyneqCachedEnumerable(source2, node);
+  }
+};
+_init4 = _chunkOWKUE3ACcjs.__decoratorStart.call(void 0, _b2);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init4, 1, "thenBy", _thenBy_dec, _TyneqOrderedEnumerable);
+_chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init4, 1, "thenByDescending", _thenByDescending_dec, _TyneqOrderedEnumerable);
+_TyneqOrderedEnumerable = _chunkOWKUE3ACcjs.__decorateElement.call(void 0, _init4, 0, "TyneqOrderedEnumerable", _TyneqOrderedEnumerable_decorators, _TyneqOrderedEnumerable);
+_chunkOWKUE3ACcjs.__runInitializers.call(void 0, _init4, 1, _TyneqOrderedEnumerable);
+var TyneqOrderedEnumerable = _TyneqOrderedEnumerable;
+
+// src/plugin/decorators/source.ts
+function source(options = {}) {
+  return function(method, context) {
+    var _a6, _b3;
+    const operatorName = (_a6 = options.name) != null ? _a6 : context.name;
+    const operatorSource = (_b3 = options.source) != null ? _b3 : "external";
+    OperatorRegistry.registerSource(operatorName, method, operatorSource);
+  };
+}
+
+// src/plugin/RegistrationUtility.ts
+var RegistrationUtility = class _RegistrationUtility {
+  constructor() {
+  }
+  /**
+   * Builds a new sequence from an enumerator factory and registers a query plan node.
+   *
+   * @remarks
+   * Every standard (non-terminal, non-ordered, non-cached) operator `impl` follows
+   * the same pattern: get the `SequenceFactory` view of `this`, create a `QueryNode`,
+   * then call `factory.createEnumerable(enumeratorFactory, node)`. This method
+   * centralises that pattern so decorator and factory `impl` bodies stay minimal.
+   *
+   * @param sequence - The current sequence (`this` inside an `impl` function).
+   * @param name - Operator name, used as the query node label.
+   * @param userArgs - Arguments passed by the caller, captured in the query node.
+   * @param category - Operator category for the query node.
+   * @param enumeratorFactory - The factory that produces the new enumerator.
+   */
+  static buildEnumerable(sequence2, name, userArgs, category, enumeratorFactory) {
+    const factory = _RegistrationUtility.asSequenceFactory(sequence2);
+    const node = new QueryNode(name, userArgs, factory[tyneqQueryNode], category);
+    return factory.createEnumerable(enumeratorFactory, node);
+  }
+  /**
+   * Creates a `QueryPlanNode` for an operator, linked to the upstream node on `sequence`.
+   *
+   * @remarks
+   * Used by `createOrderedOperator` and `createCachedOperator`, which hand the node
+   * directly to their own factory function (because those factories construct the result
+   * sequence themselves rather than delegating to `createEnumerable`).
+   *
+   * @param sequence - The current sequence (`this` inside an `impl` function).
+   * @param name - Operator name, used as the query node label.
+   * @param userArgs - Arguments passed by the caller, captured in the query node.
+   * @param category - Operator category for the query node.
+   */
+  static buildQueryNode(sequence2, name, userArgs, category) {
+    const factory = _RegistrationUtility.asSequenceFactory(sequence2);
+    return new QueryNode(name, userArgs, factory[tyneqQueryNode], category);
+  }
+  /**
+   * Narrows a `TyneqEnumerableBase` to its `SequenceFactory` view.
+   *
+   * @remarks
+   * The double-cast (`as unknown as SequenceFactory`) is required because
+   * `createEnumerable` and `createCachedEnumerable` are `protected` on the
+   * class hierarchy. `SequenceFactory` is a structural interface that describes
+   * the same shape, allowing registration-time closures to call factory methods
+   * without changing their access modifier. This is a known architectural trade-off
+   * documented in `tasks/lessons.md` under "Architecture Decisions".
+   */
+  static asSequenceFactory(sequence2) {
+    return sequence2;
+  }
+};
+
+// src/plugin/decorators/operator.ts
+function operator(name, category, validate) {
+  return function(target, _context) {
+    if (!_chunkOWKUE3ACcjs.reflect.call(void 0, target.prototype).hasMethod("handleNext")) {
+      throw new PluginError(
+        `@operator("${name}"): class "${target.name}" must define a protected handleNext(): IteratorResult<T> method. Ensure the class extends TyneqEnumerator<TInput, TOutput>.`,
+        "operator",
+        target.name
+      );
+    }
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.forCategory(category, name, TyneqEnumerableBase),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        const base = this;
+        return RegistrationUtility.buildEnumerable(this, name, userArgs, category, {
+          getEnumerator() {
+            return new target(base.getEnumerator(), ...userArgs);
+          }
+        });
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/decorators/orderedOperator.ts
+function orderedOperator(name, category, validate) {
+  return function(target, _context) {
+    if (!_chunkOWKUE3ACcjs.reflect.call(void 0, target.prototype).hasMethod("handleNext")) {
+      throw new PluginError(
+        `@orderedOperator("${name}"): class "${target.name}" must define a protected handleNext(): IteratorResult<T> method. Ensure the class extends TyneqOrderedEnumerator<T>.`,
+        "orderedOperator",
+        target.name
+      );
+    }
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.forCategory(category, name, TyneqOrderedEnumerable),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        const base = this;
+        return RegistrationUtility.buildEnumerable(this, name, userArgs, category, {
+          getEnumerator: () => new target(base, ...userArgs)
+        });
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/decorators/cachedOperator.ts
+function cachedOperator(name, category, validate) {
+  return function(target, _context) {
+    if (!_chunkOWKUE3ACcjs.reflect.call(void 0, target.prototype).hasMethod("handleNext")) {
+      throw new PluginError(
+        `@cachedOperator("${name}"): class "${target.name}" must define a protected handleNext(): IteratorResult<T> method. Ensure the class extends TyneqCachedEnumerator<T>.`,
+        "cachedOperator",
+        target.name
+      );
+    }
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.forCategory(category, name, TyneqCachedEnumerable),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        const base = this;
+        return RegistrationUtility.buildEnumerable(this, name, userArgs, category, {
+          getEnumerator: () => new target(base, ...userArgs)
+        });
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/decorators/terminal.ts
+function terminal(name, validate) {
+  return function(target, _context) {
+    if (!_chunkOWKUE3ACcjs.reflect.call(void 0, target.prototype).hasMethod("process")) {
+      throw new PluginError(
+        `@terminal("${name}"): class "${target.name}" must define a public process(): TResult method. Ensure the class extends TyneqTerminalOperator<TSource, TResult>.`,
+        "terminal",
+        target.name
+      );
+    }
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.terminal(name, TyneqEnumerableBase),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        return new target(this, ...userArgs).process();
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/decorators/orderedTerminal.ts
+function orderedTerminal(name, validate) {
+  return function(target, _context) {
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.terminal(name, TyneqOrderedEnumerable),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        const source2 = this;
+        return new target(source2, ...userArgs).process();
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/decorators/cachedTerminal.ts
+function cachedTerminal(name, validate) {
+  return function(target, _context) {
+    OperatorRegistry.register({
+      metadata: OperatorMetadata.terminal(name, TyneqCachedEnumerable),
+      impl: function(...userArgs) {
+        validate == null ? void 0 : validate(...userArgs);
+        const source2 = this;
+        return new target(source2, ...userArgs).process();
+      }
+    });
+    return target;
+  };
+}
+
+// src/plugin/registration/createOperator.ts
+function createOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.forCategory(config.category, config.name, TyneqEnumerableBase, config.source),
+    impl: function(...args) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...args);
+      return RegistrationUtility.buildEnumerable(
+        this,
+        config.name,
+        args,
+        config.category,
+        config.factory(this, ...args)
+      );
+    }
+  });
+}
+
+// src/plugin/registration/createGeneratorOperator.ts
+function createGeneratorOperator(config) {
+  var _a6;
+  const category = (_a6 = config.category) != null ? _a6 : "streaming";
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.forCategory(category, config.name, TyneqEnumerableBase, config.source),
+    impl: function(...args) {
+      var _a7;
+      (_a7 = config.validate) == null ? void 0 : _a7.call(config, ...args);
+      const source2 = this;
+      return RegistrationUtility.buildEnumerable(this, config.name, args, category, {
+        // IterableIterator<T> is structurally compatible with Enumerator<T>
+        getEnumerator: () => config.generator(source2, ...args)
+      });
+    }
+  });
+}
+
+// src/plugin/registration/createOrderedOperator.ts
+function createOrderedOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.forCategory(config.category, config.name, TyneqOrderedEnumerable, config.source),
+    impl: function(...userArgs) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...userArgs);
+      const source2 = this;
+      const node = RegistrationUtility.buildQueryNode(this, config.name, userArgs, config.category);
+      return config.factory(source2, node, ...userArgs);
+    }
+  });
+}
+
+// src/plugin/registration/createCachedOperator.ts
+function createCachedOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.forCategory(config.category, config.name, TyneqCachedEnumerable, config.source),
+    impl: function(...userArgs) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...userArgs);
+      const source2 = this;
+      const node = RegistrationUtility.buildQueryNode(this, config.name, userArgs, config.category);
+      return config.factory(source2, node, ...userArgs);
+    }
+  });
+}
+
+// src/plugin/registration/createTerminalOperator.ts
+function createTerminalOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.terminal(config.name, TyneqEnumerableBase, config.source),
+    impl: function(...args) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...args);
+      return config.execute(this, ...args);
+    }
+  });
+}
+
+// src/plugin/registration/createOrderedTerminalOperator.ts
+function createOrderedTerminalOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.terminal(config.name, TyneqOrderedEnumerable, config.source),
+    impl: function(...args) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...args);
+      return config.execute(this, ...args);
+    }
+  });
+}
+
+// src/plugin/registration/createCachedTerminalOperator.ts
+function createCachedTerminalOperator(config) {
+  OperatorRegistry.register({
+    metadata: OperatorMetadata.terminal(config.name, TyneqCachedEnumerable, config.source),
+    impl: function(...args) {
+      var _a6;
+      (_a6 = config.validate) == null ? void 0 : _a6.call(config, ...args);
+      return config.execute(this, ...args);
+    }
+  });
+}
+
+// src/core/enumerators/TyneqOrderedEnumerator.ts
+var TyneqOrderedEnumerator = class extends TyneqBaseEnumerator {
+  constructor(orderedSource) {
+    super();
+    this.orderedSource = orderedSource;
+  }
+  disposeSource() {
+  }
+};
+
+// src/core/enumerators/TyneqCachedEnumerator.ts
+var TyneqCachedEnumerator = class extends TyneqBaseEnumerator {
+  constructor(cachedSource) {
+    super();
+    this.cachedSource = cachedSource;
+  }
+  disposeSource() {
+  }
+};
+
+// src/core/terminal/TyneqOrderedTerminalOperator.ts
+var TyneqOrderedTerminalOperator = class {
+  constructor(source2) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ source: source2 });
+    this.source = source2;
+  }
+};
+
+// src/core/terminal/TyneqCachedTerminalOperator.ts
+var TyneqCachedTerminalOperator = class {
+  constructor(source2) {
+    _chunkOWKUE3ACcjs.ArgumentUtility.checkNotOptional({ source: source2 });
+    this.source = source2;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TyneqBaseEnumerator = TyneqBaseEnumerator; exports.TyneqComparer = TyneqComparer; exports.tyneqQueryNode = tyneqQueryNode; exports.isSourceNode = isSourceNode; exports.QueryNode = QueryNode; exports.PluginError = PluginError; exports.OperatorMetadata = OperatorMetadata; exports.RegistryError = RegistryError; exports.OperatorRegistry = OperatorRegistry; exports.TyneqTerminalOperator = TyneqTerminalOperator; exports.InvalidOperationError = InvalidOperationError; exports.EnumeratorUtility = EnumeratorUtility; exports.SequenceContainsNoElementsError = SequenceContainsNoElementsError; exports.TyneqEnumerator = TyneqEnumerator; exports.TyneqOrderedEnumerable = TyneqOrderedEnumerable; exports.TyneqCachedEnumerable = TyneqCachedEnumerable; exports.TyneqEnumerable = TyneqEnumerable; exports.source = source; exports.operator = operator; exports.orderedOperator = orderedOperator; exports.cachedOperator = cachedOperator; exports.terminal = terminal; exports.orderedTerminal = orderedTerminal; exports.cachedTerminal = cachedTerminal; exports.createOperator = createOperator; exports.createGeneratorOperator = createGeneratorOperator; exports.createOrderedOperator = createOrderedOperator; exports.createCachedOperator = createCachedOperator; exports.createTerminalOperator = createTerminalOperator; exports.createOrderedTerminalOperator = createOrderedTerminalOperator; exports.createCachedTerminalOperator = createCachedTerminalOperator; exports.TyneqOrderedEnumerator = TyneqOrderedEnumerator; exports.TyneqCachedEnumerator = TyneqCachedEnumerator; exports.TyneqOrderedTerminalOperator = TyneqOrderedTerminalOperator; exports.TyneqCachedTerminalOperator = TyneqCachedTerminalOperator;