mogultv/assets/background-c101863b.js

(function() {
    'use strict';

    function captureEvents(events) {
        const captured = events.map(captureEvent);

        return () => captured.forEach((t) => t())

        function captureEvent(event) {
            let isCapturePhase = true;

            // eslint-disable-next-line @typescript-eslint/ban-types
            const callbacks = new Map();
            const eventArgs = new Set();

            // This is the only listener for the native event
            event.addListener(handleEvent);

            function handleEvent(...args) {
                if (isCapturePhase) {
                    // This is before dynamic import completes
                    eventArgs.add(args);

                    if (typeof args[2] === 'function') {
                        // During capture phase all messages are async
                        return true
                    } else {
                        // Sync messages or some other event
                        return false
                    }
                } else {
                    // The callbacks determine the listener return value
                    return callListeners(...args)
                }
            }

            // Called when dynamic import is complete
            //  and when subsequent events fire
            function callListeners(...args) {
                let isAsyncCallback = false;
                callbacks.forEach((options, cb) => {
                    // A callback error should not affect the other callbacks
                    try {
                        isAsyncCallback = cb(...args) || isAsyncCallback;
                    } catch (error) {
                        console.error(error);
                    }
                });

                if (!isAsyncCallback && typeof args[2] === 'function') {
                    // We made this an async message callback during capture phase
                    //   when the function handleEvent returned true
                    //   so we are responsible to call sendResponse
                    // If the callbacks are sync message callbacks
                    //   the sendMessage callback on the other side
                    //   resolves with no arguments (this is the same behavior)
                    args[2]();
                }

                // Support events after import is complete
                return isAsyncCallback
            }

            // This function will trigger this Event with our stored args
            function triggerEvents() {
                // Fire each event for this Event
                eventArgs.forEach((args) => {
                    callListeners(...args);
                });

                // Dynamic import is complete
                isCapturePhase = false;
                // Don't need these anymore
                eventArgs.clear();
            }

            // All future listeners are handled by our code
            event.addListener = function addListener(cb, ...options) {
                callbacks.set(cb, options);
            };

            event.hasListeners = function hasListeners() {
                return callbacks.size > 0
            };

            event.hasListener = function hasListener(cb) {
                return callbacks.has(cb)
            };

            event.removeListener = function removeListener(cb) {
                callbacks.delete(cb);
            };

            event.__isCapturedEvent = true;

            return triggerEvents
        }
    }

    function delay(ms) {
        return new Promise((resolve) => {
            setTimeout(resolve, ms);
        })
    }

    /**
     * Get matches from an object of nested objects
     *
     * @export
     * @template T Type of matches
     * @param {*} object Parent object to search
     * @param {(x: any) => boolean} pred A predicate function that will receive each property value of an object
     * @param {string[]} excludeKeys Exclude a property if the key exactly matches
     * @returns {T[]} The matched values from the parent object
     */
    function getDeepMatches(object, pred, excludeKeys) {
        const keys = typeof object === 'object' && object ? Object.keys(object) : [];

        return keys.length ?
            keys
            .filter((key) => !excludeKeys.includes(key))
            .reduce((r, key) => {
                const target = object[key];

                if (target && pred(target)) {
                    return [...r, target]
                } else {
                    return [...r, ...getDeepMatches(target, pred, excludeKeys)]
                }
            }, []) :
            []
    }

    const importPath = /*@__PURE__*/ JSON.parse('"../background.js"');
    const delayLength = /*@__PURE__*/ JSON.parse('0');
    const excludedPaths = /*@__PURE__*/ JSON.parse('["extension"]');

    const events = getDeepMatches(
        chrome,
        (x) => typeof x === 'object' && 'addListener' in x,
        // The webRequest API is not compatible with event pages
        //  TODO: this can be removed
        //   if we stop using this wrapper with "webRequest" permission
        excludedPaths.concat(['webRequest']),
    );
    const triggerEvents = captureEvents(events);

    import(importPath).then(async () => {
        if (delayLength) await delay(delayLength);

        triggerEvents();
    });

}());