@tanstack/db-ivm 0.1.9 → 0.1.11

package/dist/esm/operators/output.js.map

@@ -1 +1 @@
-{"version":3,"file":"output.js","sources":["../../../src/operators/output.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { MultiSet } from \"../multiset.js\"\n\n/**\n * Operator that outputs the messages in the stream\n */\nexport class OutputOperator<T> extends UnaryOperator<T> {\n  #fn: (data: MultiSet<T>) => void\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    outputWriter: DifferenceStreamWriter<T>,\n    fn: (data: MultiSet<T>) => void\n  ) {\n    super(id, inputA, outputWriter)\n    this.#fn = fn\n  }\n\n  run(): void {\n    for (const message of this.inputMessages()) {\n      this.#fn(message)\n      this.output.sendData(message)\n    }\n  }\n}\n\n/**\n * Outputs the messages in the stream\n * @param fn - The function to call with each message\n */\nexport function output<T>(\n  fn: (data: MultiSet<T>) => void\n): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const outputStream = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>()\n    )\n    const operator = new OutputOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      outputStream.writer,\n      fn\n    )\n    stream.graph.addOperator(operator)\n    return outputStream\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;AASO,MAAM,uBAA0B,cAAiB;AAAA,EAGtD,YACE,IACA,QACA,cACA,IACA;AACA,UAAM,IAAI,QAAQ,YAAY;AARhC;AASE,uBAAK,KAAM;AAAA,EACb;AAAA,EAEA,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,yBAAK,KAAL,WAAS;AACT,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAlBE;AAwBK,SAAS,OACd,IACqB;AACrB,SAAO,CAAC,WAAiD;AACvD,UAAM,eAAe,IAAI;AAAA,MACvB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,aAAa;AAAA,MACb;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}
+{"version":3,"file":"output.js","sources":["../../../src/operators/output.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { MultiSet } from \"../multiset.js\"\n\n/**\n * Operator that outputs the messages in the stream\n */\nexport class OutputOperator<T> extends UnaryOperator<T> {\n  #fn: (data: MultiSet<T>) => void\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    outputWriter: DifferenceStreamWriter<T>,\n    fn: (data: MultiSet<T>) => void\n  ) {\n    super(id, inputA, outputWriter)\n    this.#fn = fn\n  }\n\n  run(): void {\n    for (const message of this.inputMessages()) {\n      this.#fn(message)\n      this.output.sendData(message)\n    }\n  }\n}\n\n/**\n * Outputs the messages in the stream\n * @param fn - The function to call with each message\n */\nexport function output<T>(\n  fn: (data: MultiSet<T>) => void\n): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const outputStream = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>()\n    )\n    const operator = new OutputOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      outputStream.writer,\n      fn\n    )\n    stream.graph.addOperator(operator)\n    return outputStream\n  }\n}\n"],"names":[],"mappings":";;AASO,MAAM,uBAA0B,cAAiB;AAAA,EACtD;AAAA,EAEA,YACE,IACA,QACA,cACA,IACA;AACA,UAAM,IAAI,QAAQ,YAAY;AAC9B,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,WAAK,IAAI,OAAO;AAChB,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAMO,SAAS,OACd,IACqB;AACrB,SAAO,CAAC,WAAiD;AACvD,UAAM,eAAe,IAAI;AAAA,MACvB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,aAAa;AAAA,MACb;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}

package/dist/esm/operators/reduce.js

@@ -1,37 +1,29 @@
-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 _index, _indexOut, _f;
 import { UnaryOperator, DifferenceStreamWriter } from "../graph.js";
 import { StreamBuilder } from "../d2.js";
 import { MultiSet } from "../multiset.js";
 import { Index } from "../indexes.js";
 class ReduceOperator extends UnaryOperator {
+  #index = new Index();
+  #indexOut = new Index();
+  #f;
   constructor(id, inputA, output, f) {
     super(id, inputA, output);
-    __privateAdd(this, _index, new Index());
-    __privateAdd(this, _indexOut, new Index());
-    __privateAdd(this, _f);
-    __privateSet(this, _f, f);
+    this.#f = f;
   }
   run() {
     const keysTodo = /* @__PURE__ */ new Set();
     for (const message of this.inputMessages()) {
       for (const [item, multiplicity] of message.getInner()) {
         const [key, value] = item;
-        __privateGet(this, _index).addValue(key, [value, multiplicity]);
+        this.#index.addValue(key, [value, multiplicity]);
         keysTodo.add(key);
       }
     }
     const result = [];
     for (const key of keysTodo) {
-      const curr = __privateGet(this, _index).get(key);
-      const currOut = __privateGet(this, _indexOut).get(key);
-      const out = __privateGet(this, _f).call(this, curr);
+      const curr = this.#index.get(key);
+      const currOut = this.#indexOut.get(key);
+      const out = this.#f(curr);
       const newOutputMap = /* @__PURE__ */ new Map();
       const oldOutputMap = /* @__PURE__ */ new Map();
       for (const [value, multiplicity] of out) {
@@ -45,14 +37,14 @@ class ReduceOperator extends UnaryOperator {
       for (const [value, multiplicity] of oldOutputMap) {
         if (!newOutputMap.has(value)) {
           result.push([[key, value], -multiplicity]);
-          __privateGet(this, _indexOut).addValue(key, [value, -multiplicity]);
+          this.#indexOut.addValue(key, [value, -multiplicity]);
         }
       }
       for (const [value, multiplicity] of newOutputMap) {
         if (!oldOutputMap.has(value)) {
           if (multiplicity !== 0) {
             result.push([[key, value], multiplicity]);
-            __privateGet(this, _indexOut).addValue(key, [value, multiplicity]);
+            this.#indexOut.addValue(key, [value, multiplicity]);
           }
         }
       }
@@ -62,7 +54,7 @@ class ReduceOperator extends UnaryOperator {
           const delta = newMultiplicity - oldMultiplicity;
           if (delta !== 0) {
             result.push([[key, value], delta]);
-            __privateGet(this, _indexOut).addValue(key, [value, delta]);
+            this.#indexOut.addValue(key, [value, delta]);
           }
         }
       }
@@ -72,9 +64,6 @@ class ReduceOperator extends UnaryOperator {
     }
   }
 }
-_index = new WeakMap();
-_indexOut = new WeakMap();
-_f = new WeakMap();
 function reduce(f) {
   return (stream) => {
     const output = new StreamBuilder(

package/dist/esm/operators/reduce.js.map

@@ -1 +1 @@
-{"version":3,"file":"reduce.js","sources":["../../../src/operators/reduce.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport { Index } from \"../indexes.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { IStreamBuilder, KeyValue } from \"../types.js\"\n\n/**\n * Base operator for reduction operations (version-free)\n */\nexport class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {\n  #index = new Index<K, V1>()\n  #indexOut = new Index<K, V2>()\n  #f: (values: Array<[V1, number]>) => Array<[V2, number]>\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    output: DifferenceStreamWriter<[K, V2]>,\n    f: (values: Array<[V1, number]>) => Array<[V2, number]>\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  run(): void {\n    // Collect all input messages and update the index\n    const keysTodo = new Set<K>()\n    for (const message of this.inputMessages()) {\n      for (const [item, multiplicity] of message.getInner()) {\n        const [key, value] = item\n        this.#index.addValue(key, [value, multiplicity])\n        keysTodo.add(key)\n      }\n    }\n\n    // For each key, compute the reduction and delta\n    const result: Array<[[K, V2], number]> = []\n    for (const key of keysTodo) {\n      const curr = this.#index.get(key)\n      const currOut = this.#indexOut.get(key)\n      const out = this.#f(curr)\n\n      // Create maps for current and previous outputs using values directly as keys\n      const newOutputMap = new Map<V2, number>()\n      const oldOutputMap = new Map<V2, number>()\n\n      // Process new output\n      for (const [value, multiplicity] of out) {\n        const existing = newOutputMap.get(value) ?? 0\n        newOutputMap.set(value, existing + multiplicity)\n      }\n\n      // Process previous output\n      for (const [value, multiplicity] of currOut) {\n        const existing = oldOutputMap.get(value) ?? 0\n        oldOutputMap.set(value, existing + multiplicity)\n      }\n\n      // First, emit removals for old values that are no longer present\n      for (const [value, multiplicity] of oldOutputMap) {\n        if (!newOutputMap.has(value)) {\n          // Remove the old value entirely\n          result.push([[key, value], -multiplicity])\n          this.#indexOut.addValue(key, [value, -multiplicity])\n        }\n      }\n\n      // Then, emit additions for new values that are not present in old\n      for (const [value, multiplicity] of newOutputMap) {\n        if (!oldOutputMap.has(value)) {\n          // Add the new value only if it has non-zero multiplicity\n          if (multiplicity !== 0) {\n            result.push([[key, value], multiplicity])\n            this.#indexOut.addValue(key, [value, multiplicity])\n          }\n        }\n      }\n\n      // Finally, emit multiplicity changes for values that were present and are still present\n      for (const [value, newMultiplicity] of newOutputMap) {\n        const oldMultiplicity = oldOutputMap.get(value)\n        if (oldMultiplicity !== undefined) {\n          const delta = newMultiplicity - oldMultiplicity\n          // Only emit actual changes, i.e. non-zero deltas\n          if (delta !== 0) {\n            result.push([[key, value], delta])\n            this.#indexOut.addValue(key, [value, delta])\n          }\n        }\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n}\n\n/**\n * Reduces the elements in the stream by key (version-free)\n */\nexport function reduce<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  R,\n  T,\n>(f: (values: Array<[V1Type, number]>) => Array<[R, number]>) {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {\n    const output = new StreamBuilder<KeyValue<KType, R>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<KType, R>>()\n    )\n    const operator = new ReduceOperator<KType, V1Type, R>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,\n      output.writer,\n      f\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;AAUO,MAAM,uBAAkC,cAAgC;AAAA,EAK7E,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AAV1B,+BAAS,IAAI,MAAA;AACb,kCAAY,IAAI,MAAA;AAChB;AASE,uBAAK,IAAK;AAAA,EACZ;AAAA,EAEA,MAAY;AAEV,UAAM,+BAAe,IAAA;AACrB,eAAW,WAAW,KAAK,iBAAiB;AAC1C,iBAAW,CAAC,MAAM,YAAY,KAAK,QAAQ,YAAY;AACrD,cAAM,CAAC,KAAK,KAAK,IAAI;AACrB,2BAAK,QAAO,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAC/C,iBAAS,IAAI,GAAG;AAAA,MAClB;AAAA,IACF;AAGA,UAAM,SAAmC,CAAA;AACzC,eAAW,OAAO,UAAU;AAC1B,YAAM,OAAO,mBAAK,QAAO,IAAI,GAAG;AAChC,YAAM,UAAU,mBAAK,WAAU,IAAI,GAAG;AACtC,YAAM,MAAM,mBAAK,IAAL,WAAQ;AAGpB,YAAM,mCAAmB,IAAA;AACzB,YAAM,mCAAmB,IAAA;AAGzB,iBAAW,CAAC,OAAO,YAAY,KAAK,KAAK;AACvC,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,SAAS;AAC3C,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,iBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,CAAC,YAAY,CAAC;AACzC,6BAAK,WAAU,SAAS,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;AAAA,QACrD;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,cAAI,iBAAiB,GAAG;AACtB,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,YAAY,CAAC;AACxC,+BAAK,WAAU,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,eAAe,KAAK,cAAc;AACnD,cAAM,kBAAkB,aAAa,IAAI,KAAK;AAC9C,YAAI,oBAAoB,QAAW;AACjC,gBAAM,QAAQ,kBAAkB;AAEhC,cAAI,UAAU,GAAG;AACf,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,KAAK,CAAC;AACjC,+BAAK,WAAU,SAAS,KAAK,CAAC,OAAO,KAAK,CAAC;AAAA,UAC7C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,WAAK,OAAO,SAAS,IAAI,SAAS,MAAM,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;AAtFE;AACA;AACA;AAyFK,SAAS,OAKd,GAA4D;AAC5D,SAAO,CAAC,WAAkE;AACxE,UAAM,SAAS,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA2C;AAEjD,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}
+{"version":3,"file":"reduce.js","sources":["../../../src/operators/reduce.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport { Index } from \"../indexes.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { IStreamBuilder, KeyValue } from \"../types.js\"\n\n/**\n * Base operator for reduction operations (version-free)\n */\nexport class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {\n  #index = new Index<K, V1>()\n  #indexOut = new Index<K, V2>()\n  #f: (values: Array<[V1, number]>) => Array<[V2, number]>\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    output: DifferenceStreamWriter<[K, V2]>,\n    f: (values: Array<[V1, number]>) => Array<[V2, number]>\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  run(): void {\n    // Collect all input messages and update the index\n    const keysTodo = new Set<K>()\n    for (const message of this.inputMessages()) {\n      for (const [item, multiplicity] of message.getInner()) {\n        const [key, value] = item\n        this.#index.addValue(key, [value, multiplicity])\n        keysTodo.add(key)\n      }\n    }\n\n    // For each key, compute the reduction and delta\n    const result: Array<[[K, V2], number]> = []\n    for (const key of keysTodo) {\n      const curr = this.#index.get(key)\n      const currOut = this.#indexOut.get(key)\n      const out = this.#f(curr)\n\n      // Create maps for current and previous outputs using values directly as keys\n      const newOutputMap = new Map<V2, number>()\n      const oldOutputMap = new Map<V2, number>()\n\n      // Process new output\n      for (const [value, multiplicity] of out) {\n        const existing = newOutputMap.get(value) ?? 0\n        newOutputMap.set(value, existing + multiplicity)\n      }\n\n      // Process previous output\n      for (const [value, multiplicity] of currOut) {\n        const existing = oldOutputMap.get(value) ?? 0\n        oldOutputMap.set(value, existing + multiplicity)\n      }\n\n      // First, emit removals for old values that are no longer present\n      for (const [value, multiplicity] of oldOutputMap) {\n        if (!newOutputMap.has(value)) {\n          // Remove the old value entirely\n          result.push([[key, value], -multiplicity])\n          this.#indexOut.addValue(key, [value, -multiplicity])\n        }\n      }\n\n      // Then, emit additions for new values that are not present in old\n      for (const [value, multiplicity] of newOutputMap) {\n        if (!oldOutputMap.has(value)) {\n          // Add the new value only if it has non-zero multiplicity\n          if (multiplicity !== 0) {\n            result.push([[key, value], multiplicity])\n            this.#indexOut.addValue(key, [value, multiplicity])\n          }\n        }\n      }\n\n      // Finally, emit multiplicity changes for values that were present and are still present\n      for (const [value, newMultiplicity] of newOutputMap) {\n        const oldMultiplicity = oldOutputMap.get(value)\n        if (oldMultiplicity !== undefined) {\n          const delta = newMultiplicity - oldMultiplicity\n          // Only emit actual changes, i.e. non-zero deltas\n          if (delta !== 0) {\n            result.push([[key, value], delta])\n            this.#indexOut.addValue(key, [value, delta])\n          }\n        }\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n}\n\n/**\n * Reduces the elements in the stream by key (version-free)\n */\nexport function reduce<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  R,\n  T,\n>(f: (values: Array<[V1Type, number]>) => Array<[R, number]>) {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {\n    const output = new StreamBuilder<KeyValue<KType, R>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<KType, R>>()\n    )\n    const operator = new ReduceOperator<KType, V1Type, R>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,\n      output.writer,\n      f\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":[],"mappings":";;;;AAUO,MAAM,uBAAkC,cAAgC;AAAA,EAC7E,SAAS,IAAI,MAAA;AAAA,EACb,YAAY,IAAI,MAAA;AAAA,EAChB;AAAA,EAEA,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AACxB,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,MAAY;AAEV,UAAM,+BAAe,IAAA;AACrB,eAAW,WAAW,KAAK,iBAAiB;AAC1C,iBAAW,CAAC,MAAM,YAAY,KAAK,QAAQ,YAAY;AACrD,cAAM,CAAC,KAAK,KAAK,IAAI;AACrB,aAAK,OAAO,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAC/C,iBAAS,IAAI,GAAG;AAAA,MAClB;AAAA,IACF;AAGA,UAAM,SAAmC,CAAA;AACzC,eAAW,OAAO,UAAU;AAC1B,YAAM,OAAO,KAAK,OAAO,IAAI,GAAG;AAChC,YAAM,UAAU,KAAK,UAAU,IAAI,GAAG;AACtC,YAAM,MAAM,KAAK,GAAG,IAAI;AAGxB,YAAM,mCAAmB,IAAA;AACzB,YAAM,mCAAmB,IAAA;AAGzB,iBAAW,CAAC,OAAO,YAAY,KAAK,KAAK;AACvC,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,SAAS;AAC3C,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,iBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,CAAC,YAAY,CAAC;AACzC,eAAK,UAAU,SAAS,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;AAAA,QACrD;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,cAAI,iBAAiB,GAAG;AACtB,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,YAAY,CAAC;AACxC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,eAAe,KAAK,cAAc;AACnD,cAAM,kBAAkB,aAAa,IAAI,KAAK;AAC9C,YAAI,oBAAoB,QAAW;AACjC,gBAAM,QAAQ,kBAAkB;AAEhC,cAAI,UAAU,GAAG;AACf,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,KAAK,CAAC;AACjC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,KAAK,CAAC;AAAA,UAC7C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,WAAK,OAAO,SAAS,IAAI,SAAS,MAAM,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;AAKO,SAAS,OAKd,GAA4D;AAC5D,SAAO,CAAC,WAAkE;AACxE,UAAM,SAAS,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA2C;AAEjD,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}

package/dist/esm/operators/tap.js

@@ -1,25 +1,16 @@
-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 _f;
 import { LinearUnaryOperator, DifferenceStreamWriter } from "../graph.js";
 import { StreamBuilder } from "../d2.js";
 class TapOperator extends LinearUnaryOperator {
+  #f;
   constructor(id, inputA, output, f) {
     super(id, inputA, output);
-    __privateAdd(this, _f);
-    __privateSet(this, _f, f);
+    this.#f = f;
   }
   inner(collection) {
-    __privateGet(this, _f).call(this, collection);
+    this.#f(collection);
     return collection;
   }
 }
-_f = new WeakMap();
 function tap(f) {
   return (stream) => {
     const output = new StreamBuilder(

package/dist/esm/operators/tap.js.map

@@ -1 +1 @@
-{"version":3,"file":"tap.js","sources":["../../../src/operators/tap.ts"],"sourcesContent":["import { DifferenceStreamWriter, LinearUnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { MultiSet } from \"../multiset.js\"\n\n/**\n * Operator that applies a function to each multi-set in the input stream\n */\nexport class TapOperator<T> extends LinearUnaryOperator<T, T> {\n  #f: (data: MultiSet<T>) => void\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>,\n    f: (data: MultiSet<T>) => void\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  inner(collection: MultiSet<T>): MultiSet<T> {\n    this.#f(collection)\n    return collection\n  }\n}\n\n/**\n * Invokes a function for each multi-set in the input stream.\n * This operator doesn't modify the stream and is used to perform side effects.\n * @param f - The function to invoke on each multi-set\n * @returns The input stream\n */\nexport function tap<T>(f: (data: MultiSet<T>) => void): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const output = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>()\n    )\n    const operator = new TapOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      f\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;AASO,MAAM,oBAAuB,oBAA0B;AAAA,EAG5D,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AAR1B;AASE,uBAAK,IAAK;AAAA,EACZ;AAAA,EAEA,MAAM,YAAsC;AAC1C,uBAAK,IAAL,WAAQ;AACR,WAAO;AAAA,EACT;AACF;AAhBE;AAwBK,SAAS,IAAO,GAAqD;AAC1E,SAAO,CAAC,WAAiD;AACvD,UAAM,SAAS,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}
+{"version":3,"file":"tap.js","sources":["../../../src/operators/tap.ts"],"sourcesContent":["import { DifferenceStreamWriter, LinearUnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { MultiSet } from \"../multiset.js\"\n\n/**\n * Operator that applies a function to each multi-set in the input stream\n */\nexport class TapOperator<T> extends LinearUnaryOperator<T, T> {\n  #f: (data: MultiSet<T>) => void\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>,\n    f: (data: MultiSet<T>) => void\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  inner(collection: MultiSet<T>): MultiSet<T> {\n    this.#f(collection)\n    return collection\n  }\n}\n\n/**\n * Invokes a function for each multi-set in the input stream.\n * This operator doesn't modify the stream and is used to perform side effects.\n * @param f - The function to invoke on each multi-set\n * @returns The input stream\n */\nexport function tap<T>(f: (data: MultiSet<T>) => void): PipedOperator<T, T> {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const output = new StreamBuilder<T>(\n      stream.graph,\n      new DifferenceStreamWriter<T>()\n    )\n    const operator = new TapOperator<T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      f\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":[],"mappings":";;AASO,MAAM,oBAAuB,oBAA0B;AAAA,EAC5D;AAAA,EAEA,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AACxB,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,MAAM,YAAsC;AAC1C,SAAK,GAAG,UAAU;AAClB,WAAO;AAAA,EACT;AACF;AAQO,SAAS,IAAO,GAAqD;AAC1E,SAAO,CAAC,WAAiD;AACvD,UAAM,SAAS,IAAI;AAAA,MACjB,OAAO;AAAA,MACP,IAAI,uBAAA;AAAA,IAA0B;AAEhC,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;"}

package/dist/esm/operators/topK.d.ts

@@ -1,5 +1,4 @@
-import { PipedOperator } from '../types.js';
-import { KeyValue } from '../types.js';
+import { KeyValue, PipedOperator } from '../types.js';
 interface TopKOptions {
     limit?: number;
     offset?: number;

package/dist/esm/operators/topK.js

@@ -1,8 +1,8 @@
 import { MultiSet } from "../multiset.js";
 import { reduce } from "./reduce.js";
 function topK(comparator, options) {
-  const limit = (options == null ? void 0 : options.limit) ?? Infinity;
-  const offset = (options == null ? void 0 : options.offset) ?? 0;
+  const limit = options?.limit ?? Infinity;
+  const offset = options?.offset ?? 0;
   return (stream) => {
     const reduced = stream.pipe(
       reduce((values) => {
@@ -15,8 +15,8 @@ function topK(comparator, options) {
   };
 }
 function topKWithIndex(comparator, options) {
-  const limit = (options == null ? void 0 : options.limit) ?? Infinity;
-  const offset = (options == null ? void 0 : options.offset) ?? 0;
+  const limit = options?.limit ?? Infinity;
+  const offset = options?.offset ?? 0;
   return (stream) => {
     const reduced = stream.pipe(
       reduce((values) => {

package/dist/esm/operators/topK.js.map

@@ -1 +1 @@
-{"version":3,"file":"topK.js","sources":["../../../src/operators/topK.ts"],"sourcesContent":["import { MultiSet } from \"../multiset.js\"\nimport { reduce } from \"./reduce.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types\"\nimport type { KeyValue } from \"../types.js\"\n\ninterface TopKOptions {\n  limit?: number\n  offset?: number\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that limits the number of results\n */\nexport function topK<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions\n): PipedOperator<T, T> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const reduced = stream.pipe(\n      reduce((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0] as V1Type, b[0] as V1Type))\n        return sortedValues.slice(offset, offset + limit)\n      })\n    )\n    return reduced as IStreamBuilder<T>\n  }\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n * Adds the index of the element to the result as [key, [value, index]]\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function topKWithIndex<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions\n): PipedOperator<T, KeyValue<KType, [V1Type, number]>> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<KType, [V1Type, number]>> => {\n    const reduced = stream.pipe(\n      reduce<KType, V1Type, [V1Type, number], T>((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        let i = offset\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0], b[0]))\n          .slice(offset, offset + limit)\n          .map(([value, multiplicity]): [[V1Type, number], number] => [\n            [value, i++],\n            multiplicity,\n          ])\n        return sortedValues\n      })\n    )\n    return reduced\n  }\n}\n"],"names":[],"mappings":";;AAqBO,SAAS,KAKd,YACA,SACqB;AACrB,QAAM,SAAQ,mCAAS,UAAS;AAChC,QAAM,UAAS,mCAAS,WAAU;AAElC,SAAO,CAAC,WAAiD;AACvD,UAAM,UAAU,OAAO;AAAA,MACrB,OAAO,CAAC,WAAW;AAEjB,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAa,EAAE,CAAC,CAAW,CAAC;AAC5D,eAAO,aAAa,MAAM,QAAQ,SAAS,KAAK;AAAA,MAClD,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;AAcO,SAAS,cAKd,YACA,SACqD;AACrD,QAAM,SAAQ,mCAAS,UAAS;AAChC,QAAM,UAAS,mCAAS,WAAU;AAElC,SAAO,CACL,WACsD;AACtD,UAAM,UAAU,OAAO;AAAA,MACrB,OAA2C,CAAC,WAAW;AAErD,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,YAAI,IAAI;AACR,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EACrC,MAAM,QAAQ,SAAS,KAAK,EAC5B,IAAI,CAAC,CAAC,OAAO,YAAY,MAAkC;AAAA,UAC1D,CAAC,OAAO,GAAG;AAAA,UACX;AAAA,QAAA,CACD;AACH,eAAO;AAAA,MACT,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;"}
+{"version":3,"file":"topK.js","sources":["../../../src/operators/topK.ts"],"sourcesContent":["import { MultiSet } from \"../multiset.js\"\nimport { reduce } from \"./reduce.js\"\nimport type { IStreamBuilder, KeyValue, PipedOperator } from \"../types\"\n\ninterface TopKOptions {\n  limit?: number\n  offset?: number\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that limits the number of results\n */\nexport function topK<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions\n): PipedOperator<T, T> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    const reduced = stream.pipe(\n      reduce((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0] as V1Type, b[0] as V1Type))\n        return sortedValues.slice(offset, offset + limit)\n      })\n    )\n    return reduced as IStreamBuilder<T>\n  }\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * This works on a keyed stream, where the key is the first element of the tuple\n * The ordering is withing a key group, i.e. elements are sorted within a key group\n * and the limit + offset is applied to that sorted group.\n * To order the entire stream, key by the same value for all elements such as null.\n * Adds the index of the element to the result as [key, [value, index]]\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function topKWithIndex<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  T,\n>(\n  comparator: (a: V1Type, b: V1Type) => number,\n  options?: TopKOptions\n): PipedOperator<T, KeyValue<KType, [V1Type, number]>> {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n\n  return (\n    stream: IStreamBuilder<T>\n  ): IStreamBuilder<KeyValue<KType, [V1Type, number]>> => {\n    const reduced = stream.pipe(\n      reduce<KType, V1Type, [V1Type, number], T>((values) => {\n        // `values` is a list of tuples, first element is the value, second is the multiplicity\n        const consolidated = new MultiSet(values).consolidate()\n        let i = offset\n        const sortedValues = consolidated\n          .getInner()\n          .sort((a, b) => comparator(a[0], b[0]))\n          .slice(offset, offset + limit)\n          .map(([value, multiplicity]): [[V1Type, number], number] => [\n            [value, i++],\n            multiplicity,\n          ])\n        return sortedValues\n      })\n    )\n    return reduced\n  }\n}\n"],"names":[],"mappings":";;AAoBO,SAAS,KAKd,YACA,SACqB;AACrB,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CAAC,WAAiD;AACvD,UAAM,UAAU,OAAO;AAAA,MACrB,OAAO,CAAC,WAAW;AAEjB,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAa,EAAE,CAAC,CAAW,CAAC;AAC5D,eAAO,aAAa,MAAM,QAAQ,SAAS,KAAK;AAAA,MAClD,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;AAcO,SAAS,cAKd,YACA,SACqD;AACrD,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAElC,SAAO,CACL,WACsD;AACtD,UAAM,UAAU,OAAO;AAAA,MACrB,OAA2C,CAAC,WAAW;AAErD,cAAM,eAAe,IAAI,SAAS,MAAM,EAAE,YAAA;AAC1C,YAAI,IAAI;AACR,cAAM,eAAe,aAClB,SAAA,EACA,KAAK,CAAC,GAAG,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EACrC,MAAM,QAAQ,SAAS,KAAK,EAC5B,IAAI,CAAC,CAAC,OAAO,YAAY,MAAkC;AAAA,UAC1D,CAAC,OAAO,GAAG;AAAA,UACX;AAAA,QAAA,CACD;AACH,eAAO;AAAA,MACT,CAAC;AAAA,IAAA;AAEH,WAAO;AAAA,EACT;AACF;"}

package/dist/esm/operators/topKWithFractionalIndex.d.ts

@@ -4,6 +4,10 @@ export interface TopKWithFractionalIndexOptions {
     limit?: number;
     offset?: number;
     setSizeCallback?: (getSize: () => number) => void;
+    setWindowFn?: (windowFn: (options: {
+        offset?: number;
+        limit?: number;
+    }) => void) => void;
 }
 export type TopKChanges<V> = {
     /** Indicates which element moves into the topK (if any) */
@@ -11,6 +15,14 @@ export type TopKChanges<V> = {
     /** Indicates which element moves out of the topK (if any) */
     moveOut: IndexedValue<V> | null;
 };
+export type TopKMoveChanges<V> = {
+    /** Flag that marks whether there were any changes to the topK */
+    changes: boolean;
+    /** Indicates which elements move into the topK (if any) */
+    moveIns: Array<IndexedValue<V>>;
+    /** Indicates which elements move out of the topK (if any) */
+    moveOuts: Array<IndexedValue<V>>;
+};
 /**
  * A topK data structure that supports insertions and deletions
  * and returns changes to the topK.
@@ -35,8 +47,18 @@ export declare class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator
     #private;
     constructor(id: number, inputA: DifferenceStreamReader<[K, T]>, output: DifferenceStreamWriter<[K, IndexedValue<T>]>, comparator: (a: T, b: T) => number, options: TopKWithFractionalIndexOptions);
     protected createTopK(offset: number, limit: number, comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number): TopK<TaggedValue<K, T>>;
+    /**
+     * Moves the topK window based on the provided offset and limit.
+     * Any changes to the topK are sent to the output.
+     */
+    moveTopK({ offset, limit }: {
+        offset?: number;
+        limit?: number;
+    }): void;
     run(): void;
     processElement(key: K, value: T, multiplicity: number, result: Array<[[K, IndexedValue<T>], number]>): void;
+    private handleMoveIn;
+    private handleMoveOut;
     private getMultiplicity;
     private addKey;
 }

package/dist/esm/operators/topKWithFractionalIndex.js

@@ -1,48 +1,68 @@
-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 _sortedValues, _comparator, _topKStart, _topKEnd, _TopKArray_instances, findIndex_fn, _index, _topK, _limit;
 import { generateKeyBetween } from "fractional-indexing";
 import { UnaryOperator, DifferenceStreamWriter } from "../graph.js";
 import { StreamBuilder } from "../d2.js";
 import { MultiSet } from "../multiset.js";
-import { binarySearch, globalObjectIdGenerator } from "../utils.js";
+import { diffHalfOpen, binarySearch, globalObjectIdGenerator } from "../utils.js";
 class TopKArray {
+  #sortedValues = [];
+  #comparator;
+  #topKStart;
+  #topKEnd;
   constructor(offset, limit, comparator) {
-    __privateAdd(this, _TopKArray_instances);
-    __privateAdd(this, _sortedValues, []);
-    __privateAdd(this, _comparator);
-    __privateAdd(this, _topKStart);
-    __privateAdd(this, _topKEnd);
-    __privateSet(this, _topKStart, offset);
-    __privateSet(this, _topKEnd, offset + limit);
-    __privateSet(this, _comparator, comparator);
+    this.#topKStart = offset;
+    this.#topKEnd = offset + limit;
+    this.#comparator = comparator;
   }
   get size() {
-    const offset = __privateGet(this, _topKStart);
-    const limit = __privateGet(this, _topKEnd) - __privateGet(this, _topKStart);
-    const available = __privateGet(this, _sortedValues).length - offset;
+    const offset = this.#topKStart;
+    const limit = this.#topKEnd - this.#topKStart;
+    const available = this.#sortedValues.length - offset;
     return Math.max(0, Math.min(limit, available));
   }
+  /**
+   * Moves the topK window
+   */
+  move({
+    offset,
+    limit
+  }) {
+    const oldOffset = this.#topKStart;
+    const oldLimit = this.#topKEnd - this.#topKStart;
+    const oldRange = [this.#topKStart, this.#topKEnd];
+    this.#topKStart = offset ?? oldOffset;
+    this.#topKEnd = this.#topKStart + (limit ?? oldLimit);
+    const newRange = [this.#topKStart, this.#topKEnd];
+    const { onlyInA, onlyInB } = diffHalfOpen(oldRange, newRange);
+    const moveIns = [];
+    onlyInB.forEach((index) => {
+      const value = this.#sortedValues[index];
+      if (value) {
+        moveIns.push(value);
+      }
+    });
+    const moveOuts = [];
+    onlyInA.forEach((index) => {
+      const value = this.#sortedValues[index];
+      if (value) {
+        moveOuts.push(value);
+      }
+    });
+    return { moveIns, moveOuts, changes: onlyInA.length + onlyInB.length > 0 };
+  }
   insert(value) {
     const result = { moveIn: null, moveOut: null };
-    const index = __privateMethod(this, _TopKArray_instances, findIndex_fn).call(this, value);
-    const indexBefore = index === 0 ? null : getIndex(__privateGet(this, _sortedValues)[index - 1]);
-    const indexAfter = index === __privateGet(this, _sortedValues).length ? null : getIndex(__privateGet(this, _sortedValues)[index]);
+    const index = this.#findIndex(value);
+    const indexBefore = index === 0 ? null : getIndex(this.#sortedValues[index - 1]);
+    const indexAfter = index === this.#sortedValues.length ? null : getIndex(this.#sortedValues[index]);
     const fractionalIndex = generateKeyBetween(indexBefore, indexAfter);
     const val = indexedValue(value, fractionalIndex);
-    __privateGet(this, _sortedValues).splice(index, 0, val);
-    if (index < __privateGet(this, _topKEnd)) {
-      const moveInIndex = Math.max(index, __privateGet(this, _topKStart));
-      if (moveInIndex < __privateGet(this, _sortedValues).length) {
-        result.moveIn = __privateGet(this, _sortedValues)[moveInIndex];
-        if (__privateGet(this, _topKEnd) < __privateGet(this, _sortedValues).length) {
-          result.moveOut = __privateGet(this, _sortedValues)[__privateGet(this, _topKEnd)];
+    this.#sortedValues.splice(index, 0, val);
+    if (index < this.#topKEnd) {
+      const moveInIndex = Math.max(index, this.#topKStart);
+      if (moveInIndex < this.#sortedValues.length) {
+        result.moveIn = this.#sortedValues[moveInIndex];
+        if (this.#topKEnd < this.#sortedValues.length) {
+          result.moveOut = this.#sortedValues[this.#topKEnd];
         }
       }
     }
@@ -56,54 +76,47 @@ class TopKArray {
    */
   delete(value) {
     const result = { moveIn: null, moveOut: null };
-    const index = __privateMethod(this, _TopKArray_instances, findIndex_fn).call(this, value);
-    const [removedElem] = __privateGet(this, _sortedValues).splice(index, 1);
-    if (index < __privateGet(this, _topKEnd)) {
+    const index = this.#findIndex(value);
+    const [removedElem] = this.#sortedValues.splice(index, 1);
+    if (index < this.#topKEnd) {
       result.moveOut = removedElem;
-      if (index < __privateGet(this, _topKStart)) {
-        const moveOutIndex = __privateGet(this, _topKStart) - 1;
-        if (moveOutIndex < __privateGet(this, _sortedValues).length) {
-          result.moveOut = __privateGet(this, _sortedValues)[moveOutIndex];
+      if (index < this.#topKStart) {
+        const moveOutIndex = this.#topKStart - 1;
+        if (moveOutIndex < this.#sortedValues.length) {
+          result.moveOut = this.#sortedValues[moveOutIndex];
         } else {
           result.moveOut = null;
         }
       }
-      const moveInIndex = __privateGet(this, _topKEnd) - 1;
-      if (moveInIndex < __privateGet(this, _sortedValues).length) {
-        result.moveIn = __privateGet(this, _sortedValues)[moveInIndex];
+      const moveInIndex = this.#topKEnd - 1;
+      if (moveInIndex < this.#sortedValues.length) {
+        result.moveIn = this.#sortedValues[moveInIndex];
       }
     }
     return result;
   }
+  // TODO: see if there is a way to refactor the code for insert and delete in the topK above
+  //       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right
+  //       so i have the feeling there is a common pattern here and we can implement both cases using that pattern
+  #findIndex(value) {
+    return binarySearch(
+      this.#sortedValues,
+      indexedValue(value, ``),
+      (a, b) => this.#comparator(getValue(a), getValue(b))
+    );
+  }
 }
-_sortedValues = new WeakMap();
-_comparator = new WeakMap();
-_topKStart = new WeakMap();
-_topKEnd = new WeakMap();
-_TopKArray_instances = new WeakSet();
-// TODO: see if there is a way to refactor the code for insert and delete in the topK above
-//       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right
-//       so i have the feeling there is a common pattern here and we can implement both cases using that pattern
-findIndex_fn = function(value) {
-  return binarySearch(
-    __privateGet(this, _sortedValues),
-    indexedValue(value, ``),
-    (a, b) => __privateGet(this, _comparator).call(this, getValue(a), getValue(b))
-  );
-};
 class TopKWithFractionalIndexOperator extends UnaryOperator {
+  #index = /* @__PURE__ */ new Map();
+  // maps keys to their multiplicity
+  /**
+   * topK data structure that supports insertions and deletions
+   * and returns changes to the topK.
+   */
+  #topK;
   constructor(id, inputA, output, comparator, options) {
-    var _a;
     super(id, inputA, output);
-    __privateAdd(this, _index, /* @__PURE__ */ new Map());
-    // maps keys to their multiplicity
-    /**
-     * topK data structure that supports insertions and deletions
-     * and returns changes to the topK.
-     */
-    __privateAdd(this, _topK);
-    __privateAdd(this, _limit);
-    __privateSet(this, _limit, options.limit ?? Infinity);
+    const limit = options.limit ?? Infinity;
     const offset = options.offset ?? 0;
     const compareTaggedValues = (a, b) => {
       const valueComparison = comparator(getVal(a), getVal(b));
@@ -114,12 +127,31 @@ class TopKWithFractionalIndexOperator extends UnaryOperator {
       const tieBreakerB = getTag(b);
       return tieBreakerA - tieBreakerB;
     };
-    __privateSet(this, _topK, this.createTopK(offset, __privateGet(this, _limit), compareTaggedValues));
-    (_a = options.setSizeCallback) == null ? void 0 : _a.call(options, () => __privateGet(this, _topK).size);
+    this.#topK = this.createTopK(offset, limit, compareTaggedValues);
+    options.setSizeCallback?.(() => this.#topK.size);
+    options.setWindowFn?.(this.moveTopK.bind(this));
   }
   createTopK(offset, limit, comparator) {
     return new TopKArray(offset, limit, comparator);
   }
+  /**
+   * Moves the topK window based on the provided offset and limit.
+   * Any changes to the topK are sent to the output.
+   */
+  moveTopK({ offset, limit }) {
+    if (!(this.#topK instanceof TopKArray)) {
+      throw new Error(
+        `Cannot move B+-tree implementation of TopK with fractional index`
+      );
+    }
+    const result = [];
+    const diff = this.#topK.move({ offset, limit });
+    diff.moveIns.forEach((moveIn) => this.handleMoveIn(moveIn, result));
+    diff.moveOuts.forEach((moveOut) => this.handleMoveOut(moveOut, result));
+    if (diff.changes) {
+      this.output.sendData(new MultiSet(result));
+    }
+  }
   run() {
     const result = [];
     for (const message of this.inputMessages()) {
@@ -140,44 +172,47 @@ class TopKWithFractionalIndexOperator extends UnaryOperator {
     };
     if (oldMultiplicity <= 0 && newMultiplicity > 0) {
       const taggedValue = tagValue(key, value);
-      res = __privateGet(this, _topK).insert(taggedValue);
+      res = this.#topK.insert(taggedValue);
     } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {
       const taggedValue = tagValue(key, value);
-      res = __privateGet(this, _topK).delete(taggedValue);
+      res = this.#topK.delete(taggedValue);
     } else ;
-    if (res.moveIn) {
-      const index = getIndex(res.moveIn);
-      const taggedValue = getValue(res.moveIn);
+    this.handleMoveIn(res.moveIn, result);
+    this.handleMoveOut(res.moveOut, result);
+    return;
+  }
+  handleMoveIn(moveIn, result) {
+    if (moveIn) {
+      const index = getIndex(moveIn);
+      const taggedValue = getValue(moveIn);
       const k = getKey(taggedValue);
       const val = getVal(taggedValue);
       result.push([[k, [val, index]], 1]);
     }
-    if (res.moveOut) {
-      const index = getIndex(res.moveOut);
-      const taggedValue = getValue(res.moveOut);
+  }
+  handleMoveOut(moveOut, result) {
+    if (moveOut) {
+      const index = getIndex(moveOut);
+      const taggedValue = getValue(moveOut);
       const k = getKey(taggedValue);
       const val = getVal(taggedValue);
       result.push([[k, [val, index]], -1]);
     }
-    return;
   }
   getMultiplicity(key) {
-    return __privateGet(this, _index).get(key) ?? 0;
+    return this.#index.get(key) ?? 0;
   }
   addKey(key, multiplicity) {
     const oldMultiplicity = this.getMultiplicity(key);
     const newMultiplicity = oldMultiplicity + multiplicity;
     if (newMultiplicity === 0) {
-      __privateGet(this, _index).delete(key);
+      this.#index.delete(key);
     } else {
-      __privateGet(this, _index).set(key, newMultiplicity);
+      this.#index.set(key, newMultiplicity);
     }
     return { oldMultiplicity, newMultiplicity };
   }
 }
-_index = new WeakMap();
-_topK = new WeakMap();
-_limit = new WeakMap();
 function topKWithFractionalIndex(comparator, options) {
   const opts = options || {};
   return (stream) => {