@guardian/commercial-core 0.0.0-beta-20250716121613

package/dist/esm/detect-ad-blocker.d.ts

@@ -0,0 +1,12 @@
+/**
+Detect whether or not the user has an ad blocking extension enabled.
+A few ad blockers are not detectable with this approach e.g. Safari / Adblock
+Code inspired by just-detect-adblock's:
+https://github.com/wmcmurray/just-detect-adblock/blob/master/src/helpers.js
+*/
+/**
+ * Determines whether or not the user has an ad blocking extension enabled.
+ * Note: positive results can be considered reliable while negative ones may not be.
+ * @returns Promise
+ */
+export declare function isAdBlockInUse(): Promise<boolean>;

package/dist/esm/detect-ad-blocker.js

@@ -0,0 +1,58 @@
+/**
+Detect whether or not the user has an ad blocking extension enabled.
+A few ad blockers are not detectable with this approach e.g. Safari / Adblock
+Code inspired by just-detect-adblock's:
+https://github.com/wmcmurray/just-detect-adblock/blob/master/src/helpers.js
+*/
+/*istanbul ignore file -- adElementBlocked can't be tested without patching each of the properties of
+HTMLElement.prototype that it accesses, defeating the purpose of the test! */
+let adBlockInUse = undefined;
+function adElementBlocked(ad) {
+    if (ad.offsetParent === null ||
+        ad.offsetHeight === 0 ||
+        ad.offsetLeft === 0 ||
+        ad.offsetTop === 0 ||
+        ad.offsetWidth === 0 ||
+        ad.clientHeight === 0 ||
+        ad.clientWidth === 0) {
+        return true;
+    }
+    const adStyles = window.getComputedStyle(ad);
+    if (adStyles.getPropertyValue('display') === 'none')
+        return true;
+    if (adStyles.getPropertyValue('visibility') === 'hidden')
+        return true;
+    const mozBindingProp = adStyles.getPropertyValue('-moz-binding');
+    if (mozBindingProp.includes('about:'))
+        return true;
+    return false;
+}
+/**
+ * Determines whether or not the user has an ad blocking extension enabled.
+ * Note: positive results can be considered reliable while negative ones may not be.
+ * @returns Promise
+ */
+export function isAdBlockInUse() {
+    if (adBlockInUse !== undefined) {
+        return Promise.resolve(adBlockInUse);
+    }
+    if (typeof window.getComputedStyle !== 'function') {
+        // Old browsers not supporting getComputedStyle most likely won't have adBlockers
+        adBlockInUse = false;
+        return Promise.resolve(adBlockInUse);
+    }
+    return new Promise((resolve) => {
+        window.requestAnimationFrame(() => {
+            // create a fake ad element and append it to the document
+            const ad = document.createElement('div');
+            ad.setAttribute('class', 'ad_unit pub_300x250 pub_300x250m pub_728x90 text-ad textAd text_ad text_ads text-ads text-ad-links ad-text adSense adBlock adContent adBanner');
+            ad.setAttribute('style', 'width: 1px !important; height: 1px !important; position: absolute !important; left: -10000px !important; top: -1000px !important;');
+            document.body.appendChild(ad);
+            // avoid a forced layout
+            window.requestAnimationFrame(() => {
+                // if the ad element has been hidden, an ad blocker is enabled.
+                resolve(adElementBlocked(ad));
+            });
+        });
+    });
+}

package/dist/esm/event-timer.d.ts

@@ -0,0 +1,103 @@
+import type { ConnectionType } from './types';
+declare const supportsPerformanceAPI: () => boolean;
+interface EventTimerProperties {
+    type?: ConnectionType;
+    downlink?: number;
+    effectiveType?: string;
+    adSlotsInline?: number;
+    adSlotsTotal?: number;
+    /** the height of the page / the viewport height  */
+    pageHeightVH?: number;
+    gpcSignal?: number;
+    /** distance in percentage of viewport height at which ads are lazy loaded */
+    lazyLoadMarginPercent?: number;
+    hasLabsContainer?: boolean;
+    labsUrl?: string;
+    /** Record whether we've detected an ad blocker. This is intentionally
+     * distinct from the property we pass into commercial metrics, and in the
+     * future _could_ be removed in favour of this property */
+    detectedAdBlocker?: boolean;
+    /** Record whether we've shown the adblock as message */
+    didDisplayAdBlockAsk?: boolean;
+    /** creative ID of a video interscroller for video reporting metrics */
+    videoInterscrollerCreativeId?: number | null | undefined;
+    /** percentage progress of video interscroller on page unload */
+    videoInterscrollerPercentageProgress?: number;
+}
+declare class EventTimer {
+    private _marks;
+    private _measures;
+    properties: EventTimerProperties;
+    /**
+     * Initialise the EventTimer class on page.
+     * Returns the singleton instance of the EventTimer class and binds
+     * to window.guardian.commercialTimer. If it's been previously
+     * initialised and bound it returns the original instance
+     * Note: We save to window.guardian.commercialTimer because
+     * different bundles (DCR / DCP) can use commercial, and we want
+     * all timer events saved to a single instance per-page
+     * @returns {EventTimer} Instance of EventTimer
+     */
+    static init(): EventTimer;
+    /**
+     * Just a helper method to access the singleton instance of EventTimer.
+     * Typical use case is EventTimer.get().trigger
+     */
+    static get(): EventTimer;
+    /**
+     * These are marks that are not triggered by commercial but we are interested in
+     * tracking their performance. For example, CMP-related events.
+     **/
+    private get _externalMarks();
+    /**
+     * Returns all performance marks that should be saved as commercial metrics.
+     */
+    get marks(): {
+        name: string;
+        ts: number;
+    }[];
+    /**
+     * Returns all performance measures that should be saved as commercial metrics.
+     */
+    get measures(): {
+        name: string;
+        duration: number;
+    }[];
+    private constructor();
+    /**
+     * Adds a non timer measurement
+     *
+     * @param {string} name - the property's name
+     * @param value - the property's value
+     */
+    setProperty<T extends keyof EventTimerProperties>(name: T, value: EventTimerProperties[T]): void;
+    /**
+     * Creates a new performance mark, and if the mark ends with 'End' it will
+     * create a performance measure between the start and end marks.
+     *
+     * Marks can  be triggered multiple times, but we only save the first
+     * instance of a mark, as things like ad refreshes can trigger the same mark.
+     *
+     * More info on the performance API:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure
+     *
+     * @todo more strict typing for eventName and origin
+     * @param eventName The short name applied to the mark
+     * @param origin - Either 'page' (default) or the name of the slot
+     */
+    mark(eventName: string, origin?: string): void;
+    /**
+     * Creates a performance measure given the name of the end marks.
+     * The start mark is inferred from the end mark.
+     *
+     * @param endMark - The name of the mark that ends the measure
+     **/
+    private measure;
+}
+declare const _: {
+    slotMarks: readonly ["slotReady", "adRenderStart", "prebidStart", "adOnPage", "viewable"];
+    slotMeasures: readonly ["adRender", "defineSlot", "prepareSlot", "prebid", "fetchAd"];
+    trackedSlots: readonly ["top-above-nav", "inline1", "inline2", "fronts-banner-1", "fronts-banner-2"];
+};
+export { EventTimer, _, supportsPerformanceAPI };

package/dist/esm/event-timer.js

@@ -0,0 +1,199 @@
+import { log } from '@guardian/libs';
+const supportsPerformanceAPI = () => typeof window !== 'undefined' &&
+    typeof window.performance !== 'undefined' &&
+    typeof window.performance.mark === 'function';
+// Events will be logged using the performance API for all slots, but only these slots will be tracked as commercial metrics and sent to the data lake
+const trackedSlots = [
+    'top-above-nav',
+    'inline1',
+    'inline2',
+    'fronts-banner-1',
+    'fronts-banner-2',
+];
+// marks that we want to save as commercial metrics
+const slotMarks = [
+    'slotReady',
+    'adRenderStart',
+    'prebidStart',
+    'adOnPage',
+    'viewable',
+];
+// measures that we want to save as commercial metrics
+const slotMeasures = [
+    'adRender',
+    'defineSlot',
+    'prepareSlot',
+    'prebid',
+    'fetchAd',
+];
+const pageMarks = ['commercialStart', 'commercialModulesLoaded'];
+// measures that we want to save as commercial metrics
+const pageMeasures = ['commercialBoot', 'googletagInit'];
+// all marks, including the measure start and end marks
+const allSlotMarks = [
+    ...slotMarks,
+    ...slotMeasures.map((measure) => `${measure}Start`),
+    ...slotMeasures.map((measure) => `${measure}End`),
+];
+const externalMarks = [
+    'cmp-init',
+    'cmp-ui-displayed',
+    'cmp-got-consent',
+];
+const shouldSave = (name) => {
+    let [origin, type] = name.split('_');
+    if (!type) {
+        type = origin;
+        origin = 'page';
+    }
+    const shouldSaveMark = (trackedSlots.includes(origin) &&
+        slotMarks.includes(type)) ||
+        (origin === 'page' && pageMarks.includes(type));
+    const shouldSaveMeasure = (trackedSlots.includes(origin) &&
+        slotMeasures.includes(type)) ||
+        (origin === 'page' && pageMeasures.includes(type));
+    return shouldSaveMark || shouldSaveMeasure;
+};
+class EventTimer {
+    _marks;
+    _measures;
+    properties;
+    /**
+     * Initialise the EventTimer class on page.
+     * Returns the singleton instance of the EventTimer class and binds
+     * to window.guardian.commercialTimer. If it's been previously
+     * initialised and bound it returns the original instance
+     * Note: We save to window.guardian.commercialTimer because
+     * different bundles (DCR / DCP) can use commercial, and we want
+     * all timer events saved to a single instance per-page
+     * @returns {EventTimer} Instance of EventTimer
+     */
+    static init() {
+        return (window.guardian.commercialTimer ??= new EventTimer());
+    }
+    /**
+     * Just a helper method to access the singleton instance of EventTimer.
+     * Typical use case is EventTimer.get().trigger
+     */
+    static get() {
+        return this.init();
+    }
+    /**
+     * These are marks that are not triggered by commercial but we are interested in
+     * tracking their performance. For example, CMP-related events.
+     **/
+    get _externalMarks() {
+        if (!supportsPerformanceAPI()) {
+            return new Map();
+        }
+        return externalMarks.reduce((map, mark) => {
+            const entries = window.performance.getEntriesByName(mark);
+            if (entries.length && entries[0]) {
+                map.set(mark, entries[0]);
+            }
+            return map;
+        }, new Map());
+    }
+    /**
+     * Returns all performance marks that should be saved as commercial metrics.
+     */
+    get marks() {
+        return [...this._marks, ...this._externalMarks].map(([name, timer]) => ({
+            name,
+            ts: timer.startTime,
+        }));
+    }
+    /**
+     * Returns all performance measures that should be saved as commercial metrics.
+     */
+    get measures() {
+        return [...this._measures].map(([name, measure]) => ({
+            name,
+            duration: measure.duration,
+        }));
+    }
+    constructor() {
+        this._marks = new Map();
+        this._measures = new Map();
+        this.properties = {};
+        if (window.navigator.connection) {
+            this.properties.type = window.navigator.connection.type;
+            this.properties.downlink = window.navigator.connection.downlink;
+            this.properties.effectiveType =
+                window.navigator.connection.effectiveType;
+        }
+    }
+    /**
+     * Adds a non timer measurement
+     *
+     * @param {string} name - the property's name
+     * @param value - the property's value
+     */
+    setProperty(name, value) {
+        this.properties[name] = value;
+    }
+    /**
+     * Creates a new performance mark, and if the mark ends with 'End' it will
+     * create a performance measure between the start and end marks.
+     *
+     * Marks can  be triggered multiple times, but we only save the first
+     * instance of a mark, as things like ad refreshes can trigger the same mark.
+     *
+     * More info on the performance API:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure
+     *
+     * @todo more strict typing for eventName and origin
+     * @param eventName The short name applied to the mark
+     * @param origin - Either 'page' (default) or the name of the slot
+     */
+    mark(eventName, origin = 'page') {
+        let name = eventName;
+        if (allSlotMarks.includes(eventName) && origin !== 'page') {
+            name = `${origin}_${name}`;
+        }
+        if (!!this._marks.get(name) || !supportsPerformanceAPI()) {
+            return;
+        }
+        const mark = window.performance.mark(name);
+        if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- browser support is patchy
+        typeof mark?.startTime === 'number' &&
+            // we only want to save the marks that are related to certain slots or the page
+            shouldSave(name)) {
+            this._marks.set(name, mark);
+        }
+        if (name.endsWith('End')) {
+            this.measure(name);
+        }
+    }
+    /**
+     * Creates a performance measure given the name of the end marks.
+     * The start mark is inferred from the end mark.
+     *
+     * @param endMark - The name of the mark that ends the measure
+     **/
+    measure(endMark) {
+        const startMark = endMark.replace('End', 'Start');
+        const measureName = endMark.replace('End', '');
+        const startMarkExists = window.performance.getEntriesByName(startMark).length > 0;
+        if (startMarkExists) {
+            try {
+                const measure = window.performance.measure(measureName, startMark, endMark);
+                // we only want to save the measures that are related to certain slots or the page
+                if (measure && shouldSave(measureName)) {
+                    this._measures.set(measureName, measure);
+                }
+            }
+            catch (e) {
+                log('commercial', `error measuring ${measureName}`, e);
+            }
+        }
+    }
+}
+const _ = {
+    slotMarks,
+    slotMeasures,
+    trackedSlots,
+};
+export { EventTimer, _, supportsPerformanceAPI };

package/dist/esm/geo/country-code.d.ts

@@ -0,0 +1,3 @@
+import type { CountryCode } from '@guardian/libs';
+declare const getCountryCode: () => CountryCode;
+export { getCountryCode };

package/dist/esm/geo/country-code.js

@@ -0,0 +1,31 @@
+import { getCookie, isString, storage } from '@guardian/libs';
+const editionToCountryCodeMap = {
+    UK: 'GB',
+    US: 'US',
+    AU: 'AU',
+};
+const editionToCountryCode = (editionKey = 'UK') => editionToCountryCodeMap[editionKey];
+const countryCookieName = 'GU_geo_country';
+const countryOverrideName = 'gu.geo.override';
+let locale;
+/*
+   This method can be used as a non async way of getting the country code
+   after init has been called. Returning locale should cover all/most
+   of the cases but if a race condition happen or the cookie is not set,
+   we keep fallbacks to cookie or geo from edition.
+*/
+const getCountryCode = () => {
+    const pageEdition = window.guardian.config.page.edition;
+    const maybeCountryOverride = storage.local.get(countryOverrideName);
+    const countryOverride = isString(maybeCountryOverride)
+        ? maybeCountryOverride
+        : null;
+    return (locale ??
+        countryOverride ??
+        getCookie({
+            name: countryCookieName,
+            shouldMemoize: true,
+        }) ??
+        editionToCountryCode(pageEdition));
+};
+export { getCountryCode };

package/dist/esm/geo/geo-utils.d.ts

@@ -0,0 +1,11 @@
+export declare const isInUk: () => boolean;
+export declare const isInUsa: () => boolean;
+export declare const isInCanada: () => boolean;
+export declare const isInAustralia: () => boolean;
+export declare const isInNewZealand: () => boolean;
+export declare const isInUsOrCa: () => boolean;
+export declare const isInAuOrNz: () => boolean;
+export declare const isInRow: () => boolean;
+export declare const _: {
+    resetModule: () => void;
+};

package/dist/esm/geo/geo-utils.js

@@ -0,0 +1,20 @@
+import { getCountryCode } from './country-code';
+// cache the users location so we only have to look it up once
+let geo;
+const currentGeoLocation = () => {
+    geo = geo ?? getCountryCode();
+    return geo;
+};
+export const isInUk = () => currentGeoLocation() === 'GB';
+export const isInUsa = () => currentGeoLocation() === 'US';
+export const isInCanada = () => currentGeoLocation() === 'CA';
+export const isInAustralia = () => currentGeoLocation() === 'AU';
+export const isInNewZealand = () => currentGeoLocation() === 'NZ';
+export const isInUsOrCa = () => isInUsa() || isInCanada();
+export const isInAuOrNz = () => isInAustralia() || isInNewZealand();
+export const isInRow = () => !isInUk() && !isInUsOrCa() && !isInAuOrNz();
+export const _ = {
+    resetModule: () => {
+        geo = undefined;
+    },
+};

package/dist/esm/geo/get-locale.d.ts

@@ -0,0 +1,8 @@
+import type { CountryCode } from '@guardian/libs';
+export declare const __resetCachedValue: () => void;
+/**
+ * Fetches the user's current location as an ISO 3166-1 alpha-2 string e.g. 'GB', 'AU' etc
+ * Note: This has been copied from guardian-libs and made syncronous by ommiting the call to
+ * the geolocation API
+ */
+export declare const getLocale: () => CountryCode;

package/dist/esm/geo/get-locale.js

@@ -0,0 +1,38 @@
+import { getCookie, isString, storage } from '@guardian/libs';
+const KEY = 'GU_geo_country';
+const KEY_OVERRIDE = 'gu.geo.override';
+const COUNTRY_REGEX = /^[A-Z]{2}$/;
+// best guess that we have a valid code, without actually shipping the entire list
+const isValidCountryCode = (country) => isString(country) && COUNTRY_REGEX.test(country);
+// we'll cache any successful lookups so we only have to do this once
+let locale;
+const editionToGeolocationMap = {
+    UK: 'GB',
+    US: 'US',
+    AU: 'AU',
+};
+const editionToGeolocation = (editionKey) => editionToGeolocationMap[editionKey];
+// just used for tests
+export const __resetCachedValue = () => (locale = undefined);
+/**
+ * Fetches the user's current location as an ISO 3166-1 alpha-2 string e.g. 'GB', 'AU' etc
+ * Note: This has been copied from guardian-libs and made syncronous by ommiting the call to
+ * the geolocation API
+ */
+export const getLocale = () => {
+    if (locale)
+        return locale;
+    // return overridden geo from localStorage, used for changing geo only for development purposes
+    const geoOverride = storage.local.get(KEY_OVERRIDE);
+    if (isValidCountryCode(geoOverride)) {
+        return (locale = geoOverride);
+    }
+    // return locale from cookie if it exists
+    const stored = getCookie({ name: KEY });
+    if (stored && isValidCountryCode(stored)) {
+        return (locale = stored);
+    }
+    // return locale from edition
+    const editionCountryCode = editionToGeolocation(window.guardian.config.page.edition);
+    return (locale = editionCountryCode);
+};

package/dist/esm/global.d.ts

@@ -0,0 +1,71 @@
+import type { EventTimer } from './event-timer';
+import type { AdBlockers, Apstag, ArticleCounts, ComscoreGlobals, Confiant, Config, DfpEnv, FetchBidResponse, GoogleTagParams, GoogleTrackConversionObject, HeaderNotification, IasPET, NetworkInformation, NSdkInstance, Ophan, OptOutAdSlot, OptOutInitializeOptions, Permutive, SafeFrameAPI, TeadsAnalytics, Trac } from './types';
+declare global {
+    interface Navigator {
+        readonly connection?: NetworkInformation;
+        readonly cookieDeprecationLabel?: {
+            getValue: () => Promise<string>;
+        };
+    }
+    interface Window {
+        guardian: {
+            ophan?: Ophan;
+            config: Config;
+            queue: Array<() => Promise<void>>;
+            mustardCut?: boolean;
+            polyfilled?: boolean;
+            adBlockers: AdBlockers;
+            css: {
+                onLoad: () => void;
+                loaded: boolean;
+            };
+            articleCounts?: ArticleCounts;
+            commercial?: {
+                dfpEnv?: DfpEnv;
+                a9WinningBids?: FetchBidResponse[];
+            };
+            notificationEventHistory?: HeaderNotification[][];
+            commercialTimer?: EventTimer;
+            offlineCount?: number;
+            modules: {
+                sentry?: {
+                    reportError?: (error: Error, feature: string, tags?: Record<string, string>, extras?: Record<string, unknown>) => void;
+                };
+            };
+        };
+        ootag: {
+            queue: Array<() => void>;
+            initializeOo: (o: OptOutInitializeOptions) => void;
+            addParameter: (key: string, value: string | string[]) => void;
+            addParameterForSlot: (slotId: string, key: string, value: string | string[]) => void;
+            defineSlot: (o: OptOutAdSlot) => void;
+            makeRequests: () => void;
+            refreshSlot: (slotId: string) => void;
+            refreshAllSlots: () => void;
+            logger: (...args: unknown[]) => void;
+        };
+        readonly navigator: Navigator;
+        confiant?: Confiant;
+        apstag?: Apstag;
+        permutive?: Permutive;
+        _comscore?: ComscoreGlobals[];
+        __iasPET?: IasPET;
+        teads_analytics?: TeadsAnalytics;
+        $sf: SafeFrameAPI;
+        conf: unknown;
+        NOLCMB: {
+            getInstance: (apid: string) => NSdkInstance;
+        };
+        nol_t: (pvar: {
+            cid: string;
+            content: string;
+            server: string;
+        }) => Trac;
+        google_trackConversion?: (arg0: GoogleTrackConversionObject) => void;
+        google_tag_params?: GoogleTagParams;
+        _brandmetrics?: Array<{
+            cmd: string;
+            val: Record<string, unknown>;
+        }>;
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,13 @@
+export { isAdBlockInUse } from './detect-ad-blocker';
+export { EventTimer } from './event-timer';
+export { adSizes } from './ad-sizes';
+export * as constants from './constants';
+export { bypassCommercialMetricsSampling, initCommercialMetrics, } from './send-commercial-metrics';
+export { buildPageTargeting } from './targeting/build-page-targeting';
+export { postMessage } from './messenger/post-message';
+export { buildImaAdTagUrl } from './targeting/youtube-ima';
+export { getPermutivePFPSegments } from './permutive';
+export { isEligibleForTeads } from './targeting/teads-eligibility';
+export type { AdSize, SizeMapping, SlotName } from './ad-sizes';
+export type { PageTargeting } from './targeting/build-page-targeting';
+export type { AdsConfigDisabled, AdsConfigUSNATorAus, AdsConfigTCFV2, } from './types';

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+export { isAdBlockInUse } from './detect-ad-blocker';
+export { EventTimer } from './event-timer';
+export { adSizes } from './ad-sizes';
+export * as constants from './constants';
+export { bypassCommercialMetricsSampling, initCommercialMetrics, } from './send-commercial-metrics';
+export { buildPageTargeting } from './targeting/build-page-targeting';
+export { postMessage } from './messenger/post-message';
+export { buildImaAdTagUrl } from './targeting/youtube-ima';
+export { getPermutivePFPSegments } from './permutive';
+export { isEligibleForTeads } from './targeting/teads-eligibility';

package/dist/esm/messenger/post-message.d.ts

@@ -0,0 +1 @@
+export declare const postMessage: (message: Record<string, unknown>, target: MessageEventSource, targetOrigin?: string) => void;

package/dist/esm/messenger/post-message.js

@@ -0,0 +1,3 @@
+export const postMessage = (message, target, targetOrigin = '*') => {
+    target.postMessage(JSON.stringify(message), { targetOrigin });
+};

package/dist/esm/permutive.d.ts

@@ -0,0 +1,9 @@
+declare const getPermutiveSegments: () => string[];
+declare const getPermutivePFPSegments: () => string[];
+declare const clearPermutiveSegments: () => void;
+export declare const _: {
+    PERMUTIVE_KEY: string;
+    PERMUTIVE_PFP_KEY: string;
+    getSegments: (key: string) => string[];
+};
+export { getPermutiveSegments, getPermutivePFPSegments, clearPermutiveSegments, };

package/dist/esm/permutive.js

@@ -0,0 +1,33 @@
+import { storage } from '@guardian/libs';
+const PERMUTIVE_KEY = `_papns`;
+const PERMUTIVE_PFP_KEY = `_pdfps`;
+const getSegments = (key) => {
+    try {
+        const rawSegments = storage.local.getRaw(key);
+        const segments = rawSegments
+            ? JSON.parse(rawSegments)
+            : null;
+        if (!Array.isArray(segments))
+            return [];
+        return segments
+            .slice(0, 250)
+            .map((s) => Number.parseInt(s, 10))
+            .filter((n) => typeof n === 'number' && !Number.isNaN(n))
+            .map(String);
+    }
+    catch (err) {
+        return [];
+    }
+};
+const getPermutiveSegments = () => getSegments(PERMUTIVE_KEY);
+const getPermutivePFPSegments = () => getSegments(PERMUTIVE_PFP_KEY);
+const clearPermutiveSegments = () => {
+    storage.local.remove(PERMUTIVE_KEY);
+    storage.local.remove(PERMUTIVE_PFP_KEY);
+};
+export const _ = {
+    PERMUTIVE_KEY,
+    PERMUTIVE_PFP_KEY,
+    getSegments,
+};
+export { getPermutiveSegments, getPermutivePFPSegments, clearPermutiveSegments, };