@highfivve/ad-tag 5.9.3 → 5.10.1

package/lib/ads/adService.js

@@ -56,6 +56,7 @@ export class AdService {
         this.window = window;
         this.adPipelineConfig = adPipelineConfig;
         this.requestAdsCalls = 0;
+        this.globalAuctionContext = createGlobalAuctionContext(this.window, getDefaultLogger(), this.eventService);
         this.adPipeline = new AdPipeline({
             init: [() => Promise.reject('AdPipeline not initialized yet')],
             configure: [],
@@ -63,7 +64,7 @@ export class AdService {
             prepareRequestAds: [],
             requestBids: [],
             requestAds: () => Promise.resolve()
-        }, getDefaultLogger(), this.window, createGlobalAuctionContext(this.window, getDefaultLogger(), this.eventService));
+        }, getDefaultLogger(), this.window, this.globalAuctionContext);
         this.initialize = (config, runtimeConfig, isLabelConditionMet = () => false) => {
             const env = AdService.getEnvironment(runtimeConfig);
             const adServer = config.adServer || 'gam';
@@ -100,7 +101,8 @@ export class AdService {
                 prepareRequestAds.push(a9ClearTargetingStep());
                 requestBids.push(a9RequestBids(config.a9));
             }
-            const globalAuctionContext = createGlobalAuctionContext(this.window, this.logger, this.eventService, config.globalAuctionContext, isLabelConditionMet);
+            const globalAuctionContext = createGlobalAuctionContext(this.window, this.logger, this.eventService, config.globalAuctionContext, isLabelConditionMet, this.assetService);
+            this.globalAuctionContext = globalAuctionContext;
             configure.push(globalAuctionContext.configureStep());
             init.push(...runtimeConfig.adPipelineConfig.initSteps);
             configure.push(...runtimeConfig.adPipelineConfig.configureSteps);
@@ -191,6 +193,9 @@ export class AdService {
                 return Promise.reject(e);
             }
         };
+        this.rewardedAd = () => {
+            return this.globalAuctionContext.rewardedAd();
+        };
         this.getAdPipeline = () => {
             return this.adPipeline;
         };
@@ -199,7 +204,8 @@ export class AdService {
         };
         this.logger = new ProxyLogger(getDefaultLogger());
         if (adPipelineConfig) {
-            this.adPipeline = new AdPipeline(adPipelineConfig, this.logger, window, createGlobalAuctionContext(window, this.logger, this.eventService));
+            this.globalAuctionContext = createGlobalAuctionContext(window, this.logger, this.eventService);
+            this.adPipeline = new AdPipeline(adPipelineConfig, this.logger, window, this.globalAuctionContext);
         }
     }
     refreshAdSlots(domIds, config, runtimeConfig, options) {

package/lib/ads/auctions/rewardedAdContext.js

@@ -0,0 +1,250 @@
+import { resolveAdUnitPath } from 'ad-tag/ads/adUnitPath';
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+const defaultRewardPayload = { amount: 1, type: 'reward' };
+export const createRewardedAdContext = (config, window__, logger, assetLoaderService) => {
+    let gamAdUnitPath = config.gam?.adUnitPath;
+    let inFlight = false;
+    let welectBundle;
+    const loadWelectSdk = (welectConfig) => {
+        const preloadedApi = window__.Welect;
+        if (preloadedApi) {
+            return Promise.resolve(preloadedApi);
+        }
+        welectBundle =
+            welectBundle ??
+                assetLoaderService
+                    .loadScript({
+                    name: 'welect',
+                    assetUrl: welectConfig.bundleUrl,
+                    loadMethod: AssetLoadMethod.TAG
+                })
+                    .then(() => {
+                    const welectApi = window__.Welect;
+                    return welectApi
+                        ? Promise.resolve(welectApi)
+                        : Promise.reject(new Error('welect bundle loaded, but window.Welect is not defined'));
+                })
+                    .catch(error => {
+                    welectBundle = undefined;
+                    return Promise.reject(error);
+                });
+        return welectBundle;
+    };
+    const attemptGam = (gamConfig) => new Promise(resolve => {
+        window__.googletag.cmd.push(() => {
+            const googletagRef = window__.googletag;
+            const pubads = googletagRef.pubads();
+            const adUnitPath = gamAdUnitPath ?? gamConfig.adUnitPath;
+            const slot = googletagRef.defineOutOfPageSlot(adUnitPath, googletagRef.enums.OutOfPageFormat.REWARDED);
+            if (!slot) {
+                logger.error('rewardedAd', `failed to define rewarded slot for ${adUnitPath}`);
+                resolve({ outcome: 'no-fill' });
+                return;
+            }
+            let settled = false;
+            let timeoutId;
+            const destroySlot = () => googletagRef.destroySlots([slot]);
+            const removeListeners = () => {
+                pubads.removeEventListener('slotRenderEnded', onSlotRenderEnded);
+                pubads.removeEventListener('rewardedSlotReady', onRewardedSlotReady);
+                pubads.removeEventListener('rewardedSlotGranted', onRewardedSlotGranted);
+                pubads.removeEventListener('rewardedSlotClosed', onRewardedSlotClosed);
+            };
+            const settle = (attempt) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                window__.clearTimeout(timeoutId);
+                resolve(attempt);
+            };
+            const onSlotRenderEnded = (event) => {
+                if (event.slot !== slot) {
+                    return;
+                }
+                if (event.isEmpty) {
+                    logger.debug('rewardedAd', 'gam attempt has no fill');
+                    removeListeners();
+                    destroySlot();
+                    settle({ outcome: 'no-fill' });
+                }
+            };
+            const onRewardedSlotReady = (event) => {
+                if (event.slot !== slot) {
+                    return;
+                }
+                window__.clearTimeout(timeoutId);
+                logger.debug('rewardedAd', 'gam rewarded slot ready');
+                event.makeRewardedVisible();
+            };
+            const onRewardedSlotGranted = (event) => {
+                if (event.slot !== slot) {
+                    return;
+                }
+                const payload = event.payload ?? defaultRewardPayload;
+                logger.debug('rewardedAd', 'gam granted reward', payload);
+                settle({ outcome: 'granted', payload });
+            };
+            const onRewardedSlotClosed = (event) => {
+                if (event.slot !== slot) {
+                    return;
+                }
+                logger.debug('rewardedAd', 'gam rewarded slot closed');
+                removeListeners();
+                destroySlot();
+                settle({ outcome: 'canceled' });
+            };
+            pubads.addEventListener('slotRenderEnded', onSlotRenderEnded);
+            pubads.addEventListener('rewardedSlotReady', onRewardedSlotReady);
+            pubads.addEventListener('rewardedSlotGranted', onRewardedSlotGranted);
+            pubads.addEventListener('rewardedSlotClosed', onRewardedSlotClosed);
+            timeoutId = window__.setTimeout(() => {
+                logger.debug('rewardedAd', `gam attempt timed out after ${config.timeoutMs}ms without a rewardedSlotReady event`);
+                removeListeners();
+                destroySlot();
+                settle({ outcome: 'no-fill' });
+            }, config.timeoutMs);
+            slot.addService(pubads);
+            googletagRef.display(slot);
+        });
+    });
+    const hasValidWelectToken = (welectConfig) => new Promise(resolve => {
+        let settled = false;
+        const settle = (validToken) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            window__.clearTimeout(timeoutId);
+            resolve(validToken);
+        };
+        const timeoutId = window__.setTimeout(() => {
+            logger.debug('rewardedAd', `welect token preflight timed out after ${config.timeoutMs}ms`);
+            settle(false);
+        }, config.timeoutMs);
+        loadWelectSdk(welectConfig)
+            .then(welectApi => {
+            const checkToken = welectApi.checkToken;
+            if (!checkToken) {
+                logger.error('rewardedAd', 'welect bundle does not provide checkToken');
+                settle(false);
+                return;
+            }
+            checkToken({
+                onValid: () => settle(true),
+                onInvalid: () => settle(false)
+            });
+        })
+            .catch(error => {
+            logger.error('rewardedAd', 'welect token preflight failed', error);
+            settle(false);
+        });
+    });
+    const attemptWelect = (welectConfig) => new Promise(resolve => {
+        let settled = false;
+        const settle = (attempt) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            window__.clearTimeout(timeoutId);
+            resolve(attempt);
+        };
+        const timeoutId = window__.setTimeout(() => {
+            logger.debug('rewardedAd', `welect attempt timed out after ${config.timeoutMs}ms without an availability result`);
+            settle({ outcome: 'no-fill' });
+        }, config.timeoutMs);
+        loadWelectSdk(welectConfig)
+            .then(welectApi => {
+            if (settled) {
+                return;
+            }
+            const checkAvailability = welectApi.checkAvailability;
+            const runSession = welectApi.runSession;
+            if (!checkAvailability || !runSession) {
+                logger.error('rewardedAd', 'welect bundle does not provide checkAvailability/runSession');
+                settle({ outcome: 'no-fill' });
+                return;
+            }
+            checkAvailability({
+                onAvailable: () => {
+                    if (settled) {
+                        return;
+                    }
+                    window__.clearTimeout(timeoutId);
+                    logger.debug('rewardedAd', 'welect session available');
+                    runSession({
+                        onSuccess: () => {
+                            logger.debug('rewardedAd', 'welect granted reward', welectConfig.payload);
+                            settle({ outcome: 'granted', payload: welectConfig.payload });
+                        },
+                        onAbort: () => {
+                            logger.debug('rewardedAd', 'welect session aborted');
+                            settle({ outcome: 'canceled' });
+                        }
+                    });
+                },
+                onUnavailable: () => {
+                    logger.debug('rewardedAd', 'welect attempt has no fill');
+                    settle({ outcome: 'no-fill' });
+                }
+            });
+        })
+            .catch(error => {
+            logger.error('rewardedAd', 'failed to load the welect bundle', error);
+            settle({ outcome: 'no-fill' });
+        });
+    });
+    const attemptChannel = (channel) => {
+        switch (channel) {
+            case 'gam':
+                return config.gam ? attemptGam(config.gam) : Promise.resolve({ outcome: 'no-fill' });
+            case 'welect':
+                return config.welect
+                    ? attemptWelect(config.welect)
+                    : Promise.resolve({ outcome: 'no-fill' });
+        }
+    };
+    const requestRewardedAd = async () => {
+        if (inFlight) {
+            return { state: 'error', reason: 'already-in-progress' };
+        }
+        if (!config.enabled || config.priority.length === 0) {
+            return { state: 'empty' };
+        }
+        inFlight = true;
+        try {
+            const welectConfig = config.welect;
+            if (welectConfig &&
+                config.priority.includes('welect') &&
+                welectConfig.checkToken !== false &&
+                (await hasValidWelectToken(welectConfig))) {
+                logger.debug('rewardedAd', 'valid welect token - granting without an ad');
+                return { state: 'granted', channel: 'welect', payload: welectConfig.payload };
+            }
+            for (const channel of config.priority) {
+                const attempt = await attemptChannel(channel);
+                switch (attempt.outcome) {
+                    case 'granted':
+                        return { state: 'granted', channel, payload: attempt.payload };
+                    case 'canceled':
+                        return { state: 'canceled', channel };
+                    case 'no-fill':
+                        break;
+                }
+            }
+            return { state: 'empty' };
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    return {
+        requestRewardedAd,
+        updateAdUnitPaths: (variables) => {
+            if (config.gam) {
+                gamAdUnitPath = resolveAdUnitPath(config.gam.adUnitPath, variables);
+            }
+        }
+    };
+};

package/lib/ads/globalAuctionContext.js

@@ -4,9 +4,11 @@ import { createFrequencyCapping } from './auctions/frequencyCapping';
 import { createPreviousBidCpms } from './auctions/previousBidCpms';
 import { mkConfigureStep } from './adPipeline';
 import { createInterstitialContext } from 'ad-tag/ads/auctions/interstitialContext';
+import { createRewardedAdContext } from 'ad-tag/ads/auctions/rewardedAdContext';
 import { createTrackWinningBidder } from 'ad-tag/ads/auctions/trackWinningBidder';
 import { resolveOverridableConfig } from 'ad-tag/ads/configOverrides';
-export const createGlobalAuctionContext = (window, logger, eventService, config = {}, isLabelConditionMet = () => false) => {
+import { createAssetLoaderService } from 'ad-tag/util/assetLoaderService';
+export const createGlobalAuctionContext = (window, logger, eventService, config = {}, isLabelConditionMet = () => false, assetLoaderService = createAssetLoaderService(window)) => {
     const resolveFeature = (base, feature) => {
         if (!base) {
             return undefined;
@@ -23,6 +25,7 @@ export const createGlobalAuctionContext = (window, logger, eventService, config
     const frequencyCapConfig = resolveFeature(config.frequencyCap, 'frequencyCap');
     const previousBidCpmsConfig = resolveFeature(config.previousBidCpms, 'previousBidCpms');
     const interstitialConfig = resolveFeature(config.interstitial, 'interstitial');
+    const rewardedAdConfig = resolveFeature(config.rewardedAd, 'rewardedAd');
     const trackWinningBidder = trackWinningBidderConfig?.enabled
         ? createTrackWinningBidder()
         : undefined;
@@ -39,6 +42,9 @@ export const createGlobalAuctionContext = (window, logger, eventService, config
     const interstitial = interstitialConfig?.enabled
         ? createInterstitialContext(interstitialConfig, window, window.Date.now, logger)
         : undefined;
+    const rewardedAd = rewardedAdConfig?.enabled
+        ? createRewardedAdContext(rewardedAdConfig, window, logger, assetLoaderService)
+        : undefined;
     window.pbjs = window.pbjs || { que: [] };
     window.googletag = window.googletag || {};
     window.googletag.cmd = window.googletag.cmd || [];
@@ -99,6 +105,7 @@ export const createGlobalAuctionContext = (window, logger, eventService, config
     const configureStep = mkConfigureStep('GlobalAuctionContext', context => {
         frequencyCapping?.updateAdUnitPaths(context.adUnitPathVariables__);
         interstitial?.updateAdUnitPaths(context.adUnitPathVariables__);
+        rewardedAd?.updateAdUnitPaths(context.adUnitPathVariables__);
         return Promise.resolve();
     });
     return {
@@ -121,6 +128,9 @@ export const createGlobalAuctionContext = (window, logger, eventService, config
         interstitialChannel: () => {
             return interstitial?.interstitialChannel();
         },
+        rewardedAd: () => {
+            return rewardedAd?.requestRewardedAd() ?? Promise.resolve({ state: 'empty' });
+        },
         hasMinimumRequestAds(minRequestAds) {
             if (!frequencyCapping) {
                 return true;

package/lib/ads/modules/blocklist-url/index.js

@@ -98,6 +98,7 @@ export const createBlocklistedUrls = () => {
                         const result = entry.reverseMatch === true ? !matcher(entry) : matcher(entry);
                         if (result) {
                             ctx.labelConfigService__.addLabel(entry.label);
+                            ctx.logger__.debug('Blocklist URLs', `Added label ${entry.label} for url ${ctx.window__.location.href}`);
                         }
                     });
                 })

package/lib/ads/modules/generic-skin/index.js

@@ -16,32 +16,6 @@ export const createSkin = () => {
     let skinModuleConfig = null;
     let bidsBackHandler = [];
     const config__ = () => skinModuleConfig;
-    const getSkinBids = (config, bidResponses) => {
-        const skinBidResponse = bidResponses[config.skinAdSlotDomId];
-        const isSkinBid = (bid) => {
-            const oneFilterApplied = config.formatFilter.some(filter => {
-                switch (filter.bidder) {
-                    case '*':
-                        return true;
-                    case 'gumgum':
-                        return (bid.bidder === prebidjs.GumGum &&
-                            (filter.auid === undefined ||
-                                (typeof bid.ad !== 'string' && bid.ad.auid === filter.auid)));
-                    default:
-                        return bid.bidder === filter.bidder;
-                }
-            });
-            return bid.cpm > 0 && oneFilterApplied;
-        };
-        return skinBidResponse
-            ?
-                skinBidResponse.bids.filter(isSkinBid).sort((bid1, bid2) => bid2.cpm - bid1.cpm)
-            : [];
-    };
-    const getHighestSkinBidCpm = (config, bidResponses) => {
-        const skinBids = getSkinBids(config, bidResponses);
-        return skinBids.length > 0 ? skinBids[0].cpm : null;
-    };
     const getConfigEffect = (config, bidResponses, log) => {
         const skinBidResponse = bidResponses[config.skinAdSlotDomId];
         const isSkinBid = (bid) => {
@@ -80,29 +54,12 @@ export const createSkin = () => {
         }
         return skinBids.length > 0 ? "BlockOtherSlots" : "NoBlocking";
     };
-    const selectConfig = (skinModuleConfig, bidResponses, log) => {
-        const configEvaluations = skinModuleConfig.configs.map(config => ({
-            skinConfig: config,
-            configEffect: getConfigEffect(config, bidResponses, log),
-            highestSkinCpm: getHighestSkinBidCpm(config, bidResponses)
-        }));
-        const matchingConfigs = configEvaluations.filter(({ configEffect }) => configEffect !== "NoBlocking");
-        const compareWithOtherSkinsConfigs = matchingConfigs.filter(({ skinConfig }) => skinConfig.compareWithOtherSkins);
-        if (compareWithOtherSkinsConfigs.length > 1) {
-            return compareWithOtherSkinsConfigs.reduce((selectedConfig, currentConfig) => {
-                if (selectedConfig.highestSkinCpm === null ||
-                    (currentConfig.highestSkinCpm !== null &&
-                        currentConfig.highestSkinCpm > selectedConfig.highestSkinCpm)) {
-                    return currentConfig;
-                }
-                return selectedConfig;
-            });
-        }
-        const fallbackConfig = matchingConfigs[0];
-        return fallbackConfig
-            ? { skinConfig: fallbackConfig.skinConfig, configEffect: fallbackConfig.configEffect }
-            : undefined;
-    };
+    const selectConfig = (skinModuleConfig, bidResponses, log) => skinModuleConfig.configs
+        .map(config => ({
+        skinConfig: config,
+        configEffect: getConfigEffect(config, bidResponses, log)
+    }))
+        .find(({ configEffect }) => configEffect !== "NoBlocking");
     const destroyAdSlot = (slotDefinitions, gWindow) => (adSlotDomId) => {
         const adSlots = slotDefinitions
             .map(slot => slot.adSlot)

package/lib/ads/moli.js

@@ -265,13 +265,13 @@ export const createMoliTag = (window) => {
                         ...state.config?.modules,
                         [configKey]: effectiveConfig
                     };
-                    return { module, resolvedModulesConfig };
+                    return { module, resolvedModulesConfig, effectiveConfig };
                 })
                     .filter((entry) => entry !== null)
-                    .forEach(({ module, resolvedModulesConfig }) => {
+                    .forEach(({ module, resolvedModulesConfig, effectiveConfig }) => {
                     try {
                         module.configure__(resolvedModulesConfig);
-                        getLogger(state.runtimeConfig, window).debug('MoliGlobal', `configure ${module.moduleType} module ${module.name}`, module.config__());
+                        getLogger(state.runtimeConfig, window).debug('MoliGlobal', `configure ${module.moduleType} module ${module.name}`, `module is ${effectiveConfig.enabled ? 'enabled' : 'disabled'}`, module.config__());
                         state.runtimeConfig.adPipelineConfig.initSteps.push(...module.initSteps__());
                         state.runtimeConfig.adPipelineConfig.configureSteps.push(...module.configureSteps__());
                         state.runtimeConfig.adPipelineConfig.prepareRequestAdsSteps.push(...module.prepareRequestAdsSteps__());
@@ -580,6 +580,38 @@ export const createMoliTag = (window) => {
             }
         }
     }
+    function rewardedAd() {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured':
+            case 'requestAds':
+            case 'spa-requestAds': {
+                return new Promise(resolve => {
+                    let queued = true;
+                    state.runtimeConfig.hooks.afterRequestAds.push(afterState => {
+                        if (!queued) {
+                            return;
+                        }
+                        queued = false;
+                        if (afterState === 'error') {
+                            resolve({ state: 'error', reason: 'ad-tag-error' });
+                        }
+                        else {
+                            adService.rewardedAd().then(resolve);
+                        }
+                    });
+                });
+            }
+            case 'finished':
+            case 'spa-finished': {
+                return adService.rewardedAd();
+            }
+            case 'error': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `rewardedAd is not allowed in state ${state.state}`);
+                return Promise.resolve({ state: 'error', reason: 'ad-tag-error' });
+            }
+        }
+    }
     function triggerDelay() {
         window.dispatchEvent(new CustomEvent('h5v.trigger-delay'));
         return;
@@ -690,6 +722,7 @@ export const createMoliTag = (window) => {
         refreshAdSlot: refreshAdSlot,
         refreshBucket: refreshBucket,
         refreshInfiniteAdSlot: refreshInfiniteAdSlot,
+        rewardedAd: rewardedAd,
         triggerDelay: triggerDelay,
         getState: getState,
         openConsole: openConsole,

package/lib/console/components/consentConfig.js

@@ -32,8 +32,10 @@ const cmpVendors = {
 export const ConsentConfig = () => {
     const [consentState, setConsentState] = React.useState({ messages: [] });
     React.useEffect(() => {
+        let listenerId;
         if (window.__tcfapi) {
             window.__tcfapi('addEventListener', 2, event => {
+                listenerId = event.listenerId;
                 const tcModel = event.gdprApplies ? TCString.decode(event.tcString) : undefined;
                 setConsentState(prevState => ({
                     ...prevState,
@@ -59,7 +61,12 @@ export const ConsentConfig = () => {
                 messages: [errorMessage, ...prevState.messages]
             }));
         }
-    });
+        return () => {
+            if (window.__tcfapi && listenerId != null) {
+                window.__tcfapi('removeEventListener', 2, () => undefined, listenerId);
+            }
+        };
+    }, []);
     const cmpVendorTag = () => {
         if (consentState.tcModel) {
             const cmpVendor = cmpVendors[consentState.tcModel.cmpId.toString()];
@@ -97,7 +104,7 @@ export const ConsentConfig = () => {
                 React.createElement("span", { className: "inline-block min-w-36 max-w-96 pr-1 font-medium" }, "TCF Policy Version"),
                 tcModel ? (React.createElement(Tag, null, tcModel.policyVersion.toString())) : (React.createElement(Tag, { variant: "red" }, "Unknown")))));
     };
-    const isCmpFunctionAvailable = () => window.__tcfapi || typeof window.__tcfapi === 'function';
+    const isCmpFunctionAvailable = () => typeof window.__tcfapi === 'function';
     const consentData = () => {
         if (isCmpFunctionAvailable()) {
             return (React.createElement("div", null,

package/lib/console/tailwind.config.js

@@ -196,7 +196,10 @@ export default {
                     info: '#7da6d7',
                     success: '#42cbc9',
                     warning: '#e8d06a',
-                    error: '#f88383'
+                    error: '#f88383',
+                    'base-100': '#1f1f2e',
+                    'base-200': '#2d2d3d',
+                    'base-300': '#3a3a4d'
                 }
             }
         ],

package/lib/gen/packageJson.js

@@ -1,3 +1,3 @@
 export const packageJson = {
-    version: '5.9.3'
+    version: '5.10.1'
 };

package/lib/types/welect.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highfivve/ad-tag",
-  "version": "5.9.3",
+  "version": "5.10.1",
   "license": "Apache-2.0",
   "description": "An ad tag implementation called moli",
   "main": "./lib/index.js",
@@ -67,7 +67,7 @@
     "@types/core-js": "^2.5.8",
     "@types/domready": "^1.0.0",
     "@types/jsdom": "^20.0.0",
-    "@types/mocha": "8.2.2",
+    "@types/mocha": "10.0.10",
     "@types/node": "^20.10.4",
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
@@ -89,8 +89,8 @@
     "eslint-plugin-jsdoc": "^34.8.1",
     "eslint-plugin-preact": "^0.1.0",
     "jsdom": "19.0.0",
-    "mocha": "8.4.0",
-    "mocha-junit-reporter": "2.0.0",
+    "mocha": "11.7.6",
+    "mocha-junit-reporter": "2.2.1",
     "np": "^10.0.5",
     "postcss": "^8.4.47",
     "postcss-cli": "^11.0.0",