@tanstack/db-ivm 0.0.0 → 0.1.1

package/dist/esm/d2.d.ts

@@ -0,0 +1,45 @@
+import { DifferenceStreamWriter, BinaryOperator, DifferenceStreamReader, UnaryOperator } from './graph.js';
+import { MultiSet, MultiSetArray } from './multiset.js';
+import { ID2, IStreamBuilder, PipedOperator } from './types.js';
+export declare class D2 implements ID2 {
+    #private;
+    constructor();
+    getNextOperatorId(): number;
+    newInput<T>(): RootStreamBuilder<T>;
+    addOperator(operator: UnaryOperator<any> | BinaryOperator<any>): void;
+    addStream(stream: DifferenceStreamReader<any>): void;
+    finalize(): void;
+    step(): void;
+    pendingWork(): boolean;
+    run(): void;
+}
+export declare class StreamBuilder<T> implements IStreamBuilder<T> {
+    #private;
+    constructor(graph: ID2, writer: DifferenceStreamWriter<T>);
+    connectReader(): DifferenceStreamReader<T>;
+    get writer(): DifferenceStreamWriter<T>;
+    get graph(): ID2;
+    pipe<O>(o1: PipedOperator<T, O>): IStreamBuilder<O>;
+    pipe<T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>): IStreamBuilder<O>;
+    pipe<T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, T20>, o20: PipedOperator<T20, O>): IStreamBuilder<O>;
+}
+export declare class RootStreamBuilder<T> extends StreamBuilder<T> {
+    sendData(collection: MultiSet<T> | MultiSetArray<T>): void;
+}

package/dist/esm/d2.js

@@ -0,0 +1,111 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _streams, _operators, _nextOperatorId, _finalized, _D2_instances, checkNotFinalized_fn, _graph, _writer;
+import { DifferenceStreamWriter } from "./graph.js";
+class D2 {
+  constructor() {
+    __privateAdd(this, _D2_instances);
+    __privateAdd(this, _streams, []);
+    __privateAdd(this, _operators, []);
+    __privateAdd(this, _nextOperatorId, 0);
+    __privateAdd(this, _finalized, false);
+  }
+  getNextOperatorId() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    return __privateWrapper(this, _nextOperatorId)._++;
+  }
+  newInput() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    const writer = new DifferenceStreamWriter();
+    const streamBuilder = new RootStreamBuilder(this, writer);
+    __privateGet(this, _streams).push(streamBuilder.connectReader());
+    return streamBuilder;
+  }
+  addOperator(operator) {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateGet(this, _operators).push(operator);
+  }
+  addStream(stream) {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateGet(this, _streams).push(stream);
+  }
+  finalize() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateSet(this, _finalized, true);
+  }
+  step() {
+    if (!__privateGet(this, _finalized)) {
+      throw new Error(`Graph not finalized`);
+    }
+    for (const op of __privateGet(this, _operators)) {
+      op.run();
+    }
+  }
+  pendingWork() {
+    return __privateGet(this, _operators).some((op) => op.hasPendingWork());
+  }
+  run() {
+    while (this.pendingWork()) {
+      this.step();
+    }
+  }
+}
+_streams = new WeakMap();
+_operators = new WeakMap();
+_nextOperatorId = new WeakMap();
+_finalized = new WeakMap();
+_D2_instances = new WeakSet();
+checkNotFinalized_fn = function() {
+  if (__privateGet(this, _finalized)) {
+    throw new Error(`Graph already finalized`);
+  }
+};
+class StreamBuilder {
+  constructor(graph, writer) {
+    __privateAdd(this, _graph);
+    __privateAdd(this, _writer);
+    __privateSet(this, _graph, graph);
+    __privateSet(this, _writer, writer);
+  }
+  connectReader() {
+    return __privateGet(this, _writer).newReader();
+  }
+  get writer() {
+    return __privateGet(this, _writer);
+  }
+  get graph() {
+    return __privateGet(this, _graph);
+  }
+  pipe(...operators) {
+    return operators.reduce((stream, operator) => {
+      return operator(stream);
+    }, this);
+  }
+}
+_graph = new WeakMap();
+_writer = new WeakMap();
+class RootStreamBuilder extends StreamBuilder {
+  sendData(collection) {
+    this.writer.sendData(collection);
+  }
+}
+export {
+  D2,
+  RootStreamBuilder,
+  StreamBuilder
+};
+//# sourceMappingURL=d2.js.map

package/dist/esm/d2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"d2.js","sources":["../../src/d2.ts"],"sourcesContent":["import { DifferenceStreamWriter } from \"./graph.js\"\nimport type {\n  BinaryOperator,\n  DifferenceStreamReader,\n  UnaryOperator,\n} from \"./graph.js\"\nimport type { MultiSet, MultiSetArray } from \"./multiset.js\"\nimport type { ID2, IStreamBuilder, PipedOperator } from \"./types.js\"\n\nexport class D2 implements ID2 {\n  #streams: Array<DifferenceStreamReader<any>> = []\n  #operators: Array<UnaryOperator<any> | BinaryOperator<any>> = []\n  #nextOperatorId = 0\n  #finalized = false\n\n  constructor() {}\n\n  #checkNotFinalized(): void {\n    if (this.#finalized) {\n      throw new Error(`Graph already finalized`)\n    }\n  }\n\n  getNextOperatorId(): number {\n    this.#checkNotFinalized()\n    return this.#nextOperatorId++\n  }\n\n  newInput<T>(): RootStreamBuilder<T> {\n    this.#checkNotFinalized()\n    const writer = new DifferenceStreamWriter<T>()\n    // Use the root stream builder that exposes the sendData and sendFrontier methods\n    const streamBuilder = new RootStreamBuilder<T>(this, writer)\n    this.#streams.push(streamBuilder.connectReader())\n    return streamBuilder\n  }\n\n  addOperator(operator: UnaryOperator<any> | BinaryOperator<any>): void {\n    this.#checkNotFinalized()\n    this.#operators.push(operator)\n  }\n\n  addStream(stream: DifferenceStreamReader<any>): void {\n    this.#checkNotFinalized()\n    this.#streams.push(stream)\n  }\n\n  finalize() {\n    this.#checkNotFinalized()\n    this.#finalized = true\n  }\n\n  step(): void {\n    if (!this.#finalized) {\n      throw new Error(`Graph not finalized`)\n    }\n    for (const op of this.#operators) {\n      op.run()\n    }\n  }\n\n  pendingWork(): boolean {\n    return this.#operators.some((op) => op.hasPendingWork())\n  }\n\n  run(): void {\n    while (this.pendingWork()) {\n      this.step()\n    }\n  }\n}\n\nexport class StreamBuilder<T> implements IStreamBuilder<T> {\n  #graph: ID2\n  #writer: DifferenceStreamWriter<T>\n\n  constructor(graph: ID2, writer: DifferenceStreamWriter<T>) {\n    this.#graph = graph\n    this.#writer = writer\n  }\n\n  connectReader(): DifferenceStreamReader<T> {\n    return this.#writer.newReader()\n  }\n\n  get writer(): DifferenceStreamWriter<T> {\n    return this.#writer\n  }\n\n  get graph(): ID2 {\n    return this.#graph\n  }\n\n  // Don't judge, this is the only way to type this function.\n  // rxjs has very similar code to type its pipe function\n  // https://github.com/ReactiveX/rxjs/blob/master/packages/rxjs/src/internal/util/pipe.ts\n  // We go to 20 operators deep, because surly that's enough for anyone...\n  // A user can always split the pipe into multiple pipes to get around this.\n  pipe<O>(o1: PipedOperator<T, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, T20>, o20: PipedOperator<T20, O>): IStreamBuilder<O>\n\n  pipe(...operators: Array<PipedOperator<any, any>>): IStreamBuilder<any> {\n    return operators.reduce((stream, operator) => {\n      return operator(stream)\n    }, this as IStreamBuilder<any>)\n  }\n}\n\nexport class RootStreamBuilder<T> extends StreamBuilder<T> {\n  sendData(collection: MultiSet<T> | MultiSetArray<T>): void {\n    this.writer.sendData(collection)\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AASO,MAAM,GAAkB;AAAA,EAM7B,cAAc;AANT;AACL,iCAA+C,CAAA;AAC/C,mCAA8D,CAAA;AAC9D,wCAAkB;AAClB,mCAAa;AAAA,EAEE;AAAA,EAQf,oBAA4B;AAC1B,0BAAK,qCAAL;AACA,WAAO,uBAAK,iBAAL;AAAA,EACT;AAAA,EAEA,WAAoC;AAClC,0BAAK,qCAAL;AACA,UAAM,SAAS,IAAI,uBAAA;AAEnB,UAAM,gBAAgB,IAAI,kBAAqB,MAAM,MAAM;AAC3D,uBAAK,UAAS,KAAK,cAAc,cAAA,CAAe;AAChD,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,UAA0D;AACpE,0BAAK,qCAAL;AACA,uBAAK,YAAW,KAAK,QAAQ;AAAA,EAC/B;AAAA,EAEA,UAAU,QAA2C;AACnD,0BAAK,qCAAL;AACA,uBAAK,UAAS,KAAK,MAAM;AAAA,EAC3B;AAAA,EAEA,WAAW;AACT,0BAAK,qCAAL;AACA,uBAAK,YAAa;AAAA,EACpB;AAAA,EAEA,OAAa;AACX,QAAI,CAAC,mBAAK,aAAY;AACpB,YAAM,IAAI,MAAM,qBAAqB;AAAA,IACvC;AACA,eAAW,MAAM,mBAAK,aAAY;AAChC,SAAG,IAAA;AAAA,IACL;AAAA,EACF;AAAA,EAEA,cAAuB;AACrB,WAAO,mBAAK,YAAW,KAAK,CAAC,OAAO,GAAG,gBAAgB;AAAA,EACzD;AAAA,EAEA,MAAY;AACV,WAAO,KAAK,eAAe;AACzB,WAAK,KAAA;AAAA,IACP;AAAA,EACF;AACF;AA5DE;AACA;AACA;AACA;AAJK;AAQL,uBAAA,WAA2B;AACzB,MAAI,mBAAK,aAAY;AACnB,UAAM,IAAI,MAAM,yBAAyB;AAAA,EAC3C;AACF;AAmDK,MAAM,cAA8C;AAAA,EAIzD,YAAY,OAAY,QAAmC;AAH3D;AACA;AAGE,uBAAK,QAAS;AACd,uBAAK,SAAU;AAAA,EACjB;AAAA,EAEA,gBAA2C;AACzC,WAAO,mBAAK,SAAQ,UAAA;AAAA,EACtB;AAAA,EAEA,IAAI,SAAoC;AACtC,WAAO,mBAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAa;AACf,WAAO,mBAAK;AAAA,EACd;AAAA,EA+CA,QAAQ,WAAgE;AACtE,WAAO,UAAU,OAAO,CAAC,QAAQ,aAAa;AAC5C,aAAO,SAAS,MAAM;AAAA,IACxB,GAAG,IAA2B;AAAA,EAChC;AACF;AAtEE;AACA;AAuEK,MAAM,0BAA6B,cAAiB;AAAA,EACzD,SAAS,YAAkD;AACzD,SAAK,OAAO,SAAS,UAAU;AAAA,EACjC;AACF;"}

package/dist/esm/graph.d.ts

@@ -0,0 +1,57 @@
+import { MultiSet, MultiSetArray } from './multiset.js';
+import { IDifferenceStreamReader, IDifferenceStreamWriter, IOperator } from './types.js';
+/**
+ * A read handle to a dataflow edge that receives data from a writer.
+ */
+export declare class DifferenceStreamReader<T> implements IDifferenceStreamReader<T> {
+    #private;
+    constructor(queue: Array<MultiSet<T>>);
+    drain(): Array<MultiSet<T>>;
+    isEmpty(): boolean;
+}
+/**
+ * A write handle to a dataflow edge that is allowed to publish data.
+ */
+export declare class DifferenceStreamWriter<T> implements IDifferenceStreamWriter<T> {
+    #private;
+    sendData(collection: MultiSet<T> | MultiSetArray<T>): void;
+    newReader(): DifferenceStreamReader<T>;
+}
+/**
+ * A generic implementation of a dataflow operator (node) that has multiple incoming edges (read handles) and
+ * one outgoing edge (write handle).
+ */
+export declare abstract class Operator<T> implements IOperator<T> {
+    id: number;
+    protected inputs: Array<DifferenceStreamReader<T>>;
+    protected output: DifferenceStreamWriter<T>;
+    constructor(id: number, inputs: Array<DifferenceStreamReader<T>>, output: DifferenceStreamWriter<T>);
+    abstract run(): void;
+    hasPendingWork(): boolean;
+}
+/**
+ * A convenience implementation of a dataflow operator that has a handle to one
+ * incoming stream of data, and one handle to an outgoing stream of data.
+ */
+export declare abstract class UnaryOperator<Tin, Tout = Tin> extends Operator<Tin | Tout> {
+    id: number;
+    constructor(id: number, inputA: DifferenceStreamReader<Tin>, output: DifferenceStreamWriter<Tout>);
+    inputMessages(): Array<MultiSet<Tin>>;
+}
+/**
+ * A convenience implementation of a dataflow operator that has a handle to two
+ * incoming streams of data, and one handle to an outgoing stream of data.
+ */
+export declare abstract class BinaryOperator<T> extends Operator<T> {
+    id: number;
+    constructor(id: number, inputA: DifferenceStreamReader<T>, inputB: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>);
+    inputAMessages(): Array<MultiSet<T>>;
+    inputBMessages(): Array<MultiSet<T>>;
+}
+/**
+ * Base class for operators that process a single input stream
+ */
+export declare abstract class LinearUnaryOperator<T, U> extends UnaryOperator<T | U> {
+    abstract inner(collection: MultiSet<T | U>): MultiSet<U>;
+    run(): void;
+}

package/dist/esm/graph.js

@@ -0,0 +1,90 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _queue, _queues;
+import { MultiSet } from "./multiset.js";
+class DifferenceStreamReader {
+  constructor(queue) {
+    __privateAdd(this, _queue);
+    __privateSet(this, _queue, queue);
+  }
+  drain() {
+    const out = [...__privateGet(this, _queue)].reverse();
+    __privateGet(this, _queue).length = 0;
+    return out;
+  }
+  isEmpty() {
+    return __privateGet(this, _queue).length === 0;
+  }
+}
+_queue = new WeakMap();
+class DifferenceStreamWriter {
+  constructor() {
+    __privateAdd(this, _queues, []);
+  }
+  sendData(collection) {
+    if (!(collection instanceof MultiSet)) {
+      collection = new MultiSet(collection);
+    }
+    for (const q of __privateGet(this, _queues)) {
+      q.unshift(collection);
+    }
+  }
+  newReader() {
+    const q = [];
+    __privateGet(this, _queues).push(q);
+    return new DifferenceStreamReader(q);
+  }
+}
+_queues = new WeakMap();
+class Operator {
+  constructor(id, inputs, output) {
+    this.id = id;
+    this.inputs = inputs;
+    this.output = output;
+  }
+  hasPendingWork() {
+    return this.inputs.some((input) => !input.isEmpty());
+  }
+}
+class UnaryOperator extends Operator {
+  constructor(id, inputA, output) {
+    super(id, [inputA], output);
+    this.id = id;
+  }
+  inputMessages() {
+    return this.inputs[0].drain();
+  }
+}
+class BinaryOperator extends Operator {
+  constructor(id, inputA, inputB, output) {
+    super(id, [inputA, inputB], output);
+    this.id = id;
+  }
+  inputAMessages() {
+    return this.inputs[0].drain();
+  }
+  inputBMessages() {
+    return this.inputs[1].drain();
+  }
+}
+class LinearUnaryOperator extends UnaryOperator {
+  run() {
+    for (const message of this.inputMessages()) {
+      this.output.sendData(this.inner(message));
+    }
+  }
+}
+export {
+  BinaryOperator,
+  DifferenceStreamReader,
+  DifferenceStreamWriter,
+  LinearUnaryOperator,
+  Operator,
+  UnaryOperator
+};
+//# sourceMappingURL=graph.js.map

package/dist/esm/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sources":["../../src/graph.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport type { MultiSetArray } from \"./multiset.js\"\nimport type {\n  IDifferenceStreamReader,\n  IDifferenceStreamWriter,\n  IOperator,\n} from \"./types.js\"\n\n/**\n * A read handle to a dataflow edge that receives data from a writer.\n */\nexport class DifferenceStreamReader<T> implements IDifferenceStreamReader<T> {\n  #queue: Array<MultiSet<T>>\n\n  constructor(queue: Array<MultiSet<T>>) {\n    this.#queue = queue\n  }\n\n  drain(): Array<MultiSet<T>> {\n    const out = [...this.#queue].reverse()\n    this.#queue.length = 0\n    return out\n  }\n\n  isEmpty(): boolean {\n    return this.#queue.length === 0\n  }\n}\n\n/**\n * A write handle to a dataflow edge that is allowed to publish data.\n */\nexport class DifferenceStreamWriter<T> implements IDifferenceStreamWriter<T> {\n  #queues: Array<Array<MultiSet<T>>> = []\n\n  sendData(collection: MultiSet<T> | MultiSetArray<T>): void {\n    if (!(collection instanceof MultiSet)) {\n      collection = new MultiSet(collection)\n    }\n\n    for (const q of this.#queues) {\n      q.unshift(collection)\n    }\n  }\n\n  newReader(): DifferenceStreamReader<T> {\n    const q: Array<MultiSet<T>> = []\n    this.#queues.push(q)\n    return new DifferenceStreamReader(q)\n  }\n}\n\n/**\n * A generic implementation of a dataflow operator (node) that has multiple incoming edges (read handles) and\n * one outgoing edge (write handle).\n */\nexport abstract class Operator<T> implements IOperator<T> {\n  protected inputs: Array<DifferenceStreamReader<T>>\n  protected output: DifferenceStreamWriter<T>\n\n  constructor(\n    public id: number,\n    inputs: Array<DifferenceStreamReader<T>>,\n    output: DifferenceStreamWriter<T>\n  ) {\n    this.inputs = inputs\n    this.output = output\n  }\n\n  abstract run(): void\n\n  hasPendingWork(): boolean {\n    return this.inputs.some((input) => !input.isEmpty())\n  }\n}\n\n/**\n * A convenience implementation of a dataflow operator that has a handle to one\n * incoming stream of data, and one handle to an outgoing stream of data.\n */\nexport abstract class UnaryOperator<Tin, Tout = Tin> extends Operator<\n  Tin | Tout\n> {\n  constructor(\n    public id: number,\n    inputA: DifferenceStreamReader<Tin>,\n    output: DifferenceStreamWriter<Tout>\n  ) {\n    super(id, [inputA], output)\n  }\n\n  inputMessages(): Array<MultiSet<Tin>> {\n    return this.inputs[0]!.drain() as Array<MultiSet<Tin>>\n  }\n}\n\n/**\n * A convenience implementation of a dataflow operator that has a handle to two\n * incoming streams of data, and one handle to an outgoing stream of data.\n */\nexport abstract class BinaryOperator<T> extends Operator<T> {\n  constructor(\n    public id: number,\n    inputA: DifferenceStreamReader<T>,\n    inputB: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>\n  ) {\n    super(id, [inputA, inputB], output)\n  }\n\n  inputAMessages(): Array<MultiSet<T>> {\n    return this.inputs[0]!.drain()\n  }\n\n  inputBMessages(): Array<MultiSet<T>> {\n    return this.inputs[1]!.drain()\n  }\n}\n\n/**\n * Base class for operators that process a single input stream\n */\nexport abstract class LinearUnaryOperator<T, U> extends UnaryOperator<T | U> {\n  abstract inner(collection: MultiSet<T | U>): MultiSet<U>\n\n  run(): void {\n    for (const message of this.inputMessages()) {\n      this.output.sendData(this.inner(message))\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;AAWO,MAAM,uBAAgE;AAAA,EAG3E,YAAY,OAA2B;AAFvC;AAGE,uBAAK,QAAS;AAAA,EAChB;AAAA,EAEA,QAA4B;AAC1B,UAAM,MAAM,CAAC,GAAG,mBAAK,OAAM,EAAE,QAAA;AAC7B,uBAAK,QAAO,SAAS;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,UAAmB;AACjB,WAAO,mBAAK,QAAO,WAAW;AAAA,EAChC;AACF;AAfE;AAoBK,MAAM,uBAAgE;AAAA,EAAtE;AACL,gCAAqC,CAAA;AAAA;AAAA,EAErC,SAAS,YAAkD;AACzD,QAAI,EAAE,sBAAsB,WAAW;AACrC,mBAAa,IAAI,SAAS,UAAU;AAAA,IACtC;AAEA,eAAW,KAAK,mBAAK,UAAS;AAC5B,QAAE,QAAQ,UAAU;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,YAAuC;AACrC,UAAM,IAAwB,CAAA;AAC9B,uBAAK,SAAQ,KAAK,CAAC;AACnB,WAAO,IAAI,uBAAuB,CAAC;AAAA,EACrC;AACF;AAjBE;AAuBK,MAAe,SAAoC;AAAA,EAIxD,YACS,IACP,QACA,QACA;AAHO,SAAA,KAAA;AAIP,SAAK,SAAS;AACd,SAAK,SAAS;AAAA,EAChB;AAAA,EAIA,iBAA0B;AACxB,WAAO,KAAK,OAAO,KAAK,CAAC,UAAU,CAAC,MAAM,SAAS;AAAA,EACrD;AACF;AAMO,MAAe,sBAAuC,SAE3D;AAAA,EACA,YACS,IACP,QACA,QACA;AACA,UAAM,IAAI,CAAC,MAAM,GAAG,MAAM;AAJnB,SAAA,KAAA;AAAA,EAKT;AAAA,EAEA,gBAAsC;AACpC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AACF;AAMO,MAAe,uBAA0B,SAAY;AAAA,EAC1D,YACS,IACP,QACA,QACA,QACA;AACA,UAAM,IAAI,CAAC,QAAQ,MAAM,GAAG,MAAM;AAL3B,SAAA,KAAA;AAAA,EAMT;AAAA,EAEA,iBAAqC;AACnC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AAAA,EAEA,iBAAqC;AACnC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AACF;AAKO,MAAe,4BAAkC,cAAqB;AAAA,EAG3E,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,WAAK,OAAO,SAAS,KAAK,MAAM,OAAO,CAAC;AAAA,IAC1C;AAAA,EACF;AACF;"}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './multiset.js';
+export * from './operators/index.js';
+export * from './types.js';

package/dist/esm/index.js

@@ -0,0 +1,72 @@
+import { D2, RootStreamBuilder, StreamBuilder } from "./d2.js";
+import { MultiSet } from "./multiset.js";
+import { groupBy, groupByOperators } from "./operators/groupBy.js";
+import { pipe } from "./operators/pipe.js";
+import { MapOperator, map } from "./operators/map.js";
+import { FilterOperator, filter } from "./operators/filter.js";
+import { NegateOperator, negate } from "./operators/negate.js";
+import { ConcatOperator, concat } from "./operators/concat.js";
+import { DebugOperator, debug } from "./operators/debug.js";
+import { OutputOperator, output } from "./operators/output.js";
+import { ConsolidateOperator, consolidate } from "./operators/consolidate.js";
+import { JoinOperator, antiJoin, fullJoin, innerJoin, join, leftJoin, rightJoin } from "./operators/join.js";
+import { ReduceOperator, reduce } from "./operators/reduce.js";
+import { CountOperator, count } from "./operators/count.js";
+import { DistinctOperator, distinct } from "./operators/distinct.js";
+import { keyBy, rekey, unkey } from "./operators/keying.js";
+import { topK, topKWithIndex } from "./operators/topK.js";
+import { TopKWithFractionalIndexOperator, getIndex, getValue, indexedValue, topKWithFractionalIndex } from "./operators/topKWithFractionalIndex.js";
+import { orderBy, orderByWithFractionalIndex, orderByWithFractionalIndexBase, orderByWithIndex } from "./operators/orderBy.js";
+import { filterBy } from "./operators/filterBy.js";
+export {
+  ConcatOperator,
+  ConsolidateOperator,
+  CountOperator,
+  D2,
+  DebugOperator,
+  DistinctOperator,
+  FilterOperator,
+  JoinOperator,
+  MapOperator,
+  MultiSet,
+  NegateOperator,
+  OutputOperator,
+  ReduceOperator,
+  RootStreamBuilder,
+  StreamBuilder,
+  TopKWithFractionalIndexOperator,
+  antiJoin,
+  concat,
+  consolidate,
+  count,
+  debug,
+  distinct,
+  filter,
+  filterBy,
+  fullJoin,
+  getIndex,
+  getValue,
+  groupBy,
+  groupByOperators,
+  indexedValue,
+  innerJoin,
+  join,
+  keyBy,
+  leftJoin,
+  map,
+  negate,
+  orderBy,
+  orderByWithFractionalIndex,
+  orderByWithFractionalIndexBase,
+  orderByWithIndex,
+  output,
+  pipe,
+  reduce,
+  rekey,
+  rightJoin,
+  topK,
+  topKWithFractionalIndex,
+  topKWithIndex,
+  unkey
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/indexes.d.ts

@@ -0,0 +1,20 @@
+import { MultiSet } from './multiset.js';
+/**
+ * A map from a difference collection trace's keys -> (value, multiplicities) that changed.
+ * Used in operations like join and reduce where the operation needs to
+ * exploit the key-value structure of the data to run efficiently.
+ */
+export declare class Index<K, V> {
+    #private;
+    constructor();
+    toString(indent?: boolean): string;
+    get(key: K): Array<[V, number]>;
+    getMultiplicity(key: K, value: V): number;
+    entries(): MapIterator<[K, Map<V, number>]>;
+    keys(): MapIterator<K>;
+    has(key: K): boolean;
+    get size(): number;
+    addValue(key: K, value: [V, number]): void;
+    append(other: Index<K, V>): void;
+    join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]>;
+}

package/dist/esm/indexes.js

@@ -0,0 +1,104 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _inner;
+import { MultiSet } from "./multiset.js";
+import { DefaultMap } from "./utils.js";
+class Index {
+  constructor() {
+    __privateAdd(this, _inner);
+    __privateSet(this, _inner, new DefaultMap(() => /* @__PURE__ */ new Map()));
+  }
+  toString(indent = false) {
+    return `Index(${JSON.stringify(
+      [...__privateGet(this, _inner)].map(([k, valueMap]) => [k, [...valueMap]]),
+      void 0,
+      indent ? `  ` : void 0
+    )})`;
+  }
+  get(key) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    return [...valueMap.entries()];
+  }
+  getMultiplicity(key, value) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    return valueMap.get(value) ?? 0;
+  }
+  entries() {
+    return __privateGet(this, _inner).entries();
+  }
+  keys() {
+    return __privateGet(this, _inner).keys();
+  }
+  has(key) {
+    return __privateGet(this, _inner).has(key);
+  }
+  get size() {
+    return __privateGet(this, _inner).size;
+  }
+  addValue(key, value) {
+    const [val, multiplicity] = value;
+    const valueMap = __privateGet(this, _inner).get(key);
+    const existingMultiplicity = valueMap.get(val) ?? 0;
+    const newMultiplicity = existingMultiplicity + multiplicity;
+    if (multiplicity !== 0) {
+      if (newMultiplicity === 0) {
+        valueMap.delete(val);
+      } else {
+        valueMap.set(val, newMultiplicity);
+      }
+    }
+  }
+  append(other) {
+    for (const [key, otherValueMap] of other.entries()) {
+      const thisValueMap = __privateGet(this, _inner).get(key);
+      for (const [value, multiplicity] of otherValueMap.entries()) {
+        const existingMultiplicity = thisValueMap.get(value) ?? 0;
+        const newMultiplicity = existingMultiplicity + multiplicity;
+        if (newMultiplicity === 0) {
+          thisValueMap.delete(value);
+        } else {
+          thisValueMap.set(value, newMultiplicity);
+        }
+      }
+    }
+  }
+  join(other) {
+    const result = [];
+    if (this.size <= other.size) {
+      for (const [key, valueMap] of this.entries()) {
+        if (!other.has(key)) continue;
+        const otherValues = other.get(key);
+        for (const [val1, mul1] of valueMap.entries()) {
+          for (const [val2, mul2] of otherValues) {
+            if (mul1 !== 0 && mul2 !== 0) {
+              result.push([[key, [val1, val2]], mul1 * mul2]);
+            }
+          }
+        }
+      }
+    } else {
+      for (const [key, otherValueMap] of other.entries()) {
+        if (!this.has(key)) continue;
+        const values = this.get(key);
+        for (const [val2, mul2] of otherValueMap.entries()) {
+          for (const [val1, mul1] of values) {
+            if (mul1 !== 0 && mul2 !== 0) {
+              result.push([[key, [val1, val2]], mul1 * mul2]);
+            }
+          }
+        }
+      }
+    }
+    return new MultiSet(result);
+  }
+}
+_inner = new WeakMap();
+export {
+  Index
+};
+//# sourceMappingURL=indexes.js.map

package/dist/esm/indexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.js","sources":["../../src/indexes.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport { DefaultMap } from \"./utils.js\"\n\n/**\n * A map from a difference collection trace's keys -> (value, multiplicities) that changed.\n * Used in operations like join and reduce where the operation needs to\n * exploit the key-value structure of the data to run efficiently.\n */\nexport class Index<K, V> {\n  #inner: DefaultMap<K, Map<V, number>>\n\n  constructor() {\n    this.#inner = new DefaultMap<K, Map<V, number>>(() => new Map<V, number>())\n    // #inner is a map of:\n    // {\n    //   [key]: Map<V, number>  // Direct value-to-multiplicity mapping\n    // }\n  }\n\n  toString(indent = false): string {\n    return `Index(${JSON.stringify(\n      [...this.#inner].map(([k, valueMap]) => [k, [...valueMap]]),\n      undefined,\n      indent ? `  ` : undefined\n    )})`\n  }\n\n  get(key: K): Array<[V, number]> {\n    const valueMap = this.#inner.get(key)\n    return [...valueMap.entries()]\n  }\n\n  getMultiplicity(key: K, value: V): number {\n    const valueMap = this.#inner.get(key)\n    return valueMap.get(value) ?? 0\n  }\n\n  entries() {\n    return this.#inner.entries()\n  }\n\n  keys() {\n    return this.#inner.keys()\n  }\n\n  has(key: K): boolean {\n    return this.#inner.has(key)\n  }\n\n  get size(): number {\n    return this.#inner.size\n  }\n\n  addValue(key: K, value: [V, number]): void {\n    const [val, multiplicity] = value\n    const valueMap = this.#inner.get(key)\n    const existingMultiplicity = valueMap.get(val) ?? 0\n    const newMultiplicity = existingMultiplicity + multiplicity\n\n    if (multiplicity !== 0) {\n      if (newMultiplicity === 0) {\n        valueMap.delete(val)\n      } else {\n        valueMap.set(val, newMultiplicity)\n      }\n    }\n  }\n\n  append(other: Index<K, V>): void {\n    for (const [key, otherValueMap] of other.entries()) {\n      const thisValueMap = this.#inner.get(key)\n      for (const [value, multiplicity] of otherValueMap.entries()) {\n        const existingMultiplicity = thisValueMap.get(value) ?? 0\n        const newMultiplicity = existingMultiplicity + multiplicity\n        if (newMultiplicity === 0) {\n          thisValueMap.delete(value)\n        } else {\n          thisValueMap.set(value, newMultiplicity)\n        }\n      }\n    }\n  }\n\n  join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]> {\n    const result: Array<[[K, [V, V2]], number]> = []\n\n    // We want to iterate over the smaller of the two indexes to reduce the\n    // number of operations we need to do.\n    if (this.size <= other.size) {\n      for (const [key, valueMap] of this.entries()) {\n        if (!other.has(key)) continue\n        const otherValues = other.get(key)\n        for (const [val1, mul1] of valueMap.entries()) {\n          for (const [val2, mul2] of otherValues) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    } else {\n      for (const [key, otherValueMap] of other.entries()) {\n        if (!this.has(key)) continue\n        const values = this.get(key)\n        for (const [val2, mul2] of otherValueMap.entries()) {\n          for (const [val1, mul1] of values) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    }\n\n    return new MultiSet(result)\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/multiset.d.ts

@@ -0,0 +1,36 @@
+export type MultiSetArray<T> = Array<[T, number]>;
+export type KeyedData<T> = [key: string, value: T];
+/**
+ * A multiset of data.
+ */
+export declare class MultiSet<T> {
+    #private;
+    constructor(data?: MultiSetArray<T>);
+    toString(indent?: boolean): string;
+    toJSON(): string;
+    static fromJSON<U>(json: string): MultiSet<U>;
+    /**
+     * Apply a function to all records in the collection.
+     */
+    map<U>(f: (data: T) => U): MultiSet<U>;
+    /**
+     * Filter out records for which a function f(record) evaluates to False.
+     */
+    filter(f: (data: T) => boolean): MultiSet<T>;
+    /**
+     * Negate all multiplicities in the collection.
+     */
+    negate(): MultiSet<T>;
+    /**
+     * Concatenate two collections together.
+     */
+    concat(other: MultiSet<T>): MultiSet<T>;
+    /**
+     * Produce as output a collection that is logically equivalent to the input
+     * but which combines identical instances of the same record into one
+     * (record, multiplicity) pair.
+     */
+    consolidate(): MultiSet<T>;
+    extend(other: MultiSet<T> | MultiSetArray<T>): void;
+    getInner(): MultiSetArray<T>;
+}