prebid.js 7.52.0 → 7.54.0

package/modules/adhashBidAdapter.js

@@ -1,9 +1,9 @@
-import {registerBidder} from '../src/adapters/bidderFactory.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { getStorageManager } from '../src/storageManager.js';
 import { includes } from '../src/polyfill.js';
 import { BANNER, VIDEO } from '../src/mediaTypes.js';
 
-const VERSION = '3.2';
+const VERSION = '3.6';
 const BAD_WORD_STEP = 0.1;
 const BAD_WORD_MIN = 0.2;
 const ADHASH_BIDDER_CODE = 'adhash';
@@ -19,6 +19,8 @@ const ADHASH_BIDDER_CODE = 'adhash';
  * @returns boolean flag is the page safe
  */
 function brandSafety(badWords, maxScore) {
+  const delimiter = '~';
+
   /**
    * Performs the ROT13 encoding on the string argument and returns the resulting string.
    * The Adhash bidder uses ROT13 so that the response is not blocked by:
@@ -40,17 +42,17 @@ function brandSafety(badWords, maxScore) {
   /**
    * Calculates the scoring for each bad word with dimishing returns
    * @param {integer} points points that this word costs
-   * @param {integer} occurances number of occurances
+   * @param {integer} occurrences number of occurrences
    * @returns {float} final score
    */
-  const scoreCalculator = (points, occurances) => {
+  const scoreCalculator = (points, occurrences) => {
     let positive = true;
     if (points < 0) {
       points *= -1;
       positive = false;
     }
     let result = 0;
-    for (let i = 0; i < occurances; i++) {
+    for (let i = 0; i < occurrences; i++) {
       result += Math.max(points - i * BAD_WORD_STEP, BAD_WORD_MIN);
     }
     return positive ? result : -result;
@@ -60,22 +62,50 @@ function brandSafety(badWords, maxScore) {
    * Checks what rule will match in the given array with words
    * @param {string} rule rule type (full, partial, starts, ends, regexp)
    * @param {string} decodedWord decoded word
-   * @param {array} wordsToMatch array to find a match
+   * @param {string} wordsToMatch list of all words on the page separated by delimiters
    * @returns {object|boolean} matched rule and occurances. If nothing is matched returns false
    */
   const wordsMatchedWithRule = function (rule, decodedWord, wordsToMatch) {
-    if (rule === 'full' && wordsToMatch && wordsToMatch.includes(decodedWord)) {
-      return { rule, occurances: wordsToMatch.filter(element => element === decodedWord).length };
-    } else if (rule === 'partial' && wordsToMatch && wordsToMatch.some(element => element.indexOf(decodedWord) > -1)) {
-      return { rule, occurances: wordsToMatch.filter(element => element.indexOf(decodedWord) > -1).length };
-    } else if (rule === 'starts' && wordsToMatch && wordsToMatch.some(word => word.startsWith(decodedWord))) {
-      return { rule, occurances: wordsToMatch.filter(element => element.startsWith(decodedWord)).length };
-    } else if (rule === 'ends' && wordsToMatch && wordsToMatch.some(word => word.endsWith(decodedWord))) {
-      return { rule, occurances: wordsToMatch.filter(element => element.endsWith(decodedWord)).length };
-    } else if (rule === 'regexp' && wordsToMatch && wordsToMatch.some(element => element.match(new RegExp(decodedWord, 'i')))) {
-      return { rule, occurances: wordsToMatch.filter(element => element.match(new RegExp(decodedWord, 'i'))).length };
+    if (!wordsToMatch) {
+      return false;
+    }
+
+    let occurrences;
+    let adjustedWordToMatch;
+    decodedWord = decodedWord.split(' ').join(`${delimiter}${delimiter}`);
+    switch (rule) {
+      case 'full':
+        adjustedWordToMatch = `${delimiter}${decodedWord}${delimiter}`;
+        break;
+      case 'partial':
+        adjustedWordToMatch = decodedWord;
+        break;
+      case 'starts':
+        adjustedWordToMatch = `${delimiter}${decodedWord}`;
+        break;
+      case 'ends':
+        adjustedWordToMatch = `${decodedWord}${delimiter}`;
+        break;
+      case 'combo':
+        const allOccurrences = [];
+        const paddedWordsToMatch = `${delimiter}${wordsToMatch}${delimiter}`;
+        const decodedWordsSplit = decodedWord.split(`${delimiter}${delimiter}`);
+        for (const decodedWordPart of decodedWordsSplit) {
+          adjustedWordToMatch = `${delimiter}${decodedWordPart}${delimiter}`;
+          allOccurrences.push(paddedWordsToMatch.split(adjustedWordToMatch).length - 1);
+        }
+        occurrences = Math.min(...allOccurrences);
+        return occurrences > 0 ? { rule, occurrences } : false;
+      case 'regexp':
+        occurrences = [...wordsToMatch.matchAll(new RegExp(decodedWord, 'gi'))].length;
+        return occurrences > 0 ? { rule, occurrences } : false;
+      default:
+        return false;
     }
-    return false;
+
+    const paddedWordsToMatch = `${delimiter}${wordsToMatch}${delimiter}`;
+    occurrences = paddedWordsToMatch.split(adjustedWordToMatch).length - 1;
+    return occurrences > 0 ? { rule, occurrences } : false;
   };
 
   // Default parameters if the bidder is unable to send some of them
@@ -91,11 +121,11 @@ function brandSafety(badWords, maxScore) {
       .toLowerCase()
       .trim();
     const content = window.top.document.body.innerText.toLowerCase();
-    const contentWords = content.trim().split(/\s+/).length;
     // \p{L} matches a single unicode code point in the category 'letter'. Matches any kind of letter from any language.
     const regexp = new RegExp('[\\p{L}]+', 'gu');
-    const words = content.match(regexp);
-    const wordsInUrl = wordsAndNumbersInUrl.match(regexp);
+    const wordsMatched = content.match(regexp);
+    const words = wordsMatched.join(`${delimiter}${delimiter}`);
+    const wordsInUrl = wordsAndNumbersInUrl.match(regexp).join(`${delimiter}${delimiter}`);
 
     for (const [word, rule, points] of badWords) {
       const decodedWord = rot13(word.toLowerCase());
@@ -110,19 +140,11 @@ function brandSafety(badWords, maxScore) {
 
       // Check if site content's words match any of our brand safety rules
       const matchedRule = wordsMatchedWithRule(rule, decodedWord, words);
-      if (matchedRule.rule === 'full') {
-        score += scoreCalculator(points, matchedRule.occurances);
-      } else if (matchedRule.rule === 'partial') {
-        score += scoreCalculator(points, matchedRule.occurances);
-      } else if (matchedRule.rule === 'starts') {
-        score += scoreCalculator(points, matchedRule.occurances);
-      } else if (matchedRule.rule === 'ends') {
-        score += scoreCalculator(points, matchedRule.occurances);
-      } else if (matchedRule.rule === 'regexp') {
-        score += scoreCalculator(points, matchedRule.occurances);
+      if (matchedRule !== false) {
+        score += scoreCalculator(points, matchedRule.occurrences);
       }
     }
-    return score < (maxScore * contentWords) / 1000;
+    return score < (maxScore * wordsMatched.length) / 1000;
   } catch (e) {
     return true;
   }
@@ -183,8 +205,8 @@ export const spec = {
       }
 
       // Needed for the ad density calculation
-      var adHeight = validBidRequests[i].sizes[index][1];
-      var adWidth = validBidRequests[i].sizes[index][0];
+      const adHeight = validBidRequests[i].sizes[index][1];
+      const adWidth = validBidRequests[i].sizes[index][0];
       if (!window.adsCount) {
         window.adsCount = 0;
       }
@@ -247,7 +269,7 @@ export const spec = {
     const bidderResponse = JSON.stringify({ responseText: JSON.stringify(responseBody) });
     const requestData = JSON.stringify(request.data);
 
-    var response = {
+    let response = {
       requestId: request.bidRequest.bidId,
       cpm: responseBody.creatives[0].costEUR,
       width: request.bidRequest.sizes[0][0],

package/modules/adkernelBidAdapter.js

@@ -90,7 +90,6 @@ export const spec = {
     {code: 'denakop'},
     {code: 'rtbanalytica'},
     {code: 'unibots'},
-    {code: 'catapultx'},
     {code: 'ergadx'},
     {code: 'turktelekom'},
     {code: 'felixads'},
@@ -100,7 +99,8 @@ export const spec = {
     {code: 'rtbdemand_com'},
     {code: 'bidbuddy'},
     {code: 'adliveconnect'},
-    {code: 'didnadisplay'}
+    {code: 'didnadisplay'},
+    {code: 'qortex'}
   ],
   supportedMediaTypes: [BANNER, VIDEO, NATIVE],
 

package/modules/airgridRtdProvider.js

@@ -12,8 +12,9 @@ import {
   deepAccess,
 } from '../src/utils.js';
 import { getGlobal } from '../src/prebidGlobal.js';
-import {getStorageManager} from '../src/storageManager.js';
-import {MODULE_TYPE_RTD} from '../src/activities/modules.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { loadExternalScript } from '../src/adloader.js';
+import { MODULE_TYPE_RTD } from '../src/activities/modules.js';
 
 const MODULE_NAME = 'realTimeData';
 const SUBMODULE_NAME = 'airgrid';
@@ -25,6 +26,11 @@ export const storage = getStorageManager({
   moduleName: SUBMODULE_NAME,
 });
 
+function getModuleUrl(accountId) {
+  const path = accountId ?? 'sdk';
+  return `https://cdn.edkt.io/${path}/edgekit.min.js`;
+}
+
 /**
  * Attach script tag to DOM
  * @param {Object} rtdConfig
@@ -33,19 +39,12 @@ export const storage = getStorageManager({
 export function attachScriptTagToDOM(rtdConfig) {
   var edktInitializor = (window.edktInitializor = window.edktInitializor || {});
   if (!edktInitializor.invoked) {
-    edktInitializor.invoked = true;
     edktInitializor.accountId = rtdConfig.params.accountId;
     edktInitializor.publisherId = rtdConfig.params.publisherId;
     edktInitializor.apiKey = rtdConfig.params.apiKey;
-    edktInitializor.load = function (e) {
-      var p = e || 'sdk';
-      var n = document.createElement('script');
-      n.type = 'module';
-      n.async = true;
-      n.src = 'https://cdn.edkt.io/' + p + '/edgekit.min.js';
-      document.getElementsByTagName('head')[0].appendChild(n);
-    };
-    edktInitializor.load(edktInitializor.accountId);
+    edktInitializor.invoked = true;
+    const moduleSrc = getModuleUrl(rtdConfig.params.accountId);
+    loadExternalScript(moduleSrc, SUBMODULE_NAME);
   }
 }
 

package/modules/asoBidAdapter.js

@@ -28,7 +28,8 @@ export const spec = {
   code: BIDDER_CODE,
   supportedMediaTypes: [BANNER, VIDEO],
   aliases: [
-    {code: 'bcmint'}
+    {code: 'bcmint'},
+    {code: 'bidgency'}
   ],
 
   isBidRequestValid: bid => {

package/modules/beopBidAdapter.js

@@ -37,6 +37,8 @@ export const spec = {
     */
   buildRequests: function(validBidRequests, bidderRequest) {
     const slots = validBidRequests.map(beOpRequestSlotsMaker);
+    const firstPartyData = bidderRequest.ortb2;
+    const psegs = (firstPartyData && firstPartyData.user && firstPartyData.user.ext && firstPartyData.user.ext.data) ? firstPartyData.user.ext.data.permutive : undefined;
     const pageUrl = getPageUrl(bidderRequest.refererInfo, window);
     const gdpr = bidderRequest.gdprConsent;
     const firstSlot = slots[0];
@@ -68,6 +70,10 @@ export const spec = {
       tc_string: (gdpr && gdpr.gdprApplies) ? gdpr.consentString : null,
     };
 
+    if (psegs) {
+      Object.assign(payloadObject, {psegs: psegs});
+    }
+
     const payloadString = JSON.stringify(payloadObject);
     return {
       method: 'POST',

package/modules/conceptxBidAdapter.js

@@ -0,0 +1,70 @@
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER } from '../src/mediaTypes.js';
+// import { logError, logInfo, logWarn, parseUrl } from '../src/utils.js';
+
+const BIDDER_CODE = 'conceptx';
+let ENDPOINT_URL = 'https://conceptx.cncpt-central.com/openrtb';
+// const LOG_PREFIX = 'ConceptX: ';
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER],
+  isBidRequestValid: function (bid) {
+    return !!(bid.bidId);
+  },
+
+  buildRequests: function (validBidRequests, bidderRequest) {
+    // logWarn(LOG_PREFIX + 'all native assets containing URL should be sent as placeholders with sendId(icon, image, clickUrl, displayUrl, privacyLink, privacyIcon)');
+    const requests = [];
+
+    if (bidderRequest && bidderRequest.gdprConsent && bidderRequest.gdprConsent.gdprApplies) {
+      ENDPOINT_URL += '?gdpr_applies=' + bidderRequest.gdprConsent.gdprApplies;
+      ENDPOINT_URL += '&consentString=' + bidderRequest.gdprConsent.consentString;
+    }
+    for (var i = 0; i < validBidRequests.length; i++) {
+      const requestParent = { adUnits: [], meta: {} };
+      const bid = validBidRequests[i]
+      const { adUnitCode, auctionId, bidId, bidder, bidderRequestId, ortb2 } = bid
+      requestParent.meta = { adUnitCode, auctionId, bidId, bidder, bidderRequestId, ortb2 }
+
+      const { site, adunit } = bid.params
+      const adUnit = { site, adunit, targetId: bid.bidId }
+      if (bid.mediaTypes && bid.mediaTypes.banner && bid.mediaTypes.banner.sizes) adUnit.dimensions = bid.mediaTypes.banner.sizes
+      requestParent.adUnits.push(adUnit);
+      requests.push({
+        method: 'POST',
+        url: ENDPOINT_URL,
+        options: {
+          withCredentials: false,
+        },
+        data: JSON.stringify(requestParent),
+      });
+    }
+
+    return requests;
+  },
+
+  interpretResponse: function (serverResponse, bidRequest) {
+    const bidResponsesFromServer = serverResponse.body.bidResponses;
+    const firstDummy = bidResponsesFromServer[0]
+    const firstSeat = firstDummy.ads[0]
+    const bidResponses = [];
+    const bidResponse = {
+      requestId: firstSeat.requestId,
+      cpm: firstSeat.cpm,
+      width: firstSeat.width,
+      height: firstSeat.height,
+      creativeId: firstSeat.creativeId,
+      dealId: firstSeat.dealId,
+      currency: firstSeat.currency,
+      netRevenue: true,
+      ttl: firstSeat.ttl,
+      referrer: firstSeat.referrer,
+      ad: firstSeat.html
+    };
+    bidResponses.push(bidResponse);
+    return bidResponses;
+  },
+
+}
+registerBidder(spec);

package/modules/conceptxBidAdapter.md

@@ -0,0 +1,36 @@
+# Overview
+
+```
+Module Name: ConceptX Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: info@concept.dk
+```
+
+# Description
+
+ConceptX Bidder Adapter for Prebid.js. 
+Only Banner format is supported.
+
+# Test Parameters
+```
+    var adUnits = [
+            {
+                code: "test-div",
+                mediaTypes: {
+                    banner: {
+                        sizes: [[980, 180]]
+                    }
+                },
+                bids: [
+                    {
+                        bidder: "conceptx",
+                        params: {
+                            site: "example",
+                            adunit: "some-id-3",
+                        }
+                    },
+                ]
+            },
+           
+        ];
+```

package/modules/criteoBidAdapter.js

@@ -28,7 +28,7 @@ const LOG_PREFIX = 'Criteo: ';
   Unminified source code can be found in the privately shared repo: https://github.com/Prebid-org/prebid-js-external-js-criteo/blob/master/dist/prod.js
 */
 const FAST_BID_VERSION_PLACEHOLDER = '%FAST_BID_VERSION%';
-export const FAST_BID_VERSION_CURRENT = 135;
+export const FAST_BID_VERSION_CURRENT = 136;
 const FAST_BID_VERSION_LATEST = 'latest';
 const FAST_BID_VERSION_NONE = 'none';
 const PUBLISHER_TAG_URL_TEMPLATE = 'https://static.criteo.net/js/ld/publishertag.prebid' + FAST_BID_VERSION_PLACEHOLDER + '.js';
@@ -177,7 +177,14 @@ export const spec = {
 
     if (publisherTagAvailable()) {
       // eslint-disable-next-line no-undef
-      const adapter = new Criteo.PubTag.Adapters.Prebid(PROFILE_ID_PUBLISHERTAG, ADAPTER_VERSION, bidRequests, bidderRequest, '$prebid.version$');
+      const adapter = new Criteo.PubTag.Adapters.Prebid(
+        PROFILE_ID_PUBLISHERTAG,
+        ADAPTER_VERSION,
+        bidRequests,
+        bidderRequest,
+        '$prebid.version$',
+        { createOutstreamVideoRenderer: createOutstreamVideoRenderer }
+      );
       url = adapter.buildCdbUrl();
       data = adapter.buildCdbRequest();
     } else {

package/modules/eskimiBidAdapter.js

@@ -1,7 +1,7 @@
-import {registerBidder} from '../src/adapters/bidderFactory.js';
-import {BANNER} from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
 import * as utils from '../src/utils.js';
-import {ortbConverter} from '../libraries/ortbConverter/converter.js'
 
 const BIDDER_CODE = 'eskimi';
 // const ENDPOINT = 'https://hb.eskimi.com/bids'
@@ -12,43 +12,35 @@ const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_NET_REVENUE = true;
 const GVLID = 814;
 
+const VIDEO_ORTB_PARAMS = [
+  'mimes',
+  'minduration',
+  'maxduration',
+  'placement',
+  'protocols',
+  'startdelay',
+  'skip',
+  'skipafter',
+  'minbitrate',
+  'maxbitrate',
+  'delivery',
+  'playbackmethod',
+  'api',
+  'linearity',
+  'battr'
+];
+
+const BANNER_ORTB_PARAMS = [
+  'battr'
+]
+
 export const spec = {
   code: BIDDER_CODE,
   gvlid: GVLID,
-  supportedMediaTypes: [BANNER],
-
-  isBidRequestValid: function (bid) {
-    return !!bid.params.placementId;
-  },
-
-  buildRequests(bidRequests, bidderRequest) {
-    const data = converter.toORTB({bidRequests, bidderRequest})
-
-    let bid = bidRequests.find((b) => b.params.placementId)
-    if (!data.site) data.site = {}
-    data.site.ext = {placementId: bid.params.placementId}
-
-    if (bidderRequest.gdprConsent) {
-      if (!data.user) data.user = {};
-      if (!data.user.ext) data.user.ext = {};
-      if (!data.regs) data.regs = {};
-      if (!data.regs.ext) data.regs.ext = {};
-      data.user.ext.consent = bidderRequest.gdprConsent.consentString;
-      data.regs.ext.gdpr = bidderRequest.gdprConsent.gdprApplies ? 1 : 0;
-    }
-
-    return [{
-      method: 'POST',
-      url: ENDPOINT,
-      data,
-      options: {contentType: 'application/json;charset=UTF-8', withCredentials: false}
-    }]
-  },
-
-  interpretResponse(response, request) {
-    return converter.fromORTB({response: response.body, request: request.data}).bids;
-  },
-
+  supportedMediaTypes: [BANNER, VIDEO],
+  isBidRequestValid,
+  buildRequests,
+  interpretResponse,
   /**
    * Register bidder specific code, which will execute if a bid from this bidder won the auction
    * @param {Bid} bid The bid that won the auction
@@ -60,13 +52,151 @@ export const spec = {
   }
 }
 
-const converter = ortbConverter({
+registerBidder(spec);
+
+const CONVERTER = ortbConverter({
   context: {
     netRevenue: DEFAULT_NET_REVENUE,
     ttl: DEFAULT_BID_TTL,
-    currency: DEFAULT_CURRENCY,
-    mediaType: BANNER // TODO: support more types, we should set mtype on the winning bid
+    currency: DEFAULT_CURRENCY
+  },
+  imp(buildImp, bidRequest, context) {
+    let imp = buildImp(bidRequest, context);
+    imp.secure = Number(window.location.protocol === 'https:');
+    if (!imp.bidfloor && bidRequest.params.bidFloor) {
+      imp.bidfloor = bidRequest.params.bidFloor;
+      imp.bidfloorcur = utils.getBidIdParameter('bidFloorCur', bidRequest.params).toUpperCase() || 'USD'
+    }
+
+    if (bidRequest.mediaTypes[VIDEO]) {
+      imp = buildVideoImp(bidRequest, imp);
+    } else if (bidRequest.mediaTypes[BANNER]) {
+      imp = buildBannerImp(bidRequest, imp);
+    }
+
+    return imp;
   }
 });
 
-registerBidder(spec);
+function isBidRequestValid(bidRequest) {
+  return (isPlacementIdValid(bidRequest) && (isValidBannerRequest(bidRequest) || isValidVideoRequest(bidRequest)));
+}
+
+function isPlacementIdValid(bidRequest) {
+  return utils.isNumber(bidRequest.params.placementId);
+}
+
+function isValidBannerRequest(bidRequest) {
+  const bannerSizes = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}.sizes`);
+  return utils.isArray(bannerSizes) && bannerSizes.length > 0 && bannerSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function isValidVideoRequest(bidRequest) {
+  const videoSizes = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}.playerSize`);
+
+  return utils.isArray(videoSizes) && videoSizes.length > 0 && videoSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function buildRequests(validBids, bidderRequest) {
+  let videoBids = validBids.filter(bid => isVideoBid(bid));
+  let bannerBids = validBids.filter(bid => isBannerBid(bid));
+  let requests = [];
+
+  bannerBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, BANNER));
+  });
+
+  videoBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, VIDEO));
+  });
+
+  return requests;
+}
+
+function interpretResponse(response, request) {
+  return CONVERTER.fromORTB({ request: request.data, response: response.body }).bids;
+}
+
+function buildVideoImp(bidRequest, imp) {
+  const videoAdUnitParams = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}`, {});
+  const videoBidderParams = utils.deepAccess(bidRequest, `params.${VIDEO}`, {});
+
+  const videoParams = { ...videoAdUnitParams, ...videoBidderParams };
+
+  const videoSizes = (videoAdUnitParams && videoAdUnitParams.playerSize) || [];
+
+  if (videoSizes && videoSizes.length > 0) {
+    utils.deepSetValue(imp, 'video.w', videoSizes[0][0]);
+    utils.deepSetValue(imp, 'video.h', videoSizes[0][1]);
+  }
+
+  VIDEO_ORTB_PARAMS.forEach((param) => {
+    if (videoParams.hasOwnProperty(param)) {
+      utils.deepSetValue(imp, `video.${param}`, videoParams[param]);
+    }
+  });
+
+  if (imp.video && videoParams?.context === 'outstream') {
+    imp.video.placement = imp.video.placement || 4;
+  }
+
+  return { ...imp };
+}
+
+function buildBannerImp(bidRequest, imp) {
+  const bannerAdUnitParams = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}`, {});
+  const bannerBidderParams = utils.deepAccess(bidRequest, `params.${BANNER}`, {});
+
+  const bannerParams = { ...bannerAdUnitParams, ...bannerBidderParams };
+
+  let sizes = bidRequest.mediaTypes.banner.sizes;
+
+  if (sizes) {
+    utils.deepSetValue(imp, 'banner.w', sizes[0][0]);
+    utils.deepSetValue(imp, 'banner.h', sizes[0][1]);
+  }
+
+  BANNER_ORTB_PARAMS.forEach((param) => {
+    if (bannerParams.hasOwnProperty(param)) {
+      utils.deepSetValue(imp, `banner.${param}`, bannerParams[param]);
+    }
+  });
+
+  return { ...imp };
+}
+
+function createRequest(bidRequests, bidderRequest, mediaType) {
+  const data = CONVERTER.toORTB({ bidRequests, bidderRequest, context: { mediaType } })
+
+  const bid = bidRequests.find((b) => b.params.placementId)
+  if (!data.site) data.site = {}
+  data.site.ext = { placementId: bid.params.placementId }
+
+  if (bidderRequest.gdprConsent) {
+    if (!data.user) data.user = {};
+    if (!data.user.ext) data.user.ext = {};
+    if (!data.regs) data.regs = {};
+    if (!data.regs.ext) data.regs.ext = {};
+    data.user.ext.consent = bidderRequest.gdprConsent.consentString;
+    data.regs.ext.gdpr = bidderRequest.gdprConsent.gdprApplies ? 1 : 0;
+  }
+
+  if (bid.params.bcat) data.bcat = bid.params.bcat;
+  if (bid.params.badv) data.badv = bid.params.badv;
+  if (bid.params.bapp) data.bapp = bid.params.bapp;
+
+  return {
+    method: 'POST',
+    url: ENDPOINT,
+    data: data,
+    options: { contentType: 'application/json;charset=UTF-8', withCredentials: false }
+  }
+}
+
+function isVideoBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.video');
+}
+
+function isBannerBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.banner') || !isVideoBid(bid);
+}