How to use the querystringify.parse function in querystringify

if (!isPlainObject(vast_query)) return;

    // remove query parameters
    let query = parser.query;
    if (vast_query["$$remove"]) {
      for (let key in query) {
        let regex = new RegExp(vast_query["$$remove"], "i");
        if (!regex.test(key)) continue;
        delete query[key];
      }
      delete vast_query["$$remove"];
    }

    // remove cust_params parameters
    let cust_params = qs.parse(query.cust_params);
    if (vast_query.cust_params && vast_query.cust_params["$$remove"]) {
      for (let key in cust_params) {
        let regex = new RegExp(vast_query.cust_params["$$remove"], "i");
        if (!regex.test(key)) continue;
        delete cust_params[key];
      }
      delete vast_query.cust_params["$$remove"];
    }

    // transform
    let transformed = this.macros.transform(vast_query, {
      get: (key) => {
        return vast.tnl_keys[key.toLowerCase()];
      }
    });

_transformVast(vast, context) {

    let result = {
      url: vast.url
    };

    try {
      let parser = new Url(vast.url, true);
      let transformed = this._transformQuery(vast, context, parser);
      if (transformed)
        result.url = parser.toString();

      // temp
      let cust_params = qs.parse(parser.query.cust_params);
      result.bidder = cust_params.hb_bidder;
      result.price = cust_params.gd_fp;
      
      return result;
    } catch (error) {
      result.hasError = true;
      result.message = error.message;
      result.bidder = "error";
      console.log(error.message);
      return result;
    }
  }

export const viewAllComments = () => (dispatch, _, { pym }) => {
  const query = queryString.parse(location.search);

  // remove the comment_id url param
  delete query.comment_id;

  const search = queryString.stringify(query);

  const url = buildUrl({ ...location, search });

  try {
    // "window" here refers to the embedded iframe
    window.history.replaceState({}, document.title, url);

    // also change the parent url
    pym.sendMessage('coral-view-all-comments');
  } catch (e) {
    /* not sure if we're worried about old browsers */

it('sets url parameters', function () {
    var stubLoadScript = sinon.stub(adLoader, 'loadScript');

    (new Adapter()).callBids(DEFAULT_PARAMS);

    var bidUrl = stubLoadScript.getCall(0).args[0];
    var parsedBidUrl = urlParse(bidUrl);
    var parsedBidUrlQueryString = querystringify.parse(parsedBidUrl.query);

    expect(parsedBidUrl.hostname).to.equal('rtb.t.c4tw.net');
    expect(parsedBidUrl.pathname).to.equal('/Bid');

    expect(parsedBidUrlQueryString).to.have.property('s').and.to.equal('h');
    expect(parsedBidUrlQueryString).to.have.property('callback').and.to.equal('$$PREBID_GLOBAL$$.handleTwCB');
    expect(parsedBidUrlQueryString).to.have.property('callback_uid').and.to.equal('tw_abcd1234');
    expect(parsedBidUrlQueryString).to.have.property('id').and.to.equal('test');

    stubLoadScript.restore();
  });

var stubLoadScript = sinon.stub(adLoader, 'loadScript').callsFake(function(url) {
      var bidUrl = stubLoadScript.getCall(0).args[0];
      var parsedBidUrl = urlParse(bidUrl);
      var parsedBidUrlQueryString = querystringify.parse(parsedBidUrl.query);

      $$PREBID_GLOBAL$$._bidsRequested
        .push({ bidderCode: DEFAULT_PARAMS.bidderCode,
          bids: [{ bidId: parsedBidUrlQueryString.callback_uid,
            placementCode: DEFAULT_PARAMS.bids[0].placementCode }]});

      var callback = stringToFunction(parsedBidUrlQueryString.callback);
      expect(callback).to.exist.and.to.be.a('function');
      callback(BID_RESPONSE);
    });
    var stubAddBidResponse = sinon.stub(bidmanager, 'addBidResponse');

params: {},
            bidId: '9101112',
            placementCode: 'div-gpt-ad-12345-3'
          }
        ]
      };

      adapter().callBids(params);
      var bidUrl1 = stubLoadScript.getCall(0).args[0];
      var bidUrl2 = stubLoadScript.getCall(1).args[0];

      sinon.assert.calledWith(logErrorSpy, 'Bid has no unit', 'centro');
      sinon.assert.calledWith(stubLoadScript, bidUrl1);

      var parsedBidUrl = urlParse(bidUrl1);
      var parsedBidUrlQueryString = querystringify.parse(parsedBidUrl.query);
      var generatedCallback = 'window["adCentroHandler_28136300x2501234"]';

      expect(parsedBidUrl.hostname).to.equal('staging.brand-server.com');
      expect(parsedBidUrl.pathname).to.equal('/hb');

      expect(parsedBidUrlQueryString).to.have.property('s').and.to.equal('28136');
      expect(parsedBidUrlQueryString).to.have.property('url').and.to.equal('http://test_url.ru');
      expect(parsedBidUrlQueryString).to.have.property('sz').and.to.equal('300x250');
      expect(parsedBidUrlQueryString).to.have.property('callback').and.to.equal(generatedCallback);

      sinon.assert.calledWith(stubLoadScript, bidUrl2);

      parsedBidUrl = urlParse(bidUrl2);
      parsedBidUrlQueryString = querystringify.parse(parsedBidUrl.query);
      generatedCallback = 'window["adCentroHandler_28137728x905678"]';

function parseAMPHash(opts) {
  const result = { ...opts };
  const query = window.location.hash.length && window.location.hash.substr(1);
  if (query) {
    const parsed = queryString.parse(query);
    if (parsed.asset_url && !result.asset_url) {
      result.asset_url = parsed.asset_url;
    }
    if (parsed.asset_id && !result.asset_id) {
      result.asset_id = parsed.asset_id;
    }
  }
  return result;
}

apply() {
        const { locale, location: { search } } = this.props
        const { lang: newLocale } = qs.parse(search)
        const sanitized = {
            locale: getDefaultLocale(locale, localeList),
            newLocale: getDefaultLocale(newLocale, localeList),
        }
        if (locale !== sanitized.newLocale) {
            applyLocale(store, sanitized.newLocale, localeList, 'en')
        } else if (locale !== sanitized.locale) {
            applyLocale(store, sanitized.locale, localeList, 'en')
        }
    }

    hash => qs.parse(hash)
  )

export function getQueryMatch(
  queryString: string,
  queryParameters: QueryParameterDefinitionCollection
) {
  const match: { [name: string]: string | number } = {};

  const queryParameterNames = Object.keys(queryParameters);

  if (queryParameterNames.length === 0 && queryString === "") {
    return match;
  }

  const queryParameterValues = qs.parse(queryString) as Record;

  for (const name of queryParameterNames) {
    const kind = queryParameters[name];
    const value = queryParameterValues[name];

    if (kind === "query.param.number") {
      if (value === undefined || !isNumeric(value)) {
        return false;
      }

      match[name] = parseFloat(value);
    } else if (kind === "query.param.string") {
      if (value === undefined) {
        return false;
      }