How to use the rdf-terms.mapTerms function in rdf-terms

public static replaceBlankNodes(pattern: RDF.Quad): RDF.Quad {
    const variableNames: string[] = getVariables(getTerms(pattern)).map((v) => v.value);
    // track the names the blank nodes get mapped to (required if the name has to change)
    const blankMap: { [id: string]: string } = {};
    let changed = false;

    // for every position, convert to a variable if there is a blank node
    const result = mapTerms(pattern, (term) => {
      if (term.termType === 'BlankNode') {
        let name = term.value;
        if (blankMap[name]) {
          name = blankMap[name];
        } else {
          if (variableNames.indexOf(name) >= 0) {
            // increase index added to name until we find one that is available (2 loops at most)
            let idx = 0;
            while (variableNames.indexOf(name + idx) >= 0) {
              ++idx;
            }
            name = name + idx;
          }
          blankMap[term.value] = name;
          variableNames.push(name);
        }

        .map((bindings: Bindings) => mapTerms(pattern, (value: RDF.Term) => {
          if (value.termType === 'Variable') {
            const boundValue: RDF.Term = bindings.get('?' + value.value);
            if (!boundValue) {
              data.emit('error',
                new Error('The endpoint ' + endpoint + ' failed to provide a binding for ' + value.value));
            }
            return boundValue;
          }
          return value;
        })));

public static bindQuad(bindings: Bindings, pattern: RDF.Quad): RDF.Quad {
    try {
      return mapTerms(pattern, (term) => {
        const boundTerm: RDF.Term = BindingsToQuadsIterator.bindTerm(bindings, term);
        if (!boundTerm) {
          throw new Error('Unbound term');
        }
        return boundTerm;
      });
    } catch (error) {
      return null;
    }
  }

quads._read = async () => {
      if (!initialized) {
        initialized = true;
        const jsonString = await require('stream-to-string')(action.input);
        const quadsArray = await this.jsonLd.toRDF(JSON.parse(jsonString), { base: action.baseIRI });
        for (const quad of quadsArray) {
          quads.push(mapTerms(quad, ActorRdfParseJsonLd.mapTerm));
        }
        quads.push(null);
      }
    };
    return { quads };

public static localizeQuad(blankNodeCounter: number,
                             pattern: RDF.BaseQuad): RDF.BaseQuad {
    return mapTerms(pattern, (term) => BindingsToQuadsIterator.localizeBlankNode(blankNodeCounter, term));
  }