@purespectrum1/purescore-client 0.7.0

package/lib/domain/services/device-fingerprint/storage.d.ts

@@ -0,0 +1,44 @@
+export declare class Storage {
+    /**
+     * Returns an object with properties indicating the availability of different storage types.
+     *
+     * The returned object has the following properties:
+     * - `sessionStorage`: Whether session storage is available.
+     * - `localStorage`: Whether local storage is available.
+     * - `indexedDB`: Whether IndexedDB is available.
+     *
+     * @returns {object} An object with properties indicating the availability of different storage types.
+     * @example
+     * const storageProperties = getStorageProperties();
+     * console.log(storageProperties);
+     * // Output: { sessionStorage: true, localStorage: true, indexedDB: true }
+     */
+    getStorageProperties(): {
+        sessionStorage: boolean;
+        localStorage: boolean;
+        indexedDB: boolean;
+    };
+    /**
+     * Checks if local storage is available.
+     *
+     * This function returns `true` if local storage is available, and `false` otherwise.
+     * Note that if a `SecurityError` is thrown when trying to access `window.localStorage`,
+     * it means that local storage exists, but is not accessible due to security restrictions.
+     * @returns {boolean} Whether local storage is available.
+     * @example
+     * const hasLocalStorage = hasLocalStorage(); // true if local storage is available, false otherwise
+     */
+    private _hasLocalStorage;
+    /**
+     * Checks if session storage is available.
+     *
+     * This function returns `true` if session storage is available, and `false` otherwise.
+     * Note that if a `SecurityError` is thrown when trying to access `window.sessionStorage`,
+     * it means that session storage exists, but is not accessible due to security restrictions.
+     *
+     * @returns {boolean} Whether session storage is available.
+     * @example
+     * const hasSessionStorage = hasSessionStorage(); // true if session storage is available, false otherwise
+     */
+    private _hasSessionStorage;
+}

package/lib/domain/services/device-fingerprint/storage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+class Storage {
+    /**
+     * Returns an object with properties indicating the availability of different storage types.
+     *
+     * The returned object has the following properties:
+     * - `sessionStorage`: Whether session storage is available.
+     * - `localStorage`: Whether local storage is available.
+     * - `indexedDB`: Whether IndexedDB is available.
+     *
+     * @returns {object} An object with properties indicating the availability of different storage types.
+     * @example
+     * const storageProperties = getStorageProperties();
+     * console.log(storageProperties);
+     * // Output: { sessionStorage: true, localStorage: true, indexedDB: true }
+     */
+    getStorageProperties() {
+        return {
+            sessionStorage: this._hasSessionStorage(),
+            localStorage: this._hasLocalStorage(),
+            indexedDB: !!window.indexedDB,
+        };
+    }
+    /**
+     * Checks if local storage is available.
+     *
+     * This function returns `true` if local storage is available, and `false` otherwise.
+     * Note that if a `SecurityError` is thrown when trying to access `window.localStorage`,
+     * it means that local storage exists, but is not accessible due to security restrictions.
+     * @returns {boolean} Whether local storage is available.
+     * @example
+     * const hasLocalStorage = hasLocalStorage(); // true if local storage is available, false otherwise
+     */
+    _hasLocalStorage() {
+        try {
+            return !!window.localStorage;
+        }
+        catch (_a) {
+            return true; // SecurityError when referencing it means it exists
+        }
+    }
+    /**
+     * Checks if session storage is available.
+     *
+     * This function returns `true` if session storage is available, and `false` otherwise.
+     * Note that if a `SecurityError` is thrown when trying to access `window.sessionStorage`,
+     * it means that session storage exists, but is not accessible due to security restrictions.
+     *
+     * @returns {boolean} Whether session storage is available.
+     * @example
+     * const hasSessionStorage = hasSessionStorage(); // true if session storage is available, false otherwise
+     */
+    _hasSessionStorage() {
+        try {
+            return !!window.sessionStorage;
+        }
+        catch (_a) {
+            return true; // SecurityError when referencing it means it exists
+        }
+    }
+}
+exports.Storage = Storage;

package/lib/domain/services/device-fingerprint/utils.d.ts

@@ -0,0 +1,42 @@
+import { NetworkTimes } from "../../protocols/services/device-fingerprint/utils";
+export declare class Utils {
+    /**
+     * Gets the timezone offset of the current browser.
+     *
+     * @returns {number} The timezone offset in hours.
+     *
+     * @example
+     * const timezoneOffset = getTimezoneOffset();
+     * console.log(timezoneOffset); // Output: -5 or 3
+     */
+    getTimezoneOffset(): number;
+    /**
+     * Checks if touch events are supported in the current browser.
+     *
+     * @returns {boolean} True if touch events are supported, false otherwise.
+     *
+     * @example
+     * const touchSupported = getTouchSupport();
+     * console.log(touchSupported); // Output: true or false
+     */
+    getTouchSupport(): boolean;
+    /**
+     * Gets network timing data for the current page load.
+     *
+     * @returns {NetworkTimes} An object containing network timing data.
+     *
+     * @example
+     * const networkTimes = getNetworkTime();
+     * console.log(networkTimes);
+     * // Output:
+     * // {
+     * //   networkTime: 1.234,
+     * //   dnsLookupTime: 0.123,
+     * //   tcpConnectionTime: 0.234,
+     * //   serverResponseTime: 0.345,
+     * //   pageDownloadTime: 0.456,
+     * //   browserTime: 1.567
+     * // }
+     */
+    getNetworkTime(): NetworkTimes;
+}

package/lib/domain/services/device-fingerprint/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+class Utils {
+    /**
+     * Gets the timezone offset of the current browser.
+     *
+     * @returns {number} The timezone offset in hours.
+     *
+     * @example
+     * const timezoneOffset = getTimezoneOffset();
+     * console.log(timezoneOffset); // Output: -5 or 3
+     */
+    getTimezoneOffset() {
+        const dtDate = new Date();
+        return -dtDate.getTimezoneOffset() / 60;
+    }
+    /**
+     * Checks if touch events are supported in the current browser.
+     *
+     * @returns {boolean} True if touch events are supported, false otherwise.
+     *
+     * @example
+     * const touchSupported = getTouchSupport();
+     * console.log(touchSupported); // Output: true or false
+     */
+    getTouchSupport() {
+        try {
+            if (typeof navigator !== 'undefined' && typeof navigator.maxTouchPoints === 'number'
+                && navigator.maxTouchPoints > 0) {
+                return true;
+            }
+            if (typeof window !== 'undefined' && 'ontouchstart' in window) {
+                return true;
+            }
+            if (typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+                && window.matchMedia('(any-pointer: coarse)').matches) {
+                return true;
+            }
+            return typeof document !== 'undefined' && !!document.createEvent('TouchEvent');
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Gets network timing data for the current page load.
+     *
+     * @returns {NetworkTimes} An object containing network timing data.
+     *
+     * @example
+     * const networkTimes = getNetworkTime();
+     * console.log(networkTimes);
+     * // Output:
+     * // {
+     * //   networkTime: 1.234,
+     * //   dnsLookupTime: 0.123,
+     * //   tcpConnectionTime: 0.234,
+     * //   serverResponseTime: 0.345,
+     * //   pageDownloadTime: 0.456,
+     * //   browserTime: 1.567
+     * // }
+     */
+    getNetworkTime() {
+        try {
+            const navigationTiming = performance.getEntriesByType('navigation')[0];
+            const networkTime = navigationTiming.responseEnd - navigationTiming.fetchStart;
+            const dnsLookupTime = navigationTiming.domainLookupEnd - navigationTiming.domainLookupStart;
+            const tcpConnectionTime = navigationTiming.connectEnd - navigationTiming.connectStart;
+            const serverResponseTime = navigationTiming.responseStart - navigationTiming.requestStart;
+            const pageDownloadTime = navigationTiming.responseEnd - navigationTiming.responseStart;
+            const browserTime = navigationTiming.loadEventEnd - navigationTiming.fetchStart;
+            return {
+                networkTime: Number((networkTime / 1000).toFixed(3)),
+                dnsLookupTime: Number((dnsLookupTime / 1000).toFixed(3)),
+                tcpConnectionTime: Number((tcpConnectionTime / 1000).toFixed(3)),
+                serverResponseTime: Number((serverResponseTime / 1000).toFixed(3)),
+                pageDownloadTime: Number((pageDownloadTime / 1000).toFixed(3)),
+                browserTime: Number((browserTime / 1000).toFixed(3))
+            };
+        }
+        catch (err) {
+            console.error("Failed to retrieve network timing data:", err);
+            return {
+                networkTime: 0,
+                dnsLookupTime: 0,
+                tcpConnectionTime: 0,
+                serverResponseTime: 0,
+                pageDownloadTime: 0,
+                browserTime: 0
+            };
+        }
+    }
+}
+exports.Utils = Utils;

package/lib/domain/services/device-intelligence.d.ts

@@ -0,0 +1,10 @@
+import { DeviceIdentifierConfig } from "../protocols/services/device-identifier";
+import { HttpClient, HttpMethod } from "../protocols/http/http-client";
+import { DeviceIntelligenceHTTPRequest } from "../protocols/services/device-intelligence";
+export declare class DeviceIntelligenceService implements DeviceIntelligenceHTTPRequest {
+    private httpClient;
+    private baseUrl;
+    private token;
+    constructor(httpClient: HttpClient, baseUrl: string, token: string);
+    performRequest(patch: string, method: HttpMethod, config?: DeviceIdentifierConfig, data?: any): Promise<any>;
+}

package/lib/domain/services/device-intelligence.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceIntelligenceService = void 0;
+const crosscutting_1 = require("../models/crosscutting");
+class DeviceIntelligenceService {
+    constructor(httpClient, baseUrl, token) {
+        this.httpClient = httpClient;
+        this.baseUrl = baseUrl || '';
+        this.token = token || '';
+    }
+    performRequest(patch_1, method_1) {
+        return __awaiter(this, arguments, void 0, function* (patch, method, config = {}, data) {
+            var _a, _b;
+            try {
+                const { token = '', env = 'staging' } = config;
+                const missingTransactionId = 'transactionId' in (data !== null && data !== void 0 ? data : {}) && !data.transactionId;
+                if (missingTransactionId || (!config.token && !this.token)) {
+                    throw new Error('TransactionId or Authentication Token missing');
+                }
+                const isProductionEnv = env.toLowerCase() === 'production';
+                if (isProductionEnv) {
+                    this.baseUrl = crosscutting_1.PURESCORE_INTELLIGENCE_BASE_URL.production;
+                }
+                const response = yield this.httpClient.request({
+                    url: `${this.baseUrl}${patch}`,
+                    method,
+                    body: data,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${token || this.token}`
+                    },
+                });
+                if (!response.body) {
+                    throw new Error(`Empty response with status: ${response.statusCode}`);
+                }
+                return { statusCode: response.statusCode, body: response.body };
+            }
+            catch (error) {
+                const errorResponse = {
+                    statusCode: (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status,
+                    message: error.message,
+                    body: (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data,
+                };
+                console.error('Error performing Device Intelligence request:', errorResponse);
+                return errorResponse;
+            }
+        });
+    }
+}
+exports.DeviceIntelligenceService = DeviceIntelligenceService;

package/lib/domain/services/single-script-injection/checkpoint-scheduler.d.ts

@@ -0,0 +1,37 @@
+import { ScheduleRecord } from '../../protocols/services/single-script-injection/auto-init';
+import { ScheduleStore } from './schedule-store';
+/**
+ * How often the scheduler asks "is a checkpoint due yet?".
+ *
+ * Polling rather than a `setTimeout` per checkpoint because the schedule is
+ * shared state that another page load may have advanced: a timer armed on this
+ * page would not know that a checkpoint had already been delivered elsewhere.
+ */
+export declare const TICK_MS = 5000;
+type CheckpointHandler = (n: number, record: ScheduleRecord) => Promise<void>;
+/**
+ * Drives the Device-Intelligence calls off the schedule record.
+ *
+ * Every tick it resolves the next outstanding checkpoint and fires it if its due
+ * time has passed; otherwise it keeps waiting. Once every checkpoint of the
+ * transaction has been delivered the scheduler stops itself, capping the
+ * transaction at `CHECKPOINT_COUNT`.
+ */
+export declare class CheckpointScheduler {
+    private readonly store;
+    private readonly onCheckpoint;
+    private timer;
+    private inFlight;
+    constructor(store: ScheduleStore, onCheckpoint: CheckpointHandler);
+    /**
+     * Resumes (or starts) the schedule and begins polling. The first tick runs
+     * immediately so a checkpoint already overdue is not delayed another `TICK_MS`.
+     */
+    start(): ScheduleRecord;
+    stop(): void;
+    isRunning(): boolean;
+    /** Fires a tick without letting its promise escape as an unhandled rejection. */
+    private runTick;
+    private tick;
+}
+export {};

package/lib/domain/services/single-script-injection/checkpoint-scheduler.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointScheduler = exports.TICK_MS = void 0;
+/**
+ * How often the scheduler asks "is a checkpoint due yet?".
+ *
+ * Polling rather than a `setTimeout` per checkpoint because the schedule is
+ * shared state that another page load may have advanced: a timer armed on this
+ * page would not know that a checkpoint had already been delivered elsewhere.
+ */
+exports.TICK_MS = 5000;
+/**
+ * Drives the Device-Intelligence calls off the schedule record.
+ *
+ * Every tick it resolves the next outstanding checkpoint and fires it if its due
+ * time has passed; otherwise it keeps waiting. Once every checkpoint of the
+ * transaction has been delivered the scheduler stops itself, capping the
+ * transaction at `CHECKPOINT_COUNT`.
+ */
+class CheckpointScheduler {
+    constructor(store, onCheckpoint) {
+        this.store = store;
+        this.onCheckpoint = onCheckpoint;
+        this.timer = null;
+        this.inFlight = false;
+    }
+    /**
+     * Resumes (or starts) the schedule and begins polling. The first tick runs
+     * immediately so a checkpoint already overdue is not delayed another `TICK_MS`.
+     */
+    start() {
+        this.stop();
+        const record = this.store.resumeOrCreate();
+        this.runTick();
+        this.timer = setInterval(() => this.runTick(), exports.TICK_MS);
+        return record;
+    }
+    stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    isRunning() {
+        return this.timer !== null;
+    }
+    /** Fires a tick without letting its promise escape as an unhandled rejection. */
+    runTick() {
+        this.tick().catch(error => console.error('Error in Device-Intelligence checkpoint tick:', error));
+    }
+    tick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // A call already in flight owns the next checkpoint; a second tick must not
+            // fire it again while the request is still resolving.
+            if (this.inFlight)
+                return;
+            const record = this.store.resumeOrCreate();
+            const next = record.checkpoints.find(c => c.n > record.sent);
+            if (!next) {
+                // Nothing left, and nothing can appear: the LOI checkpoints are added
+                // before the schedule starts.
+                this.stop();
+                return;
+            }
+            if (new Date().getTime() < next.dueAt)
+                return;
+            this.inFlight = true;
+            try {
+                yield this.onCheckpoint(next.n, record);
+                // Persisted only after the call resolves, so a failed request leaves the
+                // checkpoint outstanding and the next tick retries it.
+                this.store.markSent(next.n);
+            }
+            catch (error) {
+                // Swallowed on purpose: a rejected checkpoint must not surface as an
+                // unhandled rejection on the buyer's survey page.
+                console.error(`Error delivering Device-Intelligence checkpoint ${next.n}:`, error);
+            }
+            finally {
+                this.inFlight = false;
+            }
+        });
+    }
+}
+exports.CheckpointScheduler = CheckpointScheduler;

package/lib/domain/services/single-script-injection/index.d.ts

@@ -0,0 +1,3 @@
+export * from './checkpoint-scheduler';
+export * from './response-delivery';
+export * from './schedule-store';

package/lib/domain/services/single-script-injection/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./checkpoint-scheduler"), exports);
+__exportStar(require("./response-delivery"), exports);
+__exportStar(require("./schedule-store"), exports);

package/lib/domain/services/single-script-injection/response-delivery.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Name of the custom event carrying the Device-Intelligence response.
+ *
+ * The `ps:` prefix namespaces it so it cannot collide with an event the buyer's
+ * own survey platform dispatches.
+ */
+export declare const PS_RESULT_EVENT = "ps:purescore:result";
+/**
+ * Global the last response is also exposed on, for buyers who prefer reading it
+ * directly rather than listening.
+ */
+export declare const PS_GLOBAL = "psPureScore";
+/**
+ * Hands the Device-Intelligence response back to the buyer.
+ *
+ * Once the Device-Identifier owns the call it also owns the response, so it has
+ * to push it out. Three channels carry the same object and the buyer picks
+ * whichever suits their platform:
+ *
+ *   - a `ps:purescore:result` CustomEvent on `window` (any number of listeners);
+ *   - a global function named on the tag via `data-callback`;
+ *   - `window.psPureScore.lastResult`, for code that would rather read than listen.
+ */
+export declare class ResponseDeliveryService {
+    private readonly callbackName?;
+    constructor(callbackName?: string | undefined);
+    /**
+     * Delivers a response that has just arrived, on every channel.
+     */
+    deliver(response: Record<string, any>): void;
+    /**
+     * Re-emits a response that was produced on an earlier page (the replay buffer).
+     *
+     * Because the checkpoints now fire on the schedule rather than at a point the
+     * buyer chose, the call and the buyer's code are no longer guaranteed to be on
+     * the same page. The global is published synchronously — it is a read, so it
+     * has to be there before the buyer's code runs — while the event and the
+     * callback are deferred until the document has finished parsing, giving a
+     * listener or function declared further down the page a chance to exist.
+     */
+    replay(response: Record<string, any>): void;
+    private publishGlobal;
+    private dispatch;
+    private invokeCallback;
+    private buildEvent;
+    private whenDocumentReady;
+}

package/lib/domain/services/single-script-injection/response-delivery.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseDeliveryService = exports.PS_GLOBAL = exports.PS_RESULT_EVENT = void 0;
+const validation_1 = require("../../../validation");
+/**
+ * Name of the custom event carrying the Device-Intelligence response.
+ *
+ * The `ps:` prefix namespaces it so it cannot collide with an event the buyer's
+ * own survey platform dispatches.
+ */
+exports.PS_RESULT_EVENT = 'ps:purescore:result';
+/**
+ * Global the last response is also exposed on, for buyers who prefer reading it
+ * directly rather than listening.
+ */
+exports.PS_GLOBAL = 'psPureScore';
+/**
+ * Hands the Device-Intelligence response back to the buyer.
+ *
+ * Once the Device-Identifier owns the call it also owns the response, so it has
+ * to push it out. Three channels carry the same object and the buyer picks
+ * whichever suits their platform:
+ *
+ *   - a `ps:purescore:result` CustomEvent on `window` (any number of listeners);
+ *   - a global function named on the tag via `data-callback`;
+ *   - `window.psPureScore.lastResult`, for code that would rather read than listen.
+ */
+class ResponseDeliveryService {
+    constructor(callbackName) {
+        this.callbackName = callbackName;
+    }
+    /**
+     * Delivers a response that has just arrived, on every channel.
+     */
+    deliver(response) {
+        if (typeof window === 'undefined')
+            return;
+        this.publishGlobal(response);
+        this.dispatch(response);
+        this.invokeCallback(response);
+    }
+    /**
+     * Re-emits a response that was produced on an earlier page (the replay buffer).
+     *
+     * Because the checkpoints now fire on the schedule rather than at a point the
+     * buyer chose, the call and the buyer's code are no longer guaranteed to be on
+     * the same page. The global is published synchronously — it is a read, so it
+     * has to be there before the buyer's code runs — while the event and the
+     * callback are deferred until the document has finished parsing, giving a
+     * listener or function declared further down the page a chance to exist.
+     */
+    replay(response) {
+        if (typeof window === 'undefined')
+            return;
+        this.publishGlobal(response);
+        this.whenDocumentReady(() => {
+            this.dispatch(response);
+            this.invokeCallback(response);
+        });
+    }
+    publishGlobal(response) {
+        var _a;
+        try {
+            const globals = (_a = window[exports.PS_GLOBAL]) !== null && _a !== void 0 ? _a : {};
+            globals.lastResult = response;
+            window[exports.PS_GLOBAL] = globals;
+        }
+        catch ( /* never let delivery bookkeeping break the survey page */_b) { /* never let delivery bookkeeping break the survey page */ }
+    }
+    dispatch(response) {
+        try {
+            window.dispatchEvent(this.buildEvent(response));
+        }
+        catch (error) {
+            console.error('Error dispatching PureScore result event:', error);
+        }
+    }
+    invokeCallback(response) {
+        if (!this.callbackName)
+            return;
+        const error = new validation_1.GlobalFunction(this.callbackName, 'data-callback').validate();
+        if (error) {
+            console.error(`PureScore callback: ${error.message}`);
+            return;
+        }
+        const fn = window[this.callbackName];
+        try {
+            fn(response);
+        }
+        catch (error) {
+            console.error(`Error in PureScore callback "${this.callbackName}":`, error);
+        }
+    }
+    buildEvent(response) {
+        try {
+            return new CustomEvent(exports.PS_RESULT_EVENT, { detail: response });
+        }
+        catch (_a) {
+            // Older browsers where CustomEvent is not constructible.
+            const event = document.createEvent('CustomEvent');
+            event.initCustomEvent(exports.PS_RESULT_EVENT, false, false, response);
+            return event;
+        }
+    }
+    whenDocumentReady(run) {
+        if (typeof document === 'undefined' || document.readyState !== 'loading') {
+            // Already parsed: still defer by a macrotask so an inline listener placed
+            // right after the tag is registered before the replay fires.
+            setTimeout(run, 0);
+            return;
+        }
+        document.addEventListener('DOMContentLoaded', () => run(), { once: true });
+    }
+}
+exports.ResponseDeliveryService = ResponseDeliveryService;