How to use the @comunica/bus-query-operation.Bindings function in @comunica/bus-query-operation

context = context || ActionContext({});
    let subContext: ActionContext = context.delete(KEY_CONTEXT_SOURCE).delete(KEY_CONTEXT_SOURCES);
    const sourceType = this.forceSparqlEndpoint ? 'sparql' : 'auto';
    subContext = subContext.set(KEY_CONTEXT_SOURCES,
      AsyncReiterableArray.fromFixedData([{ type: sourceType, value: endpoint }]));

    // Query the source
    let output: IActorQueryOperationOutputBindings;
    try {
      output = ActorQueryOperation.getSafeBindings(
        await this.mediatorQueryOperation.mediate({ operation: pattern.input, context: subContext }));
    } catch (e) {
      if (pattern.silent) {
        // Emit a single empty binding
        output = {
          bindingsStream: new SingletonIterator(Bindings({})),
          type: 'bindings',
          variables: [],
        };
      } else {
        throw e;
      }
    }

    return output;
  }

});

    // Case: No Input
    // Some aggregators still define an output on the empty input
    // Result is a single Bindings
    if (rows.length === 0) {
      const single: { [key: string]: Term } = {};
      for (const i in this.pattern.aggregates) {
        const aggregate = this.pattern.aggregates[i];
        const key = termToString(aggregate.variable);
        const value = AggregateEvaluator.emptyValue(aggregate);
        if (value !== undefined) {
          single[key] = value;
        }
      }
      rows = [Bindings(single)];
    }

    return rows;
  }

public async runOperation(pattern: Algebra.Bgp, context: ActionContext)
  : Promise {
    return {
      bindingsStream: new SingletonIterator(Bindings({})),
      metadata: () => Promise.resolve({ totalItems: 1 }),
      type: 'bindings',
      variables: [],
    };
  }

          rawBindingsStream.on('data', (rawBindings) => bindingsStream._push(Bindings(rawBindings)));
          rawBindingsStream.on('end', () => {

const bindingsStream: BindingsStream = new PromiseProxyIterator(async () => result.data.map((quad) => {
      return Bindings(reduceTerms(quad, quadBindingsReducer, {}));
    }, { autoStart: true, maxBufferSize: 128 }));