tor-browser

google-ima.js (13793B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/**
* Bug 1713690 - Shim Google Interactive Media Ads ima3.js
*
* Many sites use ima3.js for ad bidding and placement, often in conjunction
* with Google Publisher Tags, Prebid.js and/or other scripts. This shim
* provides a stubbed-out version of the API which helps work around related
* site breakage, such as black bxoes where videos ought to be placed.
*/

if (!window.google?.ima?.VERSION) {
 const VERSION = "3.517.2";

 const CheckCanAutoplay = (function () {
   // Sourced from: https://searchfox.org/mozilla-central/source/dom/media/gtest/negative_duration.mp4
   const TEST_VIDEO = new Blob(
     [
       new Uint32Array([
         469762048, 1887007846, 1752392036, 0, 913273705, 1717987696,
         828601953, -1878917120, 1987014509, 1811939328, 1684567661, 0, 0, 0,
         -402456576, 0, 256, 1, 0, 0, 256, 0, 0, 0, 256, 0, 0, 0, 64, 0, 0, 0,
         0, 0, 0, 33554432, -201261056, 1801548404, 1744830464, 1684564852,
         251658241, 0, 0, 0, 0, 16777216, 0, -1, -1, 0, 0, 0, 0, 256, 0, 0, 0,
         256, 0, 0, 0, 64, 5, 53250, -2080309248, 1634296941, 738197504,
         1684563053, 1, 0, 0, 0, 0, -2137614336, -1, -1, 50261, 754974720,
         1919706216, 0, 0, 1701079414, 0, 0, 0, 1701079382, 1851869295,
         1919249508, 16777216, 1852402979, 102, 1752004116, 100, 1, 0, 0,
         1852400676, 102, 1701995548, 102, 0, 1, 1819440396, 32, 1, 1651799011,
         108, 1937011607, 100, 0, 1, 1668702599, 49, 0, 1, 0, 0, 0, 33555712,
         4718800, 4718592, 0, 65536, 0, 0, 0, 0, 0, 0, 0, 0, 16776984,
         1630601216, 21193590, -14745500, 1729626337, -1407254428, 89161945,
         1049019, 9453056, -251611125, 27269507, -379058688, -1329024392,
         268435456, 1937011827, 0, 0, 268435456, 1668510835, 0, 0, 335544320,
         2054386803, 0, 0, 0, 268435456, 1868788851, 0, 0, 671088640,
         2019915373, 536870912, 2019914356, 0, 16777216, 16777216, 0, 0, 0,
       ]),
     ],
     { type: "video/mp4" }
   );

   let testVideo = undefined;

   return function () {
     if (!testVideo) {
       testVideo = document.createElement("video");
       testVideo.style =
         "position:absolute; width:0; height:0; left:0; right:0; z-index:-1; border:0";
       testVideo.setAttribute("muted", "muted");
       testVideo.setAttribute("playsinline", "playsinline");
       testVideo.src = URL.createObjectURL(TEST_VIDEO);
       document.body.appendChild(testVideo);
     }
     return testVideo.play();
   };
 })();

 let ima = {};

 class AdDisplayContainer {
   destroy() {}
   initialize() {}
 }

 class ImaSdkSettings {
   #c = true;
   #f = {};
   #i = false;
   #l = "";
   #p = "";
   #r = 0;
   #t = "";
   #v = "";
   getCompanionBackfill() {}
   getDisableCustomPlaybackForIOS10Plus() {
     return this.#i;
   }
   getFeatureFlags() {
     return this.#f;
   }
   getLocale() {
     return this.#l;
   }
   getNumRedirects() {
     return this.#r;
   }
   getPlayerType() {
     return this.#t;
   }
   getPlayerVersion() {
     return this.#v;
   }
   getPpid() {
     return this.#p;
   }
   isCookiesEnabled() {
     return this.#c;
   }
   setAutoPlayAdBreaks() {}
   setCompanionBackfill() {}
   setCookiesEnabled(c) {
     this.#c = !!c;
   }
   setDisableCustomPlaybackForIOS10Plus(i) {
     this.#i = !!i;
   }
   setFeatureFlags(f) {
     this.#f = f;
   }
   setLocale(l) {
     this.#l = l;
   }
   setNumRedirects(r) {
     this.#r = r;
   }
   setPlayerType(t) {
     this.#t = t;
   }
   setPlayerVersion(v) {
     this.#v = v;
   }
   setPpid(p) {
     this.#p = p;
   }
   setSessionId(_s) {}
   setVpaidAllowed(_a) {}
   setVpaidMode(_m) {}
 }
 ImaSdkSettings.CompanionBackfillMode = {
   ALWAYS: "always",
   ON_MASTER_AD: "on_master_ad",
 };
 ImaSdkSettings.VpaidMode = {
   DISABLED: 0,
   ENABLED: 1,
   INSECURE: 2,
 };

 class EventHandler {
   #listeners = new Map();

   _dispatch(e) {
     const listeners = this.#listeners.get(e.type) || [];
     for (const listener of Array.from(listeners)) {
       try {
         listener(e);
       } catch (r) {
         console.error(r);
       }
     }
   }

   addEventListener(t, c) {
     if (!this.#listeners.has(t)) {
       this.#listeners.set(t, new Set());
     }
     this.#listeners.get(t).add(c);
   }

   removeEventListener(t, c) {
     this.#listeners.get(t)?.delete(c);
   }
 }

 class AdsLoader extends EventHandler {
   #settings = new ImaSdkSettings();
   contentComplete() {}
   destroy() {}
   getSettings() {
     return this.#settings;
   }
   getVersion() {
     return VERSION;
   }
   requestAds(_r, _c) {
     // If autoplay is disabled and the page is trying to autoplay a tracking
     // ad, then IMA fails with an error, and the page is expected to request
     // ads again later when the user clicks to play.
     CheckCanAutoplay().then(
       () => {
         const { ADS_MANAGER_LOADED } = AdsManagerLoadedEvent.Type;
         this._dispatch(new ima.AdsManagerLoadedEvent(ADS_MANAGER_LOADED));
       },
       () => {
         const e = new ima.AdError(
           "adPlayError",
           1205,
           1205,
           "The browser prevented playback initiated without user interaction."
         );
         this._dispatch(new ima.AdErrorEvent(e));
       }
     );
   }
 }

 class AdsManager extends EventHandler {
   #volume = 1;
   collapse() {}
   configureAdsManager() {}
   destroy() {}
   discardAdBreak() {}
   expand() {}
   focus() {}
   getAdSkippableState() {
     return false;
   }
   getCuePoints() {
     return [0];
   }
   getCurrentAd() {
     return currentAd;
   }
   getCurrentAdCuePoints() {
     return [];
   }
   getRemainingTime() {
     return 0;
   }
   getVolume() {
     return this.#volume;
   }
   init(_w, _h, _m, _e) {}
   isCustomClickTrackingUsed() {
     return false;
   }
   isCustomPlaybackUsed() {
     return false;
   }
   pause() {}
   requestNextAdBreak() {}
   resize(_w, _h, _m) {}
   resume() {}
   setVolume(v) {
     this.#volume = v;
   }
   skip() {}
   start() {
     requestAnimationFrame(() => {
       for (const type of [
         AdEvent.Type.LOADED,
         AdEvent.Type.STARTED,
         AdEvent.Type.CONTENT_RESUME_REQUESTED,
         AdEvent.Type.AD_BUFFERING,
         AdEvent.Type.FIRST_QUARTILE,
         AdEvent.Type.MIDPOINT,
         AdEvent.Type.THIRD_QUARTILE,
         AdEvent.Type.COMPLETE,
         AdEvent.Type.ALL_ADS_COMPLETED,
       ]) {
         try {
           this._dispatch(new ima.AdEvent(type));
         } catch (e) {
           console.error(e);
         }
       }
     });
   }
   stop() {}
   updateAdsRenderingSettings(_s) {}
 }

 class AdsRenderingSettings {}

 class AdsRequest {
   setAdWillAutoPlay() {}
   setAdWillPlayMuted() {}
   setContinuousPlayback() {}
 }

 class AdPodInfo {
   getAdPosition() {
     return 1;
   }
   getIsBumper() {
     return false;
   }
   getMaxDuration() {
     return -1;
   }
   getPodIndex() {
     return 1;
   }
   getTimeOffset() {
     return 0;
   }
   getTotalAds() {
     return 1;
   }
 }

 class Ad {
   _pi = new AdPodInfo();
   getAdId() {
     return "";
   }
   getAdPodInfo() {
     return this._pi;
   }
   getAdSystem() {
     return "";
   }
   getAdvertiserName() {
     return "";
   }
   getApiFramework() {
     return null;
   }
   getCompanionAds() {
     return [];
   }
   getContentType() {
     return "";
   }
   getCreativeAdId() {
     return "";
   }
   getCreativeId() {
     return "";
   }
   getDealId() {
     return "";
   }
   getDescription() {
     return "";
   }
   getDuration() {
     return 8.5;
   }
   getHeight() {
     return 0;
   }
   getMediaUrl() {
     return null;
   }
   getMinSuggestedDuration() {
     return -2;
   }
   getSkipTimeOffset() {
     return -1;
   }
   getSurveyUrl() {
     return null;
   }
   getTitle() {
     return "";
   }
   getTraffickingParameters() {
     return {};
   }
   getTraffickingParametersString() {
     return "";
   }
   getUiElements() {
     return [""];
   }
   getUniversalAdIdRegistry() {
     return "unknown";
   }
   getUniversalAdIds() {
     return [""];
   }
   getUniversalAdIdValue() {
     return "unknown";
   }
   getVastMediaBitrate() {
     return 0;
   }
   getVastMediaHeight() {
     return 0;
   }
   getVastMediaWidth() {
     return 0;
   }
   getWidth() {
     return 0;
   }
   getWrapperAdIds() {
     return [""];
   }
   getWrapperAdSystems() {
     return [""];
   }
   getWrapperCreativeIds() {
     return [""];
   }
   isLinear() {
     return true;
   }
   isSkippable() {
     return true;
   }
 }

 class CompanionAd {
   getAdSlotId() {
     return "";
   }
   getContent() {
     return "";
   }
   getContentType() {
     return "";
   }
   getHeight() {
     return 1;
   }
   getWidth() {
     return 1;
   }
 }

 class AdError {
   #errorCode = -1;
   #message = "";
   #type = "";
   #vastErrorCode = -1;
   constructor(type, code, vast, message) {
     this.#errorCode = code;
     this.#message = message;
     this.#type = type;
     this.#vastErrorCode = vast;
   }
   getErrorCode() {
     return this.#errorCode;
   }
   getInnerError() {}
   getMessage() {
     return this.#message;
   }
   getType() {
     return this.#type;
   }
   getVastErrorCode() {
     return this.#vastErrorCode;
   }
   toString() {
     return `AdError ${this.#errorCode}: ${this.#message}`;
   }
 }
 AdError.ErrorCode = {};
 AdError.Type = {};

 const isEngadget = () => {
   try {
     for (const ctx of Object.values(window.vidible._getContexts())) {
       if (ctx.getPlayer()?.div?.innerHTML.includes("www.engadget.com")) {
         return true;
       }
     }
   } catch (_) {}
   return false;
 };

 const currentAd = isEngadget() ? undefined : new Ad();

 class AdEvent {
   constructor(type) {
     this.type = type;
   }
   getAd() {
     return currentAd;
   }
   getAdData() {
     return {};
   }
 }
 AdEvent.Type = {
   AD_BREAK_READY: "adBreakReady",
   AD_BUFFERING: "adBuffering",
   AD_CAN_PLAY: "adCanPlay",
   AD_METADATA: "adMetadata",
   AD_PROGRESS: "adProgress",
   ALL_ADS_COMPLETED: "allAdsCompleted",
   CLICK: "click",
   COMPLETE: "complete",
   CONTENT_PAUSE_REQUESTED: "contentPauseRequested",
   CONTENT_RESUME_REQUESTED: "contentResumeRequested",
   DURATION_CHANGE: "durationChange",
   EXPANDED_CHANGED: "expandedChanged",
   FIRST_QUARTILE: "firstQuartile",
   IMPRESSION: "impression",
   INTERACTION: "interaction",
   LINEAR_CHANGE: "linearChange",
   LINEAR_CHANGED: "linearChanged",
   LOADED: "loaded",
   LOG: "log",
   MIDPOINT: "midpoint",
   PAUSED: "pause",
   RESUMED: "resume",
   SKIPPABLE_STATE_CHANGED: "skippableStateChanged",
   SKIPPED: "skip",
   STARTED: "start",
   THIRD_QUARTILE: "thirdQuartile",
   USER_CLOSE: "userClose",
   VIDEO_CLICKED: "videoClicked",
   VIDEO_ICON_CLICKED: "videoIconClicked",
   VIEWABLE_IMPRESSION: "viewable_impression",
   VOLUME_CHANGED: "volumeChange",
   VOLUME_MUTED: "mute",
 };

 class AdErrorEvent {
   type = "adError";
   #error = "";
   constructor(error) {
     this.#error = error;
   }
   getError() {
     return this.#error;
   }
   getUserRequestContext() {
     return {};
   }
 }
 AdErrorEvent.Type = {
   AD_ERROR: "adError",
 };

 const manager = new AdsManager();

 class AdsManagerLoadedEvent {
   constructor(type) {
     this.type = type;
   }
   getAdsManager() {
     return manager;
   }
   getUserRequestContext() {
     return {};
   }
 }
 AdsManagerLoadedEvent.Type = {
   ADS_MANAGER_LOADED: "adsManagerLoaded",
 };

 class CustomContentLoadedEvent {}
 CustomContentLoadedEvent.Type = {
   CUSTOM_CONTENT_LOADED: "deprecated-event",
 };

 class CompanionAdSelectionSettings {}
 CompanionAdSelectionSettings.CreativeType = {
   ALL: "All",
   FLASH: "Flash",
   IMAGE: "Image",
 };
 CompanionAdSelectionSettings.ResourceType = {
   ALL: "All",
   HTML: "Html",
   IFRAME: "IFrame",
   STATIC: "Static",
 };
 CompanionAdSelectionSettings.SizeCriteria = {
   IGNORE: "IgnoreSize",
   SELECT_EXACT_MATCH: "SelectExactMatch",
   SELECT_NEAR_MATCH: "SelectNearMatch",
 };

 class AdCuePoints {
   getCuePoints() {
     return [];
   }
 }

 class AdProgressData {}

 class UniversalAdIdInfo {
   getAdIdRegistry() {
     return "";
   }
   getAdIsValue() {
     return "";
   }
 }

 Object.assign(ima, {
   AdCuePoints,
   AdDisplayContainer,
   AdError,
   AdErrorEvent,
   AdEvent,
   AdPodInfo,
   AdProgressData,
   AdsLoader,
   AdsManager: manager,
   AdsManagerLoadedEvent,
   AdsRenderingSettings,
   AdsRequest,
   CompanionAd,
   CompanionAdSelectionSettings,
   CustomContentLoadedEvent,
   gptProxyInstance: {},
   ImaSdkSettings,
   OmidAccessMode: {
     DOMAIN: "domain",
     FULL: "full",
     LIMITED: "limited",
   },
   settings: new ImaSdkSettings(),
   UiElements: {
     AD_ATTRIBUTION: "adAttribution",
     COUNTDOWN: "countdown",
   },
   UniversalAdIdInfo,
   VERSION,
   ViewMode: {
     FULLSCREEN: "fullscreen",
     NORMAL: "normal",
   },
 });

 if (!window.google) {
   window.google = {};
 }

 window.google.ima = ima;
}