@simula/ads 1.1.0

package/dist/index.mjs

@@ -0,0 +1,2224 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { createContext, useState, useEffect, useContext, useRef, useMemo, useCallback } from 'react';
+
+// Production API URL
+const API_BASE_URL = 'https://simula-api-701226639755.us-central1.run.app';
+// Create a server session and return its id
+async function createSession(apiKey, devMode, primaryUserID) {
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        };
+        // Build query parameters
+        const params = new URLSearchParams();
+        if (devMode !== undefined) {
+            params.append('devMode', String(devMode));
+        }
+        if (primaryUserID !== undefined && primaryUserID !== '') {
+            params.append('ppid', primaryUserID);
+        }
+        const queryString = params.toString();
+        const url = `${API_BASE_URL}/session/create${queryString ? `?${queryString}` : ''}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({}),
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error('Invalid API key (please check dashboard or contact Simula team for a valid API key)');
+            }
+            return undefined;
+        }
+        const data = await response.json();
+        if (data && typeof data.sessionId === 'string' && data.sessionId) {
+            return data.sessionId;
+        }
+        return undefined;
+    }
+    catch (error) {
+        // Re-throw 401 errors with our custom message
+        if (error instanceof Error && error.message.includes('Invalid API key')) {
+            throw error;
+        }
+        return undefined;
+    }
+}
+const fetchAd = async (request) => {
+    var _a, _b, _c, _d;
+    try {
+        const conversationHistory = request.messages;
+        // Normalize theme accent and font to arrays for backend
+        const normalizedTheme = request.theme ? {
+            ...request.theme,
+            accent: request.theme.accent ? (Array.isArray(request.theme.accent) ? request.theme.accent : [request.theme.accent]) : undefined,
+            font: request.theme.font ? (Array.isArray(request.theme.font) ? request.theme.font : [request.theme.font]) : undefined,
+        } : undefined;
+        const requestBody = {
+            messages: conversationHistory,
+            types: request.formats,
+            slot_id: request.slotId,
+            theme: normalizedTheme,
+            session_id: request.sessionId,
+            char_desc: request.charDesc,
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${request.apiKey}`,
+        };
+        const response = await fetch(`${API_BASE_URL}/render_ad/ssp`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        // Handle new API shape
+        if (data && typeof data === 'object') {
+            if (!data.adInserted) {
+                return { error: 'No fill' };
+            }
+            // New shape: { adType, adInserted, adResponse: { ad_id, iframe_url, ... } }
+            if (data.adResponse && typeof data.adResponse === 'object') {
+                const ar = data.adResponse;
+                const ad = {
+                    id: (_a = ar.ad_id) !== null && _a !== void 0 ? _a : ar.id,
+                    format: ((_c = (_b = data.adType) !== null && _b !== void 0 ? _b : ar.format) !== null && _c !== void 0 ? _c : 'iframe'),
+                    iframeUrl: (_d = ar.iframe_url) !== null && _d !== void 0 ? _d : ar.iframeUrl,
+                };
+                if (ad.id && ad.iframeUrl) {
+                    return { ad };
+                }
+                return { error: 'Invalid ad response' };
+            }
+            // Legacy shape: { ad: { ... } }
+            if (data.ad) {
+                return { ad: data.ad };
+            }
+            if (data.error) {
+                return { error: data.error };
+            }
+        }
+        return { error: 'Unexpected response from ad server' };
+    }
+    catch (error) {
+        console.error('❌ API Request failed:', error);
+        return {
+            error: error instanceof Error ? error.message : 'Failed to fetch ad'
+        };
+    }
+};
+const trackImpression = async (adId, apiKey) => {
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        };
+        await fetch(`${API_BASE_URL}/track/engagement/impression/${adId}`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({}),
+        });
+    }
+    catch (error) {
+        console.error('Failed to track impression:', error);
+    }
+};
+/* Not used for now, used when we are also mediation layer
+export const trackClick = async (adId: string, apiKey: string): Promise<void> => {
+  try {
+    await fetch(`${API_BASE_URL}/track_click`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        ad_id: adId,
+        timestamp: new Date().toISOString(),
+      }),
+    });
+  } catch (error) {
+    console.error('Failed to track click:', error);
+  }
+};
+*/
+
+// Helper functions for width validation
+const isAutoWidth$1 = (width) => width === 'auto';
+const isPercentageWidth$1 = (width) => typeof width === 'string' && /^\d+(?:\.\d+)?%$/.test(width);
+const isPixelWidth = (width) => typeof width === 'string' && /^\d+(?:\.\d+)?px$/.test(width);
+/**
+ * Validates SimulaProvider props
+ * Throws descriptive errors for invalid props
+ */
+const validateSimulaProviderProps = (props) => {
+    const validProps = ['apiKey', 'children', 'devMode', 'primaryUserID'];
+    const receivedProps = Object.keys(props);
+    // Check for unknown props
+    const unknownProps = receivedProps.filter(prop => !validProps.includes(prop));
+    if (unknownProps.length > 0) {
+        throw new Error(`Invalid prop${unknownProps.length > 1 ? 's' : ''} passed to SimulaProvider: ${unknownProps.map(p => `"${p}"`).join(', ')}. ` +
+            `Valid props are: ${validProps.join(', ')}`);
+    }
+    // Validate required props
+    if (!props.apiKey || typeof props.apiKey !== 'string') {
+        throw new Error('SimulaProvider requires a valid "apiKey" prop (string)');
+    }
+    if (!props.children) {
+        throw new Error('SimulaProvider requires a "children" prop');
+    }
+    // Validate optional props
+    if (props.devMode !== undefined && typeof props.devMode !== 'boolean') {
+        throw new Error(`Invalid "devMode" prop type: "${typeof props.devMode}". Must be a boolean`);
+    }
+    if (props.primaryUserID !== undefined && typeof props.primaryUserID !== 'string') {
+        throw new Error(`Invalid "primaryUserID" prop type: "${typeof props.primaryUserID}". Must be a string`);
+    }
+};
+/**
+ * Validates InChatAdSlot props
+ * Throws descriptive errors for invalid props
+ */
+const validateInChatAdSlotProps = (props) => {
+    const validProps = ['messages', 'trigger', 'formats', 'theme', 'debounceMs', 'charDesc', 'onImpression', 'onClick', 'onError'];
+    const receivedProps = Object.keys(props);
+    // Check for unknown props
+    const unknownProps = receivedProps.filter(prop => !validProps.includes(prop));
+    if (unknownProps.length > 0) {
+        throw new Error(`Invalid prop${unknownProps.length > 1 ? 's' : ''} passed to InChatAdSlot: ${unknownProps.map(p => `"${p}"`).join(', ')}. ` +
+            `Valid props are: ${validProps.join(', ')}`);
+    }
+    // Validate messages (required)
+    if (!props.messages || !Array.isArray(props.messages)) {
+        throw new Error('InChatAdSlot requires a valid "messages" prop (array of Message objects)');
+    }
+    if (props.messages.length === 0) {
+        throw new Error('InChatAdSlot "messages" prop cannot be an empty array');
+    }
+    props.messages.forEach((msg, i) => {
+        if (!msg || typeof msg !== 'object') {
+            throw new Error(`Invalid message at index ${i}: must be an object with "role" and "content" properties`);
+        }
+        if (!msg.role || typeof msg.role !== 'string') {
+            throw new Error(`Invalid message at index ${i}: "role" must be a non-empty string`);
+        }
+        if (msg.content === undefined || typeof msg.content !== 'string') {
+            throw new Error(`Invalid message at index ${i}: "content" must be a string`);
+        }
+    });
+    // Validate formats (optional)
+    if (props.formats !== undefined) {
+        validateFormats(props.formats);
+    }
+    // Validate theme (optional)
+    if (props.theme !== undefined) {
+        validateTheme(props.theme);
+    }
+    // Validate debounceMs (optional)
+    if (props.debounceMs !== undefined) {
+        if (typeof props.debounceMs !== 'number') {
+            throw new Error(`Invalid "debounceMs" prop type: "${typeof props.debounceMs}". Must be a number`);
+        }
+        if (props.debounceMs < 0) {
+            throw new Error(`Invalid "debounceMs" prop value: "${props.debounceMs}". Must be a non-negative number`);
+        }
+    }
+    // Validate charDesc (optional)
+    if (props.charDesc !== undefined && typeof props.charDesc !== 'string') {
+        throw new Error(`Invalid "charDesc" prop type: "${typeof props.charDesc}". Must be a string`);
+    }
+    // Validate callbacks (optional)
+    if (props.onImpression !== undefined && typeof props.onImpression !== 'function') {
+        throw new Error(`Invalid "onImpression" prop type: "${typeof props.onImpression}". Must be a function`);
+    }
+    if (props.onClick !== undefined && typeof props.onClick !== 'function') {
+        throw new Error(`Invalid "onClick" prop type: "${typeof props.onClick}". Must be a function`);
+    }
+    if (props.onError !== undefined && typeof props.onError !== 'function') {
+        throw new Error(`Invalid "onError" prop type: "${typeof props.onError}". Must be a function`);
+    }
+    // Note: trigger validation (Promise check) is skipped because checking instanceof Promise
+    // is unreliable across different Promise implementations and contexts
+};
+/**
+ * Validates formats - accepts string or string[]
+ * Throws descriptive errors for invalid formats
+ */
+const validateFormats = (formats) => {
+    if (!formats)
+        return;
+    const validFormatOptions = ['all', 'tips', 'interactive', 'suggestions', 'text', 'highlight', 'visual_banner', 'image_feature'];
+    // Normalize to array for validation
+    const formatsArray = Array.isArray(formats) ? formats : [formats];
+    formatsArray.forEach((format, i) => {
+        if (typeof format !== 'string') {
+            throw new Error(`Invalid format type at index ${i}: "${typeof format}". Must be a string. Valid values: ${validFormatOptions.join(', ')}`);
+        }
+        if (!validFormatOptions.includes(format)) {
+            throw new Error(`Invalid format value${Array.isArray(formats) ? ` at index ${i}` : ''}: "${format}". Valid values: ${validFormatOptions.join(', ')}`);
+        }
+    });
+};
+/**
+ * Validates theme object
+ * Throws descriptive errors for invalid theme properties
+ */
+const validateTheme = (theme) => {
+    if (!theme || typeof theme !== 'object') {
+        throw new Error('Invalid "theme": must be an object');
+    }
+    const validThemeOptions = ['light', 'dark', 'auto'];
+    const validAccentOptions = ['blue', 'red', 'green', 'yellow', 'purple', 'pink', 'orange', 'neutral', 'gray', 'tan', 'transparent', 'image'];
+    const validFontOptions = ['san-serif', 'serif', 'monospace'];
+    const validKeys = ['theme', 'accent', 'font', 'width', 'cornerRadius'];
+    // Check for invalid top-level keys
+    Object.keys(theme).forEach(key => {
+        if (!validKeys.includes(key)) {
+            throw new Error(`Invalid theme parameter "${key}". Valid parameters: ${validKeys.join(', ')}`);
+        }
+    });
+    // Validate theme value
+    if (theme.theme !== undefined) {
+        if (typeof theme.theme !== 'string') {
+            throw new Error(`Invalid theme type "${typeof theme.theme}". Must be a string. Valid values: ${validThemeOptions.join(', ')}`);
+        }
+        if (!validThemeOptions.includes(theme.theme)) {
+            throw new Error(`Invalid theme value "${theme.theme}". Valid values: ${validThemeOptions.join(', ')}`);
+        }
+    }
+    // Validate accent value(s)
+    if (theme.accent !== undefined) {
+        const accents = Array.isArray(theme.accent) ? theme.accent : [theme.accent];
+        accents.forEach((accent, i) => {
+            if (typeof accent !== 'string') {
+                throw new Error(`Invalid accent type at index ${i}: "${typeof accent}". Must be a string. Valid values: ${validAccentOptions.join(', ')}`);
+            }
+            if (!validAccentOptions.includes(accent)) {
+                throw new Error(`Invalid accent value${Array.isArray(theme.accent) ? ` at index ${i}` : ''}: "${accent}". Valid values: ${validAccentOptions.join(', ')}`);
+            }
+        });
+    }
+    // Validate font value(s)
+    if (theme.font !== undefined) {
+        const fonts = Array.isArray(theme.font) ? theme.font : [theme.font];
+        fonts.forEach((font, i) => {
+            if (typeof font !== 'string') {
+                throw new Error(`Invalid font type at index ${i}: "${typeof font}". Must be a string. Valid values: ${validFontOptions.join(', ')}`);
+            }
+            if (!validFontOptions.includes(font)) {
+                throw new Error(`Invalid font value${Array.isArray(theme.font) ? ` at index ${i}` : ''}: "${font}". Valid values: ${validFontOptions.join(', ')}`);
+            }
+        });
+    }
+    // Validate width
+    if (theme.width !== undefined) {
+        if (typeof theme.width !== 'number' && typeof theme.width !== 'string') {
+            throw new Error(`Invalid width type "${typeof theme.width}". Must be number, "auto", "%", or "px"`);
+        }
+        if (typeof theme.width === 'string' && !isAutoWidth$1(theme.width) && !isPercentageWidth$1(theme.width) && !isPixelWidth(theme.width)) {
+            throw new Error(`Invalid width "${theme.width}". Must be an integer, "auto", or a string like "100%", "500px"`);
+        }
+    }
+    // Validate cornerRadius
+    if (theme.cornerRadius !== undefined && typeof theme.cornerRadius !== 'number') {
+        throw new Error(`Invalid cornerRadius type "${typeof theme.cornerRadius}". Must be a number`);
+    }
+};
+
+const SimulaContext = createContext(undefined);
+const useSimula = () => {
+    const context = useContext(SimulaContext);
+    if (!context) {
+        throw new Error('useSimula must be used within a SimulaProvider');
+    }
+    return context;
+};
+const SimulaProvider = (props) => {
+    // Validate props early
+    validateSimulaProviderProps(props);
+    const { apiKey, children, devMode = false, primaryUserID } = props;
+    const [sessionId, setSessionId] = useState(undefined);
+    useEffect(() => {
+        let cancelled = false;
+        async function ensureSession() {
+            const id = await createSession(apiKey, devMode, primaryUserID);
+            if (!cancelled && id)
+                setSessionId(id);
+        }
+        ensureSession();
+        return () => { cancelled = true; };
+    }, [apiKey, devMode, primaryUserID]);
+    const value = {
+        apiKey,
+        devMode,
+        sessionId,
+    };
+    return (jsx(SimulaContext.Provider, { value: value, children: children }));
+};
+
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = { randomUUID };
+
+function _v4(options, buf, offset) {
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    return _v4(options);
+}
+
+const useDebounce = (callback, delay, deps) => {
+    const timeoutRef = useRef();
+    useEffect(() => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(callback, delay);
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, [...deps, delay]);
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __awaiter(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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Fingerprint BotD v1.9.1 - Copyright (c) FingerprintJS, Inc, 2024 (https://fingerprint.com)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
+ */
+
+
+var version = "1.9.1";
+
+/**
+ * Enum for types of bots.
+ * Specific types of bots come first, followed by automation technologies.
+ *
+ * @readonly
+ * @enum {string}
+ */
+var BotKind = {
+    // Object is used instead of Typescript enum to avoid emitting IIFE which might be affected by further tree-shaking.
+    // See example of compiled enums https://stackoverflow.com/q/47363996)
+    Awesomium: 'awesomium',
+    Cef: 'cef',
+    CefSharp: 'cefsharp',
+    CoachJS: 'coachjs',
+    Electron: 'electron',
+    FMiner: 'fminer',
+    Geb: 'geb',
+    NightmareJS: 'nightmarejs',
+    Phantomas: 'phantomas',
+    PhantomJS: 'phantomjs',
+    Rhino: 'rhino',
+    Selenium: 'selenium',
+    Sequentum: 'sequentum',
+    SlimerJS: 'slimerjs',
+    WebDriverIO: 'webdriverio',
+    WebDriver: 'webdriver',
+    HeadlessChrome: 'headless_chrome',
+    Unknown: 'unknown',
+};
+/**
+ * Bot detection error.
+ */
+var BotdError = /** @class */ (function (_super) {
+    __extends(BotdError, _super);
+    /**
+     * Creates a new BotdError.
+     *
+     * @class
+     */
+    function BotdError(state, message) {
+        var _this = _super.call(this, message) || this;
+        _this.state = state;
+        _this.name = 'BotdError';
+        Object.setPrototypeOf(_this, BotdError.prototype);
+        return _this;
+    }
+    return BotdError;
+}(Error));
+
+function detect(components, detectors) {
+    var detections = {};
+    var finalDetection = {
+        bot: false,
+    };
+    for (var detectorName in detectors) {
+        var detector = detectors[detectorName];
+        var detectorRes = detector(components);
+        var detection = { bot: false };
+        if (typeof detectorRes === 'string') {
+            detection = { bot: true, botKind: detectorRes };
+        }
+        else if (detectorRes) {
+            detection = { bot: true, botKind: BotKind.Unknown };
+        }
+        detections[detectorName] = detection;
+        if (detection.bot) {
+            finalDetection = detection;
+        }
+    }
+    return [detections, finalDetection];
+}
+function collect(sources) {
+    return __awaiter(this, void 0, void 0, function () {
+        var components, sourcesKeys;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    components = {};
+                    sourcesKeys = Object.keys(sources);
+                    return [4 /*yield*/, Promise.all(sourcesKeys.map(function (sourceKey) { return __awaiter(_this, void 0, void 0, function () {
+                            var res, _a, _b, error_1;
+                            var _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        res = sources[sourceKey];
+                                        _d.label = 1;
+                                    case 1:
+                                        _d.trys.push([1, 3, , 4]);
+                                        _a = components;
+                                        _b = sourceKey;
+                                        _c = {};
+                                        return [4 /*yield*/, res()];
+                                    case 2:
+                                        _a[_b] = (_c.value = _d.sent(),
+                                            _c.state = 0 /* State.Success */,
+                                            _c);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_1 = _d.sent();
+                                        if (error_1 instanceof BotdError) {
+                                            components[sourceKey] = {
+                                                state: error_1.state,
+                                                error: "".concat(error_1.name, ": ").concat(error_1.message),
+                                            };
+                                        }
+                                        else {
+                                            components[sourceKey] = {
+                                                state: -3 /* State.UnexpectedBehaviour */,
+                                                error: error_1 instanceof Error ? "".concat(error_1.name, ": ").concat(error_1.message) : String(error_1),
+                                            };
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, components];
+            }
+        });
+    });
+}
+
+function detectAppVersion(_a) {
+    var appVersion = _a.appVersion;
+    if (appVersion.state !== 0 /* State.Success */)
+        return false;
+    if (/headless/i.test(appVersion.value))
+        return BotKind.HeadlessChrome;
+    if (/electron/i.test(appVersion.value))
+        return BotKind.Electron;
+    if (/slimerjs/i.test(appVersion.value))
+        return BotKind.SlimerJS;
+}
+
+function arrayIncludes(arr, value) {
+    return arr.indexOf(value) !== -1;
+}
+function strIncludes(str, value) {
+    return str.indexOf(value) !== -1;
+}
+function arrayFind(array, callback) {
+    if ('find' in array)
+        return array.find(callback);
+    for (var i = 0; i < array.length; i++) {
+        if (callback(array[i], i, array))
+            return array[i];
+    }
+    return undefined;
+}
+
+function getObjectProps(obj) {
+    return Object.getOwnPropertyNames(obj);
+}
+function includes(arr) {
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    var _loop_1 = function (key) {
+        if (typeof key === 'string') {
+            if (arrayIncludes(arr, key))
+                return { value: true };
+        }
+        else {
+            var match = arrayFind(arr, function (value) { return key.test(value); });
+            if (match != null)
+                return { value: true };
+        }
+    };
+    for (var _a = 0, keys_1 = keys; _a < keys_1.length; _a++) {
+        var key = keys_1[_a];
+        var state_1 = _loop_1(key);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return false;
+}
+function countTruthy(values) {
+    return values.reduce(function (sum, value) { return sum + (value ? 1 : 0); }, 0);
+}
+
+function detectDocumentAttributes(_a) {
+    var documentElementKeys = _a.documentElementKeys;
+    if (documentElementKeys.state !== 0 /* State.Success */)
+        return false;
+    if (includes(documentElementKeys.value, 'selenium', 'webdriver', 'driver')) {
+        return BotKind.Selenium;
+    }
+}
+
+function detectErrorTrace(_a) {
+    var errorTrace = _a.errorTrace;
+    if (errorTrace.state !== 0 /* State.Success */)
+        return false;
+    if (/PhantomJS/i.test(errorTrace.value))
+        return BotKind.PhantomJS;
+}
+
+function detectEvalLengthInconsistency(_a) {
+    var evalLength = _a.evalLength, browserKind = _a.browserKind, browserEngineKind = _a.browserEngineKind;
+    if (evalLength.state !== 0 /* State.Success */ ||
+        browserKind.state !== 0 /* State.Success */ ||
+        browserEngineKind.state !== 0 /* State.Success */)
+        return;
+    var length = evalLength.value;
+    if (browserEngineKind.value === "unknown" /* BrowserEngineKind.Unknown */)
+        return false;
+    return ((length === 37 && !arrayIncludes(["webkit" /* BrowserEngineKind.Webkit */, "gecko" /* BrowserEngineKind.Gecko */], browserEngineKind.value)) ||
+        (length === 39 && !arrayIncludes(["internet_explorer" /* BrowserKind.IE */], browserKind.value)) ||
+        (length === 33 && !arrayIncludes(["chromium" /* BrowserEngineKind.Chromium */], browserEngineKind.value)));
+}
+
+function detectFunctionBind(_a) {
+    var functionBind = _a.functionBind;
+    if (functionBind.state === -2 /* State.NotFunction */)
+        return BotKind.PhantomJS;
+}
+
+function detectLanguagesLengthInconsistency(_a) {
+    var languages = _a.languages;
+    if (languages.state === 0 /* State.Success */ && languages.value.length === 0) {
+        return BotKind.HeadlessChrome;
+    }
+}
+
+function detectMimeTypesConsistent(_a) {
+    var mimeTypesConsistent = _a.mimeTypesConsistent;
+    if (mimeTypesConsistent.state === 0 /* State.Success */ && !mimeTypesConsistent.value) {
+        return BotKind.Unknown;
+    }
+}
+
+function detectNotificationPermissions(_a) {
+    var notificationPermissions = _a.notificationPermissions, browserKind = _a.browserKind;
+    if (browserKind.state !== 0 /* State.Success */ || browserKind.value !== "chrome" /* BrowserKind.Chrome */)
+        return false;
+    if (notificationPermissions.state === 0 /* State.Success */ && notificationPermissions.value) {
+        return BotKind.HeadlessChrome;
+    }
+}
+
+function detectPluginsArray(_a) {
+    var pluginsArray = _a.pluginsArray;
+    if (pluginsArray.state === 0 /* State.Success */ && !pluginsArray.value)
+        return BotKind.HeadlessChrome;
+}
+
+function detectPluginsLengthInconsistency(_a) {
+    var pluginsLength = _a.pluginsLength, android = _a.android, browserKind = _a.browserKind, browserEngineKind = _a.browserEngineKind;
+    if (pluginsLength.state !== 0 /* State.Success */ ||
+        android.state !== 0 /* State.Success */ ||
+        browserKind.state !== 0 /* State.Success */ ||
+        browserEngineKind.state !== 0 /* State.Success */)
+        return;
+    if (browserKind.value !== "chrome" /* BrowserKind.Chrome */ ||
+        android.value ||
+        browserEngineKind.value !== "chromium" /* BrowserEngineKind.Chromium */)
+        return;
+    if (pluginsLength.value === 0)
+        return BotKind.HeadlessChrome;
+}
+
+function detectProcess(_a) {
+    var _b;
+    var process = _a.process;
+    if (process.state !== 0 /* State.Success */)
+        return false;
+    if (process.value.type === 'renderer' || ((_b = process.value.versions) === null || _b === void 0 ? void 0 : _b.electron) != null)
+        return BotKind.Electron;
+}
+
+function detectProductSub(_a) {
+    var productSub = _a.productSub, browserKind = _a.browserKind;
+    if (productSub.state !== 0 /* State.Success */ || browserKind.state !== 0 /* State.Success */)
+        return false;
+    if ((browserKind.value === "chrome" /* BrowserKind.Chrome */ ||
+        browserKind.value === "safari" /* BrowserKind.Safari */ ||
+        browserKind.value === "opera" /* BrowserKind.Opera */ ||
+        browserKind.value === "wechat" /* BrowserKind.WeChat */) &&
+        productSub.value !== '20030107')
+        return BotKind.Unknown;
+}
+
+function detectUserAgent(_a) {
+    var userAgent = _a.userAgent;
+    if (userAgent.state !== 0 /* State.Success */)
+        return false;
+    if (/PhantomJS/i.test(userAgent.value))
+        return BotKind.PhantomJS;
+    if (/Headless/i.test(userAgent.value))
+        return BotKind.HeadlessChrome;
+    if (/Electron/i.test(userAgent.value))
+        return BotKind.Electron;
+    if (/slimerjs/i.test(userAgent.value))
+        return BotKind.SlimerJS;
+}
+
+function detectWebDriver(_a) {
+    var webDriver = _a.webDriver;
+    if (webDriver.state === 0 /* State.Success */ && webDriver.value)
+        return BotKind.HeadlessChrome;
+}
+
+function detectWebGL(_a) {
+    var webGL = _a.webGL;
+    if (webGL.state === 0 /* State.Success */) {
+        var _b = webGL.value, vendor = _b.vendor, renderer = _b.renderer;
+        if (vendor == 'Brian Paul' && renderer == 'Mesa OffScreen') {
+            return BotKind.HeadlessChrome;
+        }
+    }
+}
+
+function detectWindowExternal(_a) {
+    var windowExternal = _a.windowExternal;
+    if (windowExternal.state !== 0 /* State.Success */)
+        return false;
+    if (/Sequentum/i.test(windowExternal.value))
+        return BotKind.Sequentum;
+}
+
+function detectWindowSize(_a) {
+    var windowSize = _a.windowSize, documentFocus = _a.documentFocus;
+    if (windowSize.state !== 0 /* State.Success */ || documentFocus.state !== 0 /* State.Success */)
+        return false;
+    var _b = windowSize.value, outerWidth = _b.outerWidth, outerHeight = _b.outerHeight;
+    // When a page is opened in a new tab without focusing it right away, the window outer size is 0x0
+    if (!documentFocus.value)
+        return;
+    if (outerWidth === 0 && outerHeight === 0)
+        return BotKind.HeadlessChrome;
+}
+
+function detectDistinctiveProperties(_a) {
+    var distinctiveProps = _a.distinctiveProps;
+    if (distinctiveProps.state !== 0 /* State.Success */)
+        return false;
+    var value = distinctiveProps.value;
+    var bot;
+    for (bot in value)
+        if (value[bot])
+            return bot;
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+var detectors = {
+    detectAppVersion: detectAppVersion,
+    detectDocumentAttributes: detectDocumentAttributes,
+    detectErrorTrace: detectErrorTrace,
+    detectEvalLengthInconsistency: detectEvalLengthInconsistency,
+    detectFunctionBind: detectFunctionBind,
+    detectLanguagesLengthInconsistency: detectLanguagesLengthInconsistency,
+    detectNotificationPermissions: detectNotificationPermissions,
+    detectPluginsArray: detectPluginsArray,
+    detectPluginsLengthInconsistency: detectPluginsLengthInconsistency,
+    detectProcess: detectProcess,
+    detectUserAgent: detectUserAgent,
+    detectWebDriver: detectWebDriver,
+    detectWebGL: detectWebGL,
+    detectWindowExternal: detectWindowExternal,
+    detectWindowSize: detectWindowSize,
+    detectMimeTypesConsistent: detectMimeTypesConsistent,
+    detectProductSub: detectProductSub,
+    detectDistinctiveProperties: detectDistinctiveProperties,
+};
+
+function getAppVersion() {
+    var appVersion = navigator.appVersion;
+    if (appVersion == undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.appVersion is undefined');
+    }
+    return appVersion;
+}
+
+function getDocumentElementKeys() {
+    if (document.documentElement === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'document.documentElement is undefined');
+    }
+    var documentElement = document.documentElement;
+    if (typeof documentElement.getAttributeNames !== 'function') {
+        throw new BotdError(-2 /* State.NotFunction */, 'document.documentElement.getAttributeNames is not a function');
+    }
+    return documentElement.getAttributeNames();
+}
+
+function getErrorTrace() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        null[0]();
+    }
+    catch (error) {
+        if (error instanceof Error && error['stack'] != null) {
+            return error.stack.toString();
+        }
+    }
+    throw new BotdError(-3 /* State.UnexpectedBehaviour */, 'errorTrace signal unexpected behaviour');
+}
+
+function getEvalLength() {
+    return eval.toString().length;
+}
+
+function getFunctionBind() {
+    if (Function.prototype.bind === undefined) {
+        throw new BotdError(-2 /* State.NotFunction */, 'Function.prototype.bind is undefined');
+    }
+    return Function.prototype.bind.toString();
+}
+
+function getBrowserEngineKind() {
+    var _a, _b;
+    // Based on research in October 2020. Tested to detect Chromium 42-86.
+    var w = window;
+    var n = navigator;
+    if (countTruthy([
+        'webkitPersistentStorage' in n,
+        'webkitTemporaryStorage' in n,
+        n.vendor.indexOf('Google') === 0,
+        'webkitResolveLocalFileSystemURL' in w,
+        'BatteryManager' in w,
+        'webkitMediaStream' in w,
+        'webkitSpeechGrammar' in w,
+    ]) >= 5) {
+        return "chromium" /* BrowserEngineKind.Chromium */;
+    }
+    if (countTruthy([
+        'ApplePayError' in w,
+        'CSSPrimitiveValue' in w,
+        'Counter' in w,
+        n.vendor.indexOf('Apple') === 0,
+        'getStorageUpdates' in n,
+        'WebKitMediaKeys' in w,
+    ]) >= 4) {
+        return "webkit" /* BrowserEngineKind.Webkit */;
+    }
+    if (countTruthy([
+        'buildID' in navigator,
+        'MozAppearance' in ((_b = (_a = document.documentElement) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : {}),
+        'onmozfullscreenchange' in w,
+        'mozInnerScreenX' in w,
+        'CSSMozDocumentRule' in w,
+        'CanvasCaptureMediaStream' in w,
+    ]) >= 4) {
+        return "gecko" /* BrowserEngineKind.Gecko */;
+    }
+    return "unknown" /* BrowserEngineKind.Unknown */;
+}
+function getBrowserKind() {
+    var _a;
+    var userAgent = (_a = navigator.userAgent) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (strIncludes(userAgent, 'edg/')) {
+        return "edge" /* BrowserKind.Edge */;
+    }
+    else if (strIncludes(userAgent, 'trident') || strIncludes(userAgent, 'msie')) {
+        return "internet_explorer" /* BrowserKind.IE */;
+    }
+    else if (strIncludes(userAgent, 'wechat')) {
+        return "wechat" /* BrowserKind.WeChat */;
+    }
+    else if (strIncludes(userAgent, 'firefox')) {
+        return "firefox" /* BrowserKind.Firefox */;
+    }
+    else if (strIncludes(userAgent, 'opera') || strIncludes(userAgent, 'opr')) {
+        return "opera" /* BrowserKind.Opera */;
+    }
+    else if (strIncludes(userAgent, 'chrome')) {
+        return "chrome" /* BrowserKind.Chrome */;
+    }
+    else if (strIncludes(userAgent, 'safari')) {
+        return "safari" /* BrowserKind.Safari */;
+    }
+    else {
+        return "unknown" /* BrowserKind.Unknown */;
+    }
+}
+// Source: https://github.com/fingerprintjs/fingerprintjs/blob/master/src/utils/browser.ts#L223
+function isAndroid() {
+    var browserEngineKind = getBrowserEngineKind();
+    var isItChromium = browserEngineKind === "chromium" /* BrowserEngineKind.Chromium */;
+    var isItGecko = browserEngineKind === "gecko" /* BrowserEngineKind.Gecko */;
+    // Only 2 browser engines are presented on Android.
+    // Actually, there is also Android 4.1 browser, but it's not worth detecting it at the moment.
+    if (!isItChromium && !isItGecko)
+        return false;
+    var w = window;
+    // Chrome removes all words "Android" from `navigator` when desktop version is requested
+    // Firefox keeps "Android" in `navigator.appVersion` when desktop version is requested
+    return (countTruthy([
+        'onorientationchange' in w,
+        'orientation' in w,
+        isItChromium && !('SharedWorker' in w),
+        isItGecko && /android/i.test(navigator.appVersion),
+    ]) >= 2);
+}
+function getDocumentFocus() {
+    if (document.hasFocus === undefined) {
+        return false;
+    }
+    return document.hasFocus();
+}
+function isChromium86OrNewer() {
+    // Checked in Chrome 85 vs Chrome 86 both on desktop and Android
+    var w = window;
+    return (countTruthy([
+        !('MediaSettingsRange' in w),
+        'RTCEncodedAudioFrame' in w,
+        '' + w.Intl === '[object Intl]',
+        '' + w.Reflect === '[object Reflect]',
+    ]) >= 3);
+}
+
+function getLanguages() {
+    var n = navigator;
+    var result = [];
+    var language = n.language || n.userLanguage || n.browserLanguage || n.systemLanguage;
+    if (language !== undefined) {
+        result.push([language]);
+    }
+    if (Array.isArray(n.languages)) {
+        var browserEngine = getBrowserEngineKind();
+        // Starting from Chromium 86, there is only a single value in `navigator.language` in Incognito mode:
+        // the value of `navigator.language`. Therefore, the value is ignored in this browser.
+        if (!(browserEngine === "chromium" /* BrowserEngineKind.Chromium */ && isChromium86OrNewer())) {
+            result.push(n.languages);
+        }
+    }
+    else if (typeof n.languages === 'string') {
+        var languages = n.languages;
+        if (languages) {
+            result.push(languages.split(','));
+        }
+    }
+    return result;
+}
+
+function areMimeTypesConsistent() {
+    if (navigator.mimeTypes === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.mimeTypes is undefined');
+    }
+    var mimeTypes = navigator.mimeTypes;
+    var isConsistent = Object.getPrototypeOf(mimeTypes) === MimeTypeArray.prototype;
+    for (var i = 0; i < mimeTypes.length; i++) {
+        isConsistent && (isConsistent = Object.getPrototypeOf(mimeTypes[i]) === MimeType.prototype);
+    }
+    return isConsistent;
+}
+
+function getNotificationPermissions() {
+    return __awaiter(this, void 0, void 0, function () {
+        var permissions, permissionStatus;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (window.Notification === undefined) {
+                        throw new BotdError(-1 /* State.Undefined */, 'window.Notification is undefined');
+                    }
+                    if (navigator.permissions === undefined) {
+                        throw new BotdError(-1 /* State.Undefined */, 'navigator.permissions is undefined');
+                    }
+                    permissions = navigator.permissions;
+                    if (typeof permissions.query !== 'function') {
+                        throw new BotdError(-2 /* State.NotFunction */, 'navigator.permissions.query is not a function');
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, permissions.query({ name: 'notifications' })];
+                case 2:
+                    permissionStatus = _a.sent();
+                    return [2 /*return*/, window.Notification.permission === 'denied' && permissionStatus.state === 'prompt'];
+                case 3:
+                    _a.sent();
+                    throw new BotdError(-3 /* State.UnexpectedBehaviour */, 'notificationPermissions signal unexpected behaviour');
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+function getPluginsArray() {
+    if (navigator.plugins === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.plugins is undefined');
+    }
+    if (window.PluginArray === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'window.PluginArray is undefined');
+    }
+    return navigator.plugins instanceof PluginArray;
+}
+
+function getPluginsLength() {
+    if (navigator.plugins === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.plugins is undefined');
+    }
+    if (navigator.plugins.length === undefined) {
+        throw new BotdError(-3 /* State.UnexpectedBehaviour */, 'navigator.plugins.length is undefined');
+    }
+    return navigator.plugins.length;
+}
+
+function getProcess() {
+    var process = window.process;
+    var errorPrefix = 'window.process is';
+    if (process === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, "".concat(errorPrefix, " undefined"));
+    }
+    if (process && typeof process !== 'object') {
+        throw new BotdError(-3 /* State.UnexpectedBehaviour */, "".concat(errorPrefix, " not an object"));
+    }
+    return process;
+}
+
+function getProductSub() {
+    var productSub = navigator.productSub;
+    if (productSub === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.productSub is undefined');
+    }
+    return productSub;
+}
+
+function getRTT() {
+    if (navigator.connection === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.connection is undefined');
+    }
+    if (navigator.connection.rtt === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.connection.rtt is undefined');
+    }
+    return navigator.connection.rtt;
+}
+
+function getUserAgent() {
+    return navigator.userAgent;
+}
+
+function getWebDriver() {
+    if (navigator.webdriver == undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'navigator.webdriver is undefined');
+    }
+    return navigator.webdriver;
+}
+
+function getWebGL() {
+    var canvasElement = document.createElement('canvas');
+    if (typeof canvasElement.getContext !== 'function') {
+        throw new BotdError(-2 /* State.NotFunction */, 'HTMLCanvasElement.getContext is not a function');
+    }
+    var webGLContext = canvasElement.getContext('webgl');
+    if (webGLContext === null) {
+        throw new BotdError(-4 /* State.Null */, 'WebGLRenderingContext is null');
+    }
+    if (typeof webGLContext.getParameter !== 'function') {
+        throw new BotdError(-2 /* State.NotFunction */, 'WebGLRenderingContext.getParameter is not a function');
+    }
+    var vendor = webGLContext.getParameter(webGLContext.VENDOR);
+    var renderer = webGLContext.getParameter(webGLContext.RENDERER);
+    return { vendor: vendor, renderer: renderer };
+}
+
+function getWindowExternal() {
+    if (window.external === undefined) {
+        throw new BotdError(-1 /* State.Undefined */, 'window.external is undefined');
+    }
+    var external = window.external;
+    if (typeof external.toString !== 'function') {
+        throw new BotdError(-2 /* State.NotFunction */, 'window.external.toString is not a function');
+    }
+    return external.toString();
+}
+
+function getWindowSize() {
+    return {
+        outerWidth: window.outerWidth,
+        outerHeight: window.outerHeight,
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+    };
+}
+
+function checkDistinctiveProperties() {
+    var _a;
+    // The order in the following list matters, because specific types of bots come first, followed by automation technologies.
+    var distinctivePropsList = (_a = {},
+        _a[BotKind.Awesomium] = {
+            window: ['awesomium'],
+        },
+        _a[BotKind.Cef] = {
+            window: ['RunPerfTest'],
+        },
+        _a[BotKind.CefSharp] = {
+            window: ['CefSharp'],
+        },
+        _a[BotKind.CoachJS] = {
+            window: ['emit'],
+        },
+        _a[BotKind.FMiner] = {
+            window: ['fmget_targets'],
+        },
+        _a[BotKind.Geb] = {
+            window: ['geb'],
+        },
+        _a[BotKind.NightmareJS] = {
+            window: ['__nightmare', 'nightmare'],
+        },
+        _a[BotKind.Phantomas] = {
+            window: ['__phantomas'],
+        },
+        _a[BotKind.PhantomJS] = {
+            window: ['callPhantom', '_phantom'],
+        },
+        _a[BotKind.Rhino] = {
+            window: ['spawn'],
+        },
+        _a[BotKind.Selenium] = {
+            window: ['_Selenium_IDE_Recorder', '_selenium', 'calledSelenium', /^([a-z]){3}_.*_(Array|Promise|Symbol)$/],
+            document: ['__selenium_evaluate', 'selenium-evaluate', '__selenium_unwrapped'],
+        },
+        _a[BotKind.WebDriverIO] = {
+            window: ['wdioElectron'],
+        },
+        _a[BotKind.WebDriver] = {
+            window: [
+                'webdriver',
+                '__webdriverFunc',
+                '__lastWatirAlert',
+                '__lastWatirConfirm',
+                '__lastWatirPrompt',
+                '_WEBDRIVER_ELEM_CACHE',
+                'ChromeDriverw',
+            ],
+            document: [
+                '__webdriver_script_fn',
+                '__driver_evaluate',
+                '__webdriver_evaluate',
+                '__fxdriver_evaluate',
+                '__driver_unwrapped',
+                '__webdriver_unwrapped',
+                '__fxdriver_unwrapped',
+                '__webdriver_script_fn',
+                '__webdriver_script_func',
+                '__webdriver_script_function',
+                '$cdc_asdjflasutopfhvcZLmcf',
+                '$cdc_asdjflasutopfhvcZLmcfl_',
+                '$chrome_asyncScriptInfo',
+                '__$webdriverAsyncExecutor',
+            ],
+        },
+        _a[BotKind.HeadlessChrome] = {
+            window: ['domAutomation', 'domAutomationController'],
+        },
+        _a);
+    var botName;
+    var result = {};
+    var windowProps = getObjectProps(window);
+    var documentProps = [];
+    if (window.document !== undefined)
+        documentProps = getObjectProps(window.document);
+    for (botName in distinctivePropsList) {
+        var props = distinctivePropsList[botName];
+        if (props !== undefined) {
+            var windowContains = props.window === undefined ? false : includes.apply(void 0, __spreadArray([windowProps], props.window, false));
+            var documentContains = props.document === undefined || !documentProps.length ? false : includes.apply(void 0, __spreadArray([documentProps], props.document, false));
+            result[botName] = windowContains || documentContains;
+        }
+    }
+    return result;
+}
+
+var sources = {
+    android: isAndroid,
+    browserKind: getBrowserKind,
+    browserEngineKind: getBrowserEngineKind,
+    documentFocus: getDocumentFocus,
+    userAgent: getUserAgent,
+    appVersion: getAppVersion,
+    rtt: getRTT,
+    windowSize: getWindowSize,
+    pluginsLength: getPluginsLength,
+    pluginsArray: getPluginsArray,
+    errorTrace: getErrorTrace,
+    productSub: getProductSub,
+    windowExternal: getWindowExternal,
+    mimeTypesConsistent: areMimeTypesConsistent,
+    evalLength: getEvalLength,
+    webGL: getWebGL,
+    webDriver: getWebDriver,
+    languages: getLanguages,
+    notificationPermissions: getNotificationPermissions,
+    documentElementKeys: getDocumentElementKeys,
+    functionBind: getFunctionBind,
+    process: getProcess,
+    distinctiveProps: checkDistinctiveProperties,
+};
+
+/**
+ * Class representing a bot detector.
+ *
+ * @class
+ * @implements {BotDetectorInterface}
+ */
+var BotDetector = /** @class */ (function () {
+    function BotDetector() {
+        this.components = undefined;
+        this.detections = undefined;
+    }
+    BotDetector.prototype.getComponents = function () {
+        return this.components;
+    };
+    BotDetector.prototype.getDetections = function () {
+        return this.detections;
+    };
+    /**
+     * @inheritdoc
+     */
+    BotDetector.prototype.detect = function () {
+        if (this.components === undefined) {
+            throw new Error("BotDetector.detect can't be called before BotDetector.collect");
+        }
+        var _a = detect(this.components, detectors), detections = _a[0], finalDetection = _a[1];
+        this.detections = detections;
+        return finalDetection;
+    };
+    /**
+     * @inheritdoc
+     */
+    BotDetector.prototype.collect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, collect(sources)];
+                    case 1:
+                        _a.components = _b.sent();
+                        return [2 /*return*/, this.components];
+                }
+            });
+        });
+    };
+    return BotDetector;
+}());
+
+/**
+ * Sends an unpersonalized AJAX request to collect installation statistics
+ */
+function monitor() {
+    // The FingerprintJS CDN (https://github.com/fingerprintjs/cdn) replaces `window.__fpjs_d_m` with `true`
+    if (window.__fpjs_d_m || Math.random() >= 0.001) {
+        return;
+    }
+    try {
+        var request = new XMLHttpRequest();
+        request.open('get', "https://m1.openfpcdn.io/botd/v".concat(version, "/npm-monitoring"), true);
+        request.send();
+    }
+    catch (error) {
+        // console.error is ok here because it's an unexpected error handler
+        // eslint-disable-next-line no-console
+        console.error(error);
+    }
+}
+function load(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.monitoring, monitoring = _c === void 0 ? true : _c;
+    return __awaiter(this, void 0, void 0, function () {
+        var detector;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (monitoring) {
+                        monitor();
+                    }
+                    detector = new BotDetector();
+                    return [4 /*yield*/, detector.collect()];
+                case 1:
+                    _d.sent();
+                    return [2 /*return*/, detector];
+            }
+        });
+    });
+}
+
+const useBotDetection = () => {
+    const [result, setResult] = useState({
+        isBot: false,
+        reasons: []
+    });
+    useEffect(() => {
+        const detectBot = async () => {
+            try {
+                // Load and initialize BotD
+                const botd = await load();
+                const detectionResult = await botd.detect();
+                const isBot = detectionResult.bot;
+                const reasons = isBot ? ['FingerprintJS BotD detected automation'] : [];
+                setResult({
+                    isBot,
+                    reasons
+                });
+            }
+            catch (error) {
+                // If BotD fails to load, assume human user (fail open for better UX)
+                console.warn('BotD detection failed, assuming human user:', error);
+                setResult({
+                    isBot: false,
+                    reasons: ['BotD failed to load - assuming human']
+                });
+            }
+        };
+        detectBot();
+    }, []);
+    return result;
+};
+
+const useViewability = (options = {}) => {
+    const { threshold = 0.5, durationMs = 1000, onImpressionTracked } = options;
+    const elementRef = useRef(null);
+    const [isViewable, setIsViewable] = useState(false);
+    const [hasBeenViewed, setHasBeenViewed] = useState(false);
+    const [impressionTracked, setImpressionTracked] = useState(false);
+    const [viewableStartTime, setViewableStartTime] = useState(null);
+    const [hasMetDuration, setHasMetDuration] = useState(false);
+    useEffect(() => {
+        if (!elementRef.current)
+            return;
+        const observer = new IntersectionObserver(([entry]) => {
+            const viewable = entry.intersectionRatio >= threshold;
+            const now = Date.now();
+            if (viewable) {
+                if (viewableStartTime === null) {
+                    setViewableStartTime(now);
+                }
+                setIsViewable(true);
+                if (!hasBeenViewed) {
+                    setHasBeenViewed(true);
+                }
+            }
+            else {
+                setViewableStartTime(null);
+                setIsViewable(false);
+                setHasMetDuration(false);
+            }
+        }, {
+            threshold,
+            rootMargin: '0px'
+        });
+        observer.observe(elementRef.current);
+        return () => observer.disconnect();
+    }, [threshold, hasBeenViewed, viewableStartTime]);
+    // Duration tracking effect
+    useEffect(() => {
+        if (!isViewable || viewableStartTime === null || hasMetDuration)
+            return;
+        const timeoutId = setTimeout(() => {
+            if (isViewable && viewableStartTime !== null) {
+                const elapsed = Date.now() - viewableStartTime;
+                if (elapsed >= durationMs) {
+                    setHasMetDuration(true);
+                }
+            }
+        }, durationMs);
+        return () => clearTimeout(timeoutId);
+    }, [isViewable, viewableStartTime, durationMs, hasMetDuration]);
+    const trackImpression = (adId) => {
+        if (impressionTracked)
+            return;
+        setImpressionTracked(true);
+        if (onImpressionTracked && adId) {
+            onImpressionTracked(adId);
+        }
+    };
+    return {
+        elementRef,
+        isViewable: isViewable && hasMetDuration, // MRC-compliant viewability (with duration)
+        isInstantViewable: isViewable, // Instant viewability (no duration requirement)
+        hasBeenViewed,
+        impressionTracked,
+        trackImpression
+    };
+};
+
+// Font definitions
+const fonts = {
+    'san-serif': {
+        primary: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+        secondary: 'system-ui, -apple-system, sans-serif'
+    },
+    'serif': {
+        primary: 'Georgia, "Times New Roman", Times, serif',
+        secondary: '"Hoefler Text", "Baskerville Old Face", Garamond, serif'
+    },
+    'monospace': {
+        primary: '"SF Mono", Monaco, "Inconsolata", "Roboto Mono", "Source Code Pro", Consolas, "Courier New", monospace',
+        secondary: 'ui-monospace, Menlo, monospace'
+    }
+};
+// Modal color themes - only two options based on theme mode
+const colorCombinations = {
+    'light': {
+        background: '#ffffff',
+        text: '#1e293b',
+        primary: '#3b82f6',
+        primaryHover: '#2563eb',
+        border: '#e2e8f0'
+    },
+    'dark': {
+        background: '#0f172a',
+        text: '#f1f5f9',
+        primary: '#60a5fa',
+        primaryHover: '#3b82f6',
+        border: '#475569'
+    }
+};
+// Function to get the appropriate theme based on theme mode
+// Accent is ignored - modal always uses consistent colors based on light/dark theme
+function getColorTheme(themeMode, _accent) {
+    // Handle auto theme by detecting system preference
+    let resolvedTheme = themeMode;
+    if (themeMode === 'auto') {
+        resolvedTheme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+    }
+    // Return the theme color, fallback to light
+    return colorCombinations[resolvedTheme] || colorCombinations['light'];
+}
+// Helper functions for styling
+const getSolidBackground = (colors) => {
+    return colors.background;
+};
+const getBackgroundGradient = (colors) => {
+    // No longer using gradients, just return solid background
+    return colors.background;
+};
+const getTextMuted = (colors) => {
+    // Use a slightly muted version of the text color
+    return colors.text + 'aa'; // Add alpha for slight transparency
+};
+const getTextSecondary = (colors) => {
+    // Not used anymore, but keeping for compatibility
+    return colors.text;
+};
+const getBorderLight = (colors) => {
+    return colors.border;
+};
+const getShadow = (colors) => {
+    return 'rgba(0, 0, 0, 0.1)';
+};
+const getFontStyles = (font = 'san-serif') => {
+    return fonts[font] || fonts['san-serif'];
+};
+
+const createInChatAdSlotCSS = (theme = {}) => {
+    const { theme: themeMode = 'light', accent = 'blue', font = 'san-serif', width = 'auto', } = theme;
+    // If accent or font is an array, use the first value for styling
+    Array.isArray(accent) ? accent[0] : accent;
+    const effectiveFont = Array.isArray(font) ? font[0] : font;
+    const colors = getColorTheme(themeMode);
+    const fonts = getFontStyles(effectiveFont);
+    // Fixed dimensions
+    const minWidth = 320;
+    const fixedHeight = 265;
+    // Handle width calculation
+    const getWidthCSS = () => {
+        if (width === 'auto') {
+            return '100%';
+        }
+        if (typeof width === 'string') {
+            // For percentage values and other CSS units, use as-is
+            return width;
+        }
+        return `${width}px`;
+    };
+    return `
+    .simula-content-slot {
+      width: ${getWidthCSS()};
+      min-width: ${minWidth}px;
+      height: ${fixedHeight}px;
+      margin: 0px;
+      line-height: 1.5;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .simula-content-slot * {
+      margin: 0;
+      padding: 0;
+    }
+
+    .simula-content-frame {
+      width: 100%;
+      height: 100%;
+      border: none;
+      outline: none;
+      box-shadow: none;
+      border-radius: 0;
+      background: transparent;
+      display: block;
+      margin: 0;
+      padding: 0;
+      position: relative;
+      vertical-align: top;
+    }
+
+    .simula-info-icon {
+      position: absolute;
+      top: 12;
+      right: 12px;
+      background: none;
+      border: none;
+      color: ${colors.text};
+      opacity: 0.5;
+      cursor: pointer;
+      padding: 6px;
+      border-radius: 50%;
+      transition: all 0.2s ease;
+      z-index: 10;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .simula-info-icon:hover {
+      opacity: 1;
+      transform: scale(1.1);
+    }
+
+    .simula-modal-overlay {
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.5);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 1000;
+    }
+
+    .simula-modal-content {
+      background: ${getSolidBackground(colors)};
+      border-radius: 8px;
+      padding: 16px;
+      width: 75%;
+      min-width: 200px;
+      max-width: 431px;
+      margin: 16px;
+      position: relative;
+      box-shadow: 0 4px 12px ${getShadow()};
+      font-family: ${fonts.primary};
+      line-height: 1.5;
+      color: ${colors.text};
+      font-size: 14px;
+      border: 1px solid ${colors.border};
+    }
+
+    .simula-modal-close {
+      position: absolute;
+      top: 8px;
+      right: 12px;
+      background: none;
+      border: none;
+      font-size: 24px;
+      cursor: pointer;
+      color: ${getTextMuted(colors)};
+      padding: 4px;
+      line-height: 1;
+    }
+
+    .simula-modal-close:hover {
+      color: ${colors.text};
+    }
+
+    .simula-modal-link {
+      color: ${colors.primary};
+      text-decoration: underline;
+    }
+
+    .simula-modal-link:hover {
+      color: ${colors.primaryHover};
+      text-decoration: underline;
+    }
+
+    .simula-content-label {
+      font-size: 10px;
+      color: ${getTextMuted(colors)};
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 8px;
+      display: block;
+    }
+  `;
+};
+
+// Internal constant to prevent API abuse
+const MIN_FETCH_INTERVAL_MS = 1000; // 1 second minimum between fetches
+// Helper functions for width validation
+const isAutoWidth = (width) => width === 'auto';
+const isPercentageWidth = (width) => typeof width === 'string' && /^\d+(?:\.\d+)?%$/.test(width);
+const needsWidthMeasurement = (width) => isAutoWidth(width) || isPercentageWidth(width);
+// Validate messages array has actual content
+const hasValidMessages = (messages) => {
+    return messages.length > 0 && messages.some(msg => msg && msg.content && msg.content.trim().length > 0);
+};
+const InChatAdSlot = (props) => {
+    // Validate props early
+    validateInChatAdSlotProps(props);
+    const { messages, trigger, formats: formatsRaw = ['all'], theme = {}, debounceMs = 0, charDesc, onImpression, onClick, onError, } = props;
+    // Normalize formats to array (similar to theme.accent and theme.font)
+    const formats = Array.isArray(formatsRaw) ? formatsRaw : [formatsRaw];
+    const { apiKey, sessionId } = useSimula();
+    // Generate a stable slotId for this component instance
+    const slotId = useMemo(() => `slot-${v4()}`, []);
+    const [ad, setAd] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [shouldFetch, setShouldFetch] = useState(false);
+    const [showInfoModal, setShowInfoModal] = useState(false);
+    const [iframeLoaded, setIframeLoaded] = useState(false);
+    const [measuredWidth, setMeasuredWidth] = useState(null);
+    // Track if this AdSlot has already been triggered
+    const [hasTriggered, setHasTriggered] = useState(false);
+    const [triggerUsed, setTriggerUsed] = useState(null);
+    const lastFetchTimeRef = useRef(0);
+    const styleElementRef = useRef(null);
+    const { elementRef, hasBeenViewed, isViewable, // MRC-compliant (1 second duration)
+    trackImpression: viewabilityTrackImpression } = useViewability({
+        threshold: 0.5,
+        durationMs: 1000, // 1 second for MRC compliance
+        onImpressionTracked: (adId) => {
+            // This gets called after impression tracking
+            trackImpression(adId, apiKey);
+            if (ad) {
+                onImpression === null || onImpression === void 0 ? void 0 : onImpression(ad);
+            }
+        }
+    });
+    const { isBot, reasons } = useBotDetection();
+    // Measure actual width once when element is ready
+    useEffect(() => {
+        const currentWidth = theme.width;
+        // If no width is configured at all, skip measurement
+        if (currentWidth === undefined)
+            return;
+        // Only measure if it's 'auto' or a percentage value
+        const needsMeasurement = needsWidthMeasurement(currentWidth);
+        if (!needsMeasurement)
+            return;
+        if (!elementRef.current)
+            return;
+        // Track if already measured to prevent re-observation
+        let hasMeasured = false;
+        // Use ResizeObserver to get the initial size
+        const resizeObserver = new ResizeObserver(entries => {
+            const entry = entries[0];
+            if (entry && !hasMeasured) {
+                hasMeasured = true;
+                const width = Math.round(entry.contentRect.width);
+                setMeasuredWidth(width);
+                // Disconnect after first measurement
+                resizeObserver.disconnect();
+            }
+        });
+        resizeObserver.observe(elementRef.current);
+        return () => {
+            resizeObserver.disconnect();
+        };
+    }, [theme.width, elementRef]);
+    const fetchAdData = useCallback(async () => {
+        if (!hasBeenViewed || loading || hasTriggered || error) {
+            return;
+        }
+        // Block if sessionId is missing or invalid
+        if (!sessionId) {
+            setError('Session invalid, fetch ad request blocked');
+            console.error('Session invalid, fetch ad request blocked');
+            return;
+        }
+        // Wait for width measurement when using auto or percentage values
+        const currentWidth = theme.width;
+        const needsMeasurement = needsWidthMeasurement(currentWidth);
+        if (needsMeasurement && measuredWidth === null) {
+            return;
+        }
+        // Block ad requests from detected bots
+        if (isBot) {
+            console.warn('Bot detected, blocking ad request:', { reasons });
+            return;
+        }
+        const now = Date.now();
+        if (now - lastFetchTimeRef.current < MIN_FETCH_INTERVAL_MS) {
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        lastFetchTimeRef.current = now;
+        try {
+            // Validate width before making API call
+            const currentConfiguredWidth = theme.width;
+            const minWidth = 320;
+            // Check width bounds (numeric or px string)
+            let widthValue = null;
+            if (typeof currentConfiguredWidth === 'number') {
+                widthValue = currentConfiguredWidth;
+            }
+            else if (typeof currentConfiguredWidth === 'string') {
+                const pxMatch = currentConfiguredWidth.match(/^(\d+(?:\.\d+)?)px$/);
+                if (pxMatch) {
+                    widthValue = parseFloat(pxMatch[1]);
+                }
+            }
+            // Validate minimum width if we have a concrete value
+            if (widthValue !== null && widthValue < minWidth) {
+                console.error(`AdSlot width ${widthValue}px is below minimum ${minWidth}px. Skipping ad request.`);
+                setError(`Invalid width: ${widthValue}px (minimum: ${minWidth}px)`);
+                setLoading(false);
+                return;
+            }
+            // Create theme with measured width for backend
+            const themeForBackend = { ...theme };
+            // Convert the current width to pixels for backend - always send as 'width'
+            if (typeof currentConfiguredWidth === "string") {
+                // Check if it's a px string like "400px"
+                const pxMatch = currentConfiguredWidth.match(/^(\d+(?:\.\d+)?)px$/);
+                if (pxMatch) {
+                    // Convert "400px" to 400
+                    themeForBackend.width = parseFloat(pxMatch[1]);
+                }
+                else if (measuredWidth !== null) {
+                    // For 'auto' and percentages, use measured width
+                    // If measured width is below minimum, use minimum
+                    const finalWidth = measuredWidth < minWidth ? minWidth : measuredWidth;
+                    themeForBackend.width = finalWidth;
+                }
+            }
+            else if (typeof currentConfiguredWidth === "number") {
+                // Already a number, just use it
+                themeForBackend.width = currentConfiguredWidth;
+            }
+            const result = await fetchAd({
+                messages,
+                formats,
+                apiKey,
+                slotId,
+                theme: themeForBackend,
+                sessionId,
+                charDesc,
+            });
+            if (result.error) {
+                console.warn('🚫 Ad fetch failed:', result.error);
+                setError(result.error);
+                onError === null || onError === void 0 ? void 0 : onError(new Error(result.error));
+            }
+            else if (result.ad) {
+                setAd(result.ad);
+                // Mark as triggered - this AdSlot will never fetch again
+                setHasTriggered(true);
+            }
+            else {
+                console.warn('🚫 No ad returned from API - no fill or invalid response');
+                setError('No ad available');
+                onError === null || onError === void 0 ? void 0 : onError(new Error('No ad available'));
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to fetch ad';
+            setError(errorMessage);
+            onError === null || onError === void 0 ? void 0 : onError(new Error(errorMessage));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [hasBeenViewed, loading, hasTriggered, error, messages, formats, apiKey, slotId, theme, onError, isBot, reasons, sessionId, measuredWidth]);
+    useDebounce(() => {
+        if (shouldFetch) {
+            fetchAdData();
+            setShouldFetch(false);
+        }
+    }, debounceMs, [shouldFetch, fetchAdData]);
+    // Handle trigger promise resolution/rejection
+    useEffect(() => {
+        if (hasTriggered)
+            return;
+        if (!trigger)
+            return;
+        if (trigger === triggerUsed)
+            return;
+        setTriggerUsed(trigger);
+        trigger
+            .then(() => {
+            if (!hasTriggered) {
+                setShouldFetch(true);
+            }
+        })
+            .catch(() => {
+            if (!hasTriggered) {
+                setShouldFetch(true);
+            }
+        });
+    }, [trigger, triggerUsed, hasTriggered]);
+    // Consolidated trigger logic - checks all conditions before fetching
+    useEffect(() => {
+        // Don't trigger if already triggered
+        if (hasTriggered)
+            return;
+        // Don't trigger if no valid messages
+        if (!hasValidMessages(messages))
+            return;
+        // Don't trigger if waiting for trigger promise
+        if (trigger && !triggerUsed)
+            return;
+        // Don't trigger if not viewed yet
+        if (!hasBeenViewed)
+            return;
+        // Don't trigger if waiting for width measurement
+        const needsMeasurement = typeof theme.width === "string" && needsWidthMeasurement(theme.width);
+        if (needsMeasurement && measuredWidth === null)
+            return;
+        // All conditions met, trigger fetch
+        setShouldFetch(true);
+    }, [hasBeenViewed, hasTriggered, triggerUsed, trigger, measuredWidth, theme.width, messages]);
+    useEffect(() => {
+        if (ad && isViewable && !isBot && iframeLoaded) {
+            viewabilityTrackImpression(ad.id); // Track impression when viewable AND iframe loaded
+        }
+    }, [ad, isViewable, isBot, iframeLoaded, viewabilityTrackImpression]);
+    useEffect(() => {
+        // Create style element once on mount
+        if (!styleElementRef.current) {
+            styleElementRef.current = document.createElement('style');
+            styleElementRef.current.setAttribute('data-simula-styles', 'true');
+            document.head.appendChild(styleElementRef.current);
+        }
+        // Update CSS content whenever theme changes
+        const css = createInChatAdSlotCSS(theme);
+        styleElementRef.current.textContent = css;
+        // Cleanup only on unmount
+        return () => {
+            if (styleElementRef.current && document.head.contains(styleElementRef.current)) {
+                document.head.removeChild(styleElementRef.current);
+                styleElementRef.current = null;
+            }
+        };
+    }, [theme]);
+    const renderContent = () => {
+        if (loading) {
+            return null;
+        }
+        if (error) {
+            return null;
+        }
+        if (!ad || !ad.iframeUrl) {
+            return null;
+        }
+        return (jsxs("div", { className: "simula-content-slot", onClick: () => onClick === null || onClick === void 0 ? void 0 : onClick(ad), style: { cursor: onClick ? 'pointer' : 'default' }, children: [jsx("iframe", { src: ad.iframeUrl, className: "simula-content-frame", style: { display: 'block', verticalAlign: 'top', border: 0, margin: 0, padding: 0, width: '100%' }, frameBorder: "0", scrolling: "no", allowTransparency: true, sandbox: "allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox", title: `Content: ${ad.id}`, onLoad: () => {
+                        // Iframe loaded - now impressions can be tracked
+                        setIframeLoaded(true);
+                    } }), jsx("button", { className: "simula-info-icon", onClick: (e) => {
+                        e.stopPropagation();
+                        setShowInfoModal(true);
+                    }, "aria-label": "Content information", children: jsxs("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: [jsx("circle", { cx: "8", cy: "8", r: "7", stroke: "currentColor", strokeWidth: "1", fill: "none" }), jsx("text", { x: "8", y: "12", textAnchor: "middle", fontSize: "10", fontFamily: "serif", children: "i" })] }) }), showInfoModal && (jsx("div", { className: "simula-modal-overlay", onClick: () => setShowInfoModal(false), children: jsxs("div", { className: "simula-modal-content", onClick: (e) => e.stopPropagation(), children: [jsx("button", { className: "simula-modal-close", onClick: () => setShowInfoModal(false), "aria-label": "Close", children: "\u00D7" }), jsxs("p", { children: ["Powered by", ' ', jsx("a", { href: "https://simula.ad", target: "_blank", rel: "noopener noreferrer", className: "simula-modal-link", children: "Simula" })] })] }) }))] }));
+    };
+    return (jsx("div", { ref: elementRef, style: {
+            display: error ? 'none' : 'block',
+            minWidth: ad && ad.id ? '320px' : '0px',
+            width: !theme.width || theme.width === 'auto' ? '100%' : theme.width,
+            height: ad && ad.id ? '265px' : '0px',
+            overflow: 'hidden'
+        }, children: renderContent() }));
+};
+
+const useOMIDViewability = (options = {}) => {
+    const { threshold = 0.5, durationMs = 1000, partnerName = 'Simula-Ad-SDK', partnerVersion = '1.0.0', onImpressionTracked } = options;
+    const elementRef = useRef(null);
+    const [isViewable, setIsViewable] = useState(false);
+    const [hasBeenViewed, setHasBeenViewed] = useState(false);
+    const [impressionTracked, setImpressionTracked] = useState(false);
+    const [viewableStartTime, setViewableStartTime] = useState(null);
+    const [hasMetDuration, setHasMetDuration] = useState(false);
+    const omidSessionRef = useRef(null);
+    const adEventsRef = useRef(null);
+    useEffect(() => {
+        if (!elementRef.current)
+            return;
+        // Initialize OMID Session
+        const initializeOMID = async () => {
+            var _a;
+            try {
+                // Load OMID Service Script dynamically if not already loaded
+                if (!window.omidSessionClient) {
+                    await loadOMIDServiceScript();
+                }
+                const sessionClient = (_a = window.omidSessionClient) === null || _a === void 0 ? void 0 : _a['1.0.0'];
+                if (!sessionClient) {
+                    console.warn('OMID Session Client not available, falling back to basic viewability');
+                    initializeFallbackViewability();
+                    return;
+                }
+                // Create OMID partner and context
+                const Partner = sessionClient.Partner;
+                const Context = sessionClient.Context;
+                const AdSession = sessionClient.AdSession;
+                const AdEvents = sessionClient.AdEvents;
+                const partner = new Partner(partnerName, partnerVersion);
+                const context = new Context(partner, [], null); // No verification scripts for now
+                // Create ad session
+                const adSession = new AdSession(context);
+                adSession.setCreativeType('display');
+                adSession.setImpressionType('beginToRender');
+                omidSessionRef.current = adSession;
+                // Set the ad view
+                context.setSlotElement(elementRef.current);
+                // Start session
+                adSession.start();
+                // Create ad events handler
+                adEventsRef.current = new AdEvents(adSession);
+                // Register session observer for viewability events
+                adSession.registerSessionObserver((event) => {
+                    var _a;
+                    switch (event.type) {
+                        case 'sessionStart':
+                            // Signal ad loaded
+                            (_a = adEventsRef.current) === null || _a === void 0 ? void 0 : _a.loaded();
+                            break;
+                        case 'sessionError':
+                            console.error('OMID session error:', event.data);
+                            initializeFallbackViewability();
+                            break;
+                        case 'sessionFinish':
+                            break;
+                        case 'geometryChange':
+                            handleGeometryChange(event.data);
+                            break;
+                    }
+                });
+            }
+            catch (error) {
+                console.warn('OMID initialization failed, using fallback:', error);
+                initializeFallbackViewability();
+            }
+        };
+        const loadOMIDServiceScript = async () => {
+            return new Promise((resolve, reject) => {
+                // Check if script is already loaded
+                if (document.querySelector('script[src*="omweb-v1.js"]')) {
+                    resolve();
+                    return;
+                }
+                const script = document.createElement('script');
+                script.src = 'https://s0.2mdn.net/instream/omweb/omweb-v1.js'; // Official OMID Service Script
+                script.async = true;
+                script.onload = () => resolve();
+                script.onerror = () => reject(new Error('Failed to load OMID script'));
+                document.head.appendChild(script);
+            });
+        };
+        const handleGeometryChange = (geometryData) => {
+            if (!(geometryData === null || geometryData === void 0 ? void 0 : geometryData.viewport) || !(geometryData === null || geometryData === void 0 ? void 0 : geometryData.adView))
+                return;
+            const { viewport, adView } = geometryData;
+            // Calculate viewable area
+            const viewableArea = calculateViewableArea(viewport, adView);
+            const totalArea = adView.width * adView.height;
+            const viewablePercentage = totalArea > 0 ? viewableArea / totalArea : 0;
+            const newIsViewable = viewablePercentage >= threshold;
+            const now = Date.now();
+            if (newIsViewable) {
+                if (viewableStartTime === null) {
+                    setViewableStartTime(now);
+                }
+                setIsViewable(true);
+                if (!hasBeenViewed) {
+                    setHasBeenViewed(true);
+                }
+            }
+            else {
+                setViewableStartTime(null);
+                setIsViewable(false);
+                setHasMetDuration(false);
+            }
+        };
+        const calculateViewableArea = (viewport, adView) => {
+            const intersectionLeft = Math.max(viewport.x, adView.x);
+            const intersectionTop = Math.max(viewport.y, adView.y);
+            const intersectionRight = Math.min(viewport.x + viewport.width, adView.x + adView.width);
+            const intersectionBottom = Math.min(viewport.y + viewport.height, adView.y + adView.height);
+            const width = Math.max(0, intersectionRight - intersectionLeft);
+            const height = Math.max(0, intersectionBottom - intersectionTop);
+            return width * height;
+        };
+        // Fallback implementation using Intersection Observer
+        const initializeFallbackViewability = () => {
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    const newIsViewable = entry.intersectionRatio >= threshold;
+                    const now = Date.now();
+                    if (newIsViewable) {
+                        if (viewableStartTime === null) {
+                            setViewableStartTime(now);
+                        }
+                        setIsViewable(true);
+                        if (!hasBeenViewed) {
+                            setHasBeenViewed(true);
+                        }
+                    }
+                    else {
+                        setViewableStartTime(null);
+                        setIsViewable(false);
+                        setHasMetDuration(false);
+                    }
+                });
+            }, {
+                threshold,
+                rootMargin: '0px'
+            });
+            if (elementRef.current) {
+                observer.observe(elementRef.current);
+            }
+            return () => {
+                observer.disconnect();
+            };
+        };
+        initializeOMID();
+        // Cleanup
+        return () => {
+            if (omidSessionRef.current) {
+                try {
+                    omidSessionRef.current.finish();
+                }
+                catch (error) {
+                    console.warn('Error finishing OMID session:', error);
+                }
+            }
+        };
+    }, [threshold, partnerName, partnerVersion, hasBeenViewed, viewableStartTime]);
+    // Duration tracking effect
+    useEffect(() => {
+        if (!isViewable || viewableStartTime === null || hasMetDuration)
+            return;
+        const timeoutId = setTimeout(() => {
+            if (isViewable && viewableStartTime !== null) {
+                const elapsed = Date.now() - viewableStartTime;
+                if (elapsed >= durationMs) {
+                    setHasMetDuration(true);
+                }
+            }
+        }, durationMs);
+        return () => clearTimeout(timeoutId);
+    }, [isViewable, viewableStartTime, durationMs, hasMetDuration]);
+    const trackImpression = (adId) => {
+        if (impressionTracked)
+            return;
+        if (adEventsRef.current) {
+            // Use OMID impression tracking
+            try {
+                adEventsRef.current.impressionOccurred();
+                setImpressionTracked(true);
+                // After OMID tracks successfully, ping our backend
+                if (onImpressionTracked && adId) {
+                    onImpressionTracked(adId);
+                }
+            }
+            catch (error) {
+                console.warn('OMID impression tracking failed:', error);
+                setImpressionTracked(true); // Mark as tracked to prevent retries
+            }
+        }
+        else {
+            // Fallback impression tracking
+            setImpressionTracked(true);
+            // Still ping our backend even in fallback mode
+            if (onImpressionTracked && adId) {
+                onImpressionTracked(adId);
+            }
+        }
+    };
+    return {
+        elementRef,
+        isViewable: isViewable && hasMetDuration, // Only considered viewable after meeting duration
+        hasBeenViewed,
+        impressionTracked,
+        trackImpression
+    };
+};
+
+export { InChatAdSlot, SimulaProvider, fonts, getBackgroundGradient, getBorderLight, getColorTheme, getFontStyles, getShadow, getSolidBackground, getTextMuted, getTextSecondary, useBotDetection, useOMIDViewability, useSimula, useViewability };
+//# sourceMappingURL=index.mjs.map