/******/ var __webpack_modules__ = ({

/***/ "./src/config.js":
/*!***********************!*\
  !*** ./src/config.js ***!
  \***********************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    production: 'cr-production',
    vilo: 'https://static.crunchyroll.com/vilos',
    clientId: 'xunihvedbt3mbisuhevt',
    clientSecret: '1kIS5dyTvjE0_rqaA3YeAh0bUXUmxW11',
    clientIdSso: 'ltccxd10yl6cqcn1acx1',
    url: 'https://www.crunchyroll.com',
    urlBeta: 'https://beta-api.crunchyroll.com',
    urlSso: 'https://sso.crunchyroll.com',
    urlStatic: 'https://static.crunchyroll.com',
    urlDrm: 'https://cr-play-service.prd.crunchyrollsvc.com',
    urlPl: 'https://pl.crunchyroll.com',
    urlLicense: 'https://cr-license-proxy.prd.crunchyrollsvc.com',
    accountingId: 'crunchyroll',
    castId: '4D84B31C',
    urlEec: 'https://eec.crunchyroll.com',
    appConfig: 'app-config-default-production.json',
    versionName: '3.70.4',
    appId: 'cr-android',
    osReleaseVersion: '13',
    contentTypes: ['series', 'movie_listing', 'episode'],
    sortByValues: ['popularity', 'newly_added', 'alphabetical'],
    ratingContentTypes: ['1s', '2s', '3s', '4s', '5s'],
    ratingEpisodeTypes: ['up', 'down'],
});


/***/ }),

/***/ "./src/error.js":
/*!**********************!*\
  !*** ./src/error.js ***!
  \**********************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });

/**
 * Class to handel custom errors
 */
class CrunchyrollError extends Error {

    constructor(message, code = null, context = null, status = null, statusText = null) {
        super(message)
        this.code = code
        this.context = context
        this.httpStatus = status
        this.httpStatusText = statusText
        Object.setPrototypeOf(this, CrunchyrollError.prototype)
    }

}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CrunchyrollError);


/***/ }),

/***/ "./src/localStore.js":
/*!***************************!*\
  !*** ./src/localStore.js ***!
  \***************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
/* harmony import */ var _services_auth_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./services/auth.js */ "./src/services/auth.js");
/* harmony import */ var _services_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./services/index.js */ "./src/services/index.js");
/* harmony import */ var _services_account_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./services/account.js */ "./src/services/account.js");
/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./error.js */ "./src/error.js");








/** @type {import('./types.js').Storage} */
const storage = {
    credential: null,
    device: null,
    token: null,
    cms: null,
    account: null
}

/**
 * @type {Function}
 * @param {Object} data
 */
let externalSaveData = null

/**
 * @type {Function}
 * @returns {Object}
 */
let externalLoadData = null


/**
 * @param {Object} jsonData
 * @returns {Object}
 */
function fromJSON(jsonData) {
    return swapObjectJson(jsonData, _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toCamel)
}


/**
 * @param {Object} jsonData
 * @returns {Object}
 */
function toJSON(jsonData) {
    return swapObjectJson(jsonData, _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toSnake)
}


/**
 * @param {Object} [data]
 * @returns {Promise}
 */
async function saveToken(data) {
    if (data) {
        storage.token = fromJSON(data)
        storage.token.token = `${storage.token.tokenType} ${storage.token.accessToken}`
    } else {
        storage.token = null
    }
    await saveToLocal()
}


/**
 * @returns {Promise<String>}
 */
async function getAuthToken() {
    let tokenObj = null

    if (storage.token && storage.token.accessToken) {
        const now = new Date()
        const diff = (now.getTime() - (new Date(storage.token.createdDate)).getTime()) / 1000
        if (diff < (storage.token.expiresIn - 5)) {
            tokenObj = storage.token
        }
    }
    if (!tokenObj) {
        let data = null
        if (storage.token && storage.token.refreshToken) {
            data = await _services_auth_js__WEBPACK_IMPORTED_MODULE_1__["default"].getRefreshToken({
                ...storage.token,
                device: storage.device
            })
        } else if (storage.credential) {
            data = await _services_auth_js__WEBPACK_IMPORTED_MODULE_1__["default"].getToken({
                ...storage.credential,
                device: storage.device
            })
        }
        await saveToken(data)
        tokenObj = storage.token
    }
    if (!tokenObj) {
        throw new _error_js__WEBPACK_IMPORTED_MODULE_4__["default"]('No auth token found.')
    }
    return tokenObj.token
}


/**
 * @param {String} profileId
 * @returns {Promise<import('./types').TokenObj>}
 */
async function switchProfile(profileId) {
    const data = await _services_auth_js__WEBPACK_IMPORTED_MODULE_1__["default"].switchProfile({
        ...storage.token,
        device: storage.device,
        profileId
    })
    await saveToken(data)
    return storage.token
}


/**
 * @returns {Promise<import('./types').TokenObj>}
 */
async function getToken() {
    await getAuthToken()
    return storage.token
}


/**
 * @returns {Promise}
 */
async function revokeToken() {
    if (storage.token) {
        await _services_auth_js__WEBPACK_IMPORTED_MODULE_1__["default"].revokeRefreshToken(storage.token)
    }
    storage.token = null
    await saveToLocal()
}


/**
 * @returns {Promise<import('./types').CmsObj>}
 */
async function getCms() {
    let cms = null
    if (storage.cms && storage.cms.bucket) {
        const now = new Date()
        if (new Date(storage.cms.expires) > now) {
            cms = storage.cms
        }
    }
    if (!cms) {
        cms = await _services_index_js__WEBPACK_IMPORTED_MODULE_2__["default"].getIndexConfig({ token: await getAuthToken() })
        storage.cms = fromJSON(cms.cms)
        cms = storage.cms
        await saveToLocal()
    }

    return cms
}


/**
 * @returns {Promise<import('./types').AccountObj>}
 */
async function getAccount() {
    if (!storage.account || !storage.account.accountId) {
        const account = await _services_account_js__WEBPACK_IMPORTED_MODULE_3__["default"].getAccountId({ token: await getAuthToken() })
        storage.account = fromJSON(account)
        await saveToLocal()
    }
    return storage.account
}


/**
 * Return basic params to query api
 * @param {import('./types').Profile} profile
 * @returns {Promise<import('./types').AccountAuth>}
 */
async function getContentParam(profile) {
    const tokenObj = await getToken()
    return {
        ...tokenObj,
        locale: profile.preferred_communication_language,
        audioLanguage: profile.preferred_content_audio_language,
    }
}


/**
 * @todo maybe add a extra field to save locale, and return profile.preferredContentSubtitleLanguage too
 */
async function getLocale() {
    return 'es-419'
}


/**
 * Load from persistence data
 * @returns {Promise}
 */
async function loadFromLocal() {
    let data = null
    const authData = await authDataFile()
    try {
        if (externalLoadData) {
            data = await externalLoadData()
        } else {
            const data64 = window.localStorage.getItem(authData)
            if (data64) {
                data = atob(data64)
            }
        }
    } catch (_e) {
        // #if process.env.NODE_COMPILING !== 'true'
//         const fs = (await import('fs')).default
//         if (fs.existsSync(authData)) {
//             data = fs.readFileSync(authData, 'utf-8')
//         }
        // #endif
    }
    if (data) {
        const jsonData = JSON.parse(data)
        Object.assign(storage, fromJSON(jsonData))
    }
}


/**
 * Save to persistence data
 * @returns {Promise}
 */
async function saveToLocal() {
    const authData = await authDataFile()
    const data = JSON.stringify(toJSON(storage), null, '\t')
    try {
        if (externalSaveData) {
            await externalSaveData(data)
        } else {
            window.localStorage.setItem(authData, btoa(data))
        }
    } catch (_e) {
        // #if process.env.NODE_COMPILING !== 'true'
//         const fs = (await import('fs')).default
//         fs.writeFileSync(authData, data)
        // #endif
    }
}


/**
 * @param {Object} jsonData
 * @param {Function} func
 * @returns {Object}
 */
function swapObjectJson(jsonData, func) {
    let out
    if (jsonData) {
        if (Array.isArray(jsonData)) {
            out = []
            for (const item of jsonData) {
                out.push(swapObjectJson(item, func))
            }
        } else if (typeof jsonData === 'object' || Object.prototype.isPrototypeOf.call(jsonData, Object)) {
            out = {}
            for (const key of Object.keys(jsonData)) {
                out[func(key)] = swapObjectJson(jsonData[key], func)
            }
        } else {
            out = jsonData
        }
    } else {
        out = jsonData
    }
    return out
}


/**
 * Disk file with credential data
 * @returns {Promise<String>}
 */
async function authDataFile() {
    let out = 'crunchyData'

    // #if process.env.NODE_COMPILING !== 'true'
//     const path = (await import('path')).default
//     out = path.resolve('.') + '/authData.json'
    // #endif
    return out
}


/**
 * Set function to save and load data from external storage
 * @param {{save: Function, load: Function}} obj
 */
function setExternalStorage({ save, load }) {
    if (load !== undefined) {
        externalLoadData = load
    }
    if (save !== undefined) {
        externalSaveData = save
    }
}


/**
 * Set credentials of an account
 * @param {Storage} newData
 * @returns {Promise}
 */
async function setNewData(newData) {
    Object.assign(storage, newData)
    await saveToLocal()
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    storage,
    getAuthToken,
    getToken,
    getLocale,
    getCms,
    getContentParam,
    loadFromLocal,
    saveToLocal,
    authDataFile,
    getAccount,
    saveToken,
    setExternalStorage,
    setNewData,
    switchProfile,
    revokeToken,
});


/***/ }),

/***/ "./src/logger.js":
/*!***********************!*\
  !*** ./src/logger.js ***!
  \***********************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });

let LEVEL = 'info', COLOR_ACTIVE = true

if (process && process.env && process.env.LOG_LEVEL) {
    LEVEL = process.env.LOG_LEVEL
}

/**
   @type {{
    info: Function,
    error: Function,
    debug: Function,
    setLevel: Function,
    activeColor: Function,
}}
 */
const logger = {
    info: () => { },
    error: () => { },
    debug: () => { },
    setLevel: () => { },
    /**
     * @param {Boolean} active
     */
    activeColor: active => { COLOR_ACTIVE = active },
}

if (!console.debug) { console.debug = console.log }
if (!console.info) { console.info = console.log }
if (!console.error) { console.error = console.log }

/**
 * @param {Object} obj
 */
const formatObj = obj => {
    let extra = ''
    const keys = Object.keys(obj)

    if (keys.length) {
        if (keys.length === 2 && keys.includes('message') && keys.includes('stack')) {
            /** @type {Error} */
            const err = obj
            extra = `\n  message:${err.name}\n  stack:${err.stack}`
        } else {
            extra = '\n' + JSON.stringify(obj, null, '  ')
        }
    } else if (obj instanceof Error) {
        extra = `\n  message:${obj.name}\n  stack:${obj.stack}`
    } else if (obj instanceof Set) {
        extra = '[' + Array.from(obj).toString() + ']'
    }
    return extra
}

const colors = { debug: '\x1b[33m', info: '\x1b[32m', error: '\x1b[31m', reset: '\x1b[0m' }

/**
 * @param {any} message
 * @param {String} level
 */
const getMessage = (message, level) => {
    if (!(typeof (message) === 'string' || message instanceof String)) {
        message = formatObj(message)
    }
    const error = new Error();
    /** @type {String} */
    const callerFile = error.stack.split('\n')[3]
    let color = colors[level], resetColor = colors['reset']
    if (!COLOR_ACTIVE) {
        color = resetColor = ''
    }
    const date = new Date().toISOString()
    return `${date} ${color}${level.toUpperCase()} ${message} ${(callerFile || '').trim()} ${resetColor}`
}

/**
 * @param {String} newLevel
 */
function configBrowserLogger(newLevel) {
    if (!newLevel) {
        newLevel = LEVEL
    }
    logger.debug = () => { }
    logger.info = () => { }
    logger.error = () => { }
    /*eslint-disable */
    switch (newLevel) {
        case 'silent': break;
        case 'debug': logger.debug = msg => { console.debug(getMessage(msg, 'debug')) };
        case 'info': logger.info = msg => { console.info(getMessage(msg, 'info')) };
        case 'error': logger.error = msg => { console.error(getMessage(msg, 'error')) };
            break;
    }
    return logger
}

logger.setLevel = configBrowserLogger
logger.setLevel()

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (logger);


/***/ }),

/***/ "./src/services/account.js":
/*!*********************************!*\
  !*** ./src/services/account.js ***!
  \*********************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");




/**
 * Return account info
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Account>}
 */
async function getAccountId({ token, fnConfig }) {
    const fnName = 'getAccountId'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * Return profile info
 * @deprecated
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Profile>}
 */
async function getProfile({ token, fnConfig }) {
    const fnName = 'getProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/profile`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Return user names, idk what it is
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{usernames: Array<String>}>}
 */
async function getUsernames({ token, fnConfig }) {
    const fnName = 'getAccountId'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/usernames`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * Update profile
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').Profile} obj.data
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function updateProfile({ token, data, fnConfig }) {
    const fnName = 'updateProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/profile`
    const reqConfig = {
        method: 'patch',
        headers: {
            Authorization: token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(data),
    }
    // @ts-expect-error
    await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Update profile
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').ProfileCreate} obj.data
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function createMultiProfile({ token, data, fnConfig }) {
    const fnName = 'createMultiProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/multiprofile`
    const reqConfig = {
        method: 'post',
        headers: {
            Authorization: token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(data),
    }
    // @ts-expect-error
    await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Delete profile
 * @param {Object} obj
 * @param {String} obj.token
 * @param {String} obj.profileId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function deleteMultiProfile({ token, profileId, fnConfig }) {
    const fnName = 'deleteMultiProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/multiprofile/${profileId}`
    const reqConfig = {
        method: 'delete',
        headers: {
            Authorization: token,
            'Content-Type': 'application/json',
        },
    }
    // @ts-expect-error
    await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * Return profile info
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').ProfileResponse>}
 */
async function getMultiProfiles({ token, fnConfig }) {
    const fnName = 'getMultiProfiles'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/multiprofile`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Update profile
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').Profile} obj.data
 * @param {String} obj.profileId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function updateMultiProfile({ token, data, profileId, fnConfig }) {
    const fnName = 'updateMultiProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/multiprofile/${profileId}`
    const reqConfig = {
        method: 'patch',
        headers: {
            Authorization: token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(data),
    }
    // @ts-expect-error
    await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Return profile info
 * @param {Object} obj
 * @param {String} obj.token
 * @param {String} obj.profileId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Profile>}
 */
async function getMultiProfile({ token, profileId, fnConfig }) {
    const fnName = 'getMultiProfiles'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/accounts/v1/me/multiprofile/${profileId}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    createMultiProfile,
    deleteMultiProfile,
    getAccountId,
    getProfile,
    getMultiProfile,
    getMultiProfiles,
    getUsernames,
    updateProfile,
    updateMultiProfile
});


/***/ }),

/***/ "./src/services/assets.js":
/*!********************************!*\
  !*** ./src/services/assets.js ***!
  \********************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");




/**
 * Return Avatar list
 * @param {Object} obj
 * @param {String} obj.token
 * @param {String} obj.lang
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<import('../types.js').AssesItem>}>}
 */
async function getAvatar({ token, lang, fnConfig }) {
    const fnName = 'getAvatar'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/assets/v2/${lang}/avatar`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Return wallpaper list
 * @param {Object} obj
 * @param {String} obj.token
 * @param {String} obj.lang
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<import('../types.js').AssesItem>}>}
 */
async function getWallpaper({ token, lang, fnConfig }) {
    const fnName = 'getWallpaper'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/assets/v2/${lang}/wallpaper`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getAvatar,
    getWallpaper,
});


/***/ }),

/***/ "./src/services/auth.js":
/*!******************************!*\
  !*** ./src/services/auth.js ***!
  \******************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config.js */ "./src/config.js");






/**
 * Return hardcode credentials to login
 * @returns {String}
 */
function getBasicToken() {
    const credenciales = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].clientId}:${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].clientSecret}`
    let buff = Buffer.from(credenciales)
    let base64data = buff.toString('base64')
    return base64data
}

/**
 * Get device code for easy login
 * @param {Object} obj
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').DeviceCode>}
 */
async function getDeviceCode(obj) {
    const fnName = 'getDeviceCode'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const basicToken = getBasicToken()
    const body = { grant_type: 'client_id' }
    const url = `/auth/v1/device/code`
    const reqConfig = {
        method: 'post',
        body: await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(body),
        headers: {
            Authorization: `Basic ${basicToken}`,
            'Content-Type': 'application/x-www-form-urlencoded',
            'etp-anonymous-id': null,
        },
    }
    const { fnConfig } = (obj || {})
    // @ts-expect-error
    const token = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
    if (token) {
        token.created_date = new Date().toISOString()
    }
    return token
}

/**
 * Get access token from device code
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} obj.deviceCode login type
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function getDeviceAuth({ device, deviceCode, fnConfig }) {
    const fnName = 'getDeviceAuth'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const basicToken = getBasicToken()
    const body = {
        device_id: device.id,
        device_name: device.name,
        device_type: device.type,
        device_code: deviceCode,
    }
    const url = `/auth/v1/device/token`
    const reqConfig = {
        method: 'post',
        body: JSON.stringify(body),
        headers: {
            Authorization: `Basic ${basicToken}`,
            'Content-Type': 'application/json',
        },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * Make out system login
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {Object} obj.credentials login type
 * @param {String} obj.grantType login type
 * @param {String} [obj.scope]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function _makeLogin({ device, credentials, grantType, scope, fnConfig }) {
    const fnName = '_makeLogin'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const basicToken = getBasicToken()
    const body = {
        grant_type: grantType,
        scope: scope || 'offline_access',
        device_id: device.id,
        device_name: device.name,
        device_type: device.type,
        ...credentials,
    }
    const url = `/auth/v1/token`
    const reqConfig = {
        method: 'post',
        body: await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(body),
        headers: {
            Authorization: `Basic ${basicToken}`,
            'Content-Type': 'application/x-www-form-urlencoded',
            'ETP-Anonymous-ID': null,
        },
    }
    // @ts-expect-error
    const token = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
    if (token) {
        token.created_date = new Date().toISOString()
    }
    return token
}


/**
 * Make out system login
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} [obj.scope]
 * @param {String} obj.username user's email
 * @param {String} obj.password user's password
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function getToken({ device, scope, username, password, fnConfig }) {
    const fnName = 'getToken'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    return _makeLogin({
        device,
        scope,
        grantType: 'password',
        credentials: { username, password },
        fnConfig,
    })
}


/**
 * Make out system login
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} [obj.scope]
 * @param {String} obj.phone user's phone
 * @param {String} obj.verification_code
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function getTokenWithPhone({ device, scope, phone, verification_code, fnConfig }) {
    const fnName = 'getTokenWithPhone'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    return _makeLogin({
        device,
        scope,
        grantType: 'phone',
        credentials: { phone_number: phone, verification_code },
        fnConfig,
    })
}

/**
 * Make out system login
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} [obj.scope]
 * @param {String} obj.code
 * @param {String} obj.code_verifier
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function getTokenWithCode({ device, scope, code, code_verifier, fnConfig }) {
    const fnName = 'getTokenWithCode'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    return _makeLogin({
        device,
        scope,
        grantType: 'authorization_code',
        credentials: { code, code_verifier: code_verifier },
        fnConfig,
    })
}


/**
 * Refresh access token.
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} [obj.scope]
 * @param {String} obj.refreshToken refresh token from login
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function getRefreshToken({ device, scope, refreshToken, fnConfig }) {
    const fnName = 'getRefreshToken'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    return _makeLogin({
        device,
        scope,
        grantType: 'refresh_token',
        credentials: { refresh_token: refreshToken },
        fnConfig,
    })
}


/**
 * Switch profile
 * @param {Object} obj
 * @param {import('../types.js').Device} obj.device Device
 * @param {String} [obj.scope]
 * @param {String} obj.refreshToken refresh token from login
 * @param {String} obj.profileId profile id for switch
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').Token>}
 */
async function switchProfile({ device, scope, refreshToken, profileId, fnConfig }) {
    const fnName = 'switchProfile'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    return _makeLogin({
        device,
        scope,
        grantType: 'refresh_token_profile_id',
        credentials: { refresh_token: refreshToken, profile_id: profileId },
        fnConfig,
    })
}

/**
 * revoke access token.
 * @param {Object} obj
 * @param {String} obj.refreshToken
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{status: String}>}
 */
async function revokeRefreshToken({ refreshToken, fnConfig }) {
    const fnName = 'revokeRefreshToken'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const basicToken = getBasicToken()
    const body = { token: refreshToken }
    const url = `/auth/v1/revoke`
    const reqConfig = {
        method: 'post',
        body: await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(body),
        headers: {
            Authorization: `Basic ${basicToken}`,
            'Content-Type': 'application/x-www-form-urlencoded',
            'ETP-Anonymous-ID': null,
        },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getDeviceCode,
    getDeviceAuth,
    getToken,
    getTokenWithPhone,
    getTokenWithCode,
    getRefreshToken,
    revokeRefreshToken,
    switchProfile,
});


/***/ }),

/***/ "./src/services/cms.js":
/*!*****************************!*\
  !*** ./src/services/cms.js ***!
  \*****************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config.js */ "./src/config.js");






/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.episodeId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getEpisode({ account, episodeId, fnConfig }) {
    const fnName = 'getEpisode'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/episodes/${episodeId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.seasonId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getEpisodes({ account, seasonId, fnConfig }) {
    const fnName = 'getEpisodes'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/seasons/${seasonId}/episodes?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.movieId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getMovie({ account, movieId, fnConfig }) {
    const fnName = 'getMovie'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/movies/${movieId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.movieListingId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getMovieListing({ account, movieListingId, fnConfig }) {
    const fnName = 'getMovieListing'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/movie_listings/${movieListingId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.movieListingId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getMovieListingExtras({ account, movieListingId, fnConfig }) {
    const fnName = 'getMovieListingExtras'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/movie_listings/${movieListingId}/extra_videos?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.movieListingId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getMovies({ account, movieListingId, fnConfig }) {
    const fnName = 'getMovies'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/movie_listings/${movieListingId}/movies?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} obj.objectIds
 * @param {Boolean} obj.ratings
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getObjects({ account, objectIds, ratings, fnConfig }) {
    const fnName = 'getObjects'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/objects/${objectIds.join(',')}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.seasonId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getSeason({ account, seasonId, fnConfig }) {
    const fnName = 'getSeason'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/seasons/${seasonId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.seasonId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getSeasonExtras({ account, seasonId, fnConfig }) {
    const fnName = 'getSeasonExtras'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/seasons/${seasonId}/extra_videos?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.serieId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getSeasons({ account, serieId, fnConfig }) {
    const fnName = 'getSeasons'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/series/${serieId}/seasons?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.serieId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getSeries({ account, serieId, fnConfig }) {
    const fnName = 'getSeries'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/series/${serieId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @deprecated
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.streamUrl
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getStreamsWithURL({ account, streamUrl, fnConfig }) {
    const fnName = 'getStreamsWithURL'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `${streamUrl}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @deprecated
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getStreams({ account, contentId, fnConfig }) {
    const fnName = 'getStreams'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/cms/videos/${contentId}/streams?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getSkiptEvents({ account, contentId, fnConfig }) {
    const fnName = 'getSkiptEvents'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlStatic}/skip-events/production/${contentId}.json`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    let out = null
    try {
        // @ts-expect-error
        out = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
    } catch (_e) {
        // ignore any error
    }
    return out
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getEpisode,
    getEpisodes,
    getMovie,
    getMovieListing,
    getMovieListingExtras,
    getMovies,
    getObjects,
    getSeason,
    getSeasonExtras,
    getSeasons,
    getSeries,
    getStreamsWithURL,
    getStreams,
    getSkiptEvents,
});


/***/ }),

/***/ "./src/services/content.js":
/*!*********************************!*\
  !*** ./src/services/content.js ***!
  \*********************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../error.js */ "./src/error.js");






/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function addItemToCustomList({ account, listId, contentId, fnConfig }) {
    const fnName = 'addItemToCustomList'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}?${queryStr}`
    const reqConfig = {
        method: 'post',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ content_id: contentId })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {String} obj.contentId
 * @param {String} obj.location
 * @param {String} obj.refContentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function changeCustomListItemPosition({ account, listId, contentId, location, refContentId, fnConfig }) {
    const fnName = 'changeCustomListItemPosition'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}/${contentId}/position?${queryStr}`
    if (!['after', 'before'].includes(location)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_2__["default"](`Wrong location`) }
    const reqConfig = {
        method: 'put',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            location: location,
            ref_content_id: refContentId
        })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {String} [obj.page]
 * @param {String} [obj.pageSize]
 * @param {String} [obj.sort] manual, date_added
 * @param {String} [obj.order] asc, desc
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getCustomListItems({ account, listId, page, pageSize, sort, order, fnConfig }) {
    const fnName = 'getCustomListItems'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'page', page)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'page_size', pageSize)
    if (sort && !['manual', 'date_added'].includes(sort)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Wrong sort value') }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'sort_by', sort)
    if (order && !['asc', 'desc'].includes(order)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Wrong order value') }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'order', order)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {String} obj.contentId 
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function deleteCustomListItem({ account, listId, contentId, fnConfig }) {
    const fnName = 'deleteCustomListItem'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'delete',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.title
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{data: Array<import('../types').CustomListResponse>}>}
 */
async function createPrivateCustomList({ account, title, fnConfig }) {
    const fnName = 'createPrivateCustomList'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists?${queryStr}`
    const reqConfig = {
        method: 'post',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ title })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Object, meta: Object}>}
 */
async function getCustomLists({ account, fnConfig }) {
    const fnName = 'getCustomLists'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {String} obj.title
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function updateCustomList({ account, listId, title, fnConfig }) {
    const fnName = 'updateCustomList'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}?${queryStr}`
    const reqConfig = {
        method: 'patch',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ title })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.listId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function deletePrivateCustomList({ account, listId, fnConfig }) {
    const fnName = 'deletePrivateCustomList'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/custom-lists/${listId}?${queryStr}`
    const reqConfig = {
        method: 'delete',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function addWatchlistItem({ account, contentId, fnConfig }) {
    const fnName = 'addWatchlistItem'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/watchlist?${queryStr}`
    const reqConfig = {
        method: 'post',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ content_id: contentId })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.contentIds]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>} 
 */
async function getWatchlistItems({ account, contentIds, fnConfig }) {
    const fnName = 'getWatchlistItems'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    if (contentIds && contentIds.length) {
        _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'content_ids', contentIds.join(','))
    }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    let url = `/content/v2/${account.accountId}/watchlist?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {Boolean} obj.isFavorite
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function updateWatchlistItemFavoriteStatus({ account, contentId, isFavorite, fnConfig }) {
    const fnName = 'updateWatchlistItemFavoriteStatus'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/watchlist/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'patch',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ is_favorite: isFavorite })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function deleteWatchlistItem({ account, contentId, fnConfig }) {
    const fnName = 'deleteWatchlistItem'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/watchlist/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'delete',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.page it has to be > 1
 * @param {Number} obj.pageSize
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>} 
 */
async function getWatchHistory({ account, page, pageSize, fnConfig }) {
    const fnName = 'getWatchHistory'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'page', page, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'page_size', pageSize, val => val > 0)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/watch-history?${query}`
    const reqConfig = {
        method: 'get',
        headers: {
            Authorization: account.token,
            upload_offline_playheads: true,
        }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} obj.contentIds
 * @param {Boolean} obj.uploadOfflinePlayheads 
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>} 
 */
async function _getPlayheads({ account, contentIds, uploadOfflinePlayheads, fnConfig }) {
    const fnName = '_getPlayheads'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'content_ids', contentIds.join(','))
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/playheads?${query}`
    const reqConfig = {
        method: 'get',
        headers: {
            Authorization: account.token,
            upload_offline_playheads: uploadOfflinePlayheads
        }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} obj.contentIds
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>} 
 */
async function getPlayheads({ account, contentIds, fnConfig }) {
    return _getPlayheads({ account, contentIds, uploadOfflinePlayheads: true, fnConfig })
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {Number} obj.playhead
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function savePlayhead({ account, contentId, playhead, fnConfig }) {
    const fnName = 'savePlayhead'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/${account.accountId}/playheads?${queryStr}`
    const reqConfig = {
        method: 'post',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            content_id: contentId,
            playhead: playhead
        })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.method http method
 * @param {Boolean} [obj.baseUrlIncluded]
 * @param {String} obj.url if url incluse a domain pass baseUrlIncluded=true
 * @param {Object} [obj.body]
 * @param {Object} [obj.headers]
 * @param {Object} [obj.queryParams]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getData({
    account,
    method = 'get',
    baseUrlIncluded = false,
    url,
    body = null,
    headers = {},
    queryParams = {},
    fnConfig,
}) {
    const fnName = 'getData'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = {
        locale: account.locale,
        preferred_audio_language: account.audioLanguage,
        ...queryParams,
    }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const urlStr = `${url}?${queryStr}`
    const reqConfig = {
        method,
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
            ...headers,
        },
        baseUrlIncluded,
        body: body && JSON.stringify(body),
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, urlStr, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    addItemToCustomList,
    addWatchlistItem,
    changeCustomListItemPosition,
    createPrivateCustomList,
    deleteCustomListItem,
    deletePrivateCustomList,
    deleteWatchlistItem,
    getCustomListItems,
    getCustomLists,
    getData,
    getPlayheads,
    getWatchHistory,
    getWatchlistItems,
    savePlayhead,
    updateCustomList,
    updateWatchlistItemFavoriteStatus,
});


/***/ }),

/***/ "./src/services/discover.js":
/*!**********************************!*\
  !*** ./src/services/discover.js ***!
  \**********************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config.js */ "./src/config.js");
/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../error.js */ "./src/error.js");







/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {Boolean} [obj.ratings]
 * @param {String} [obj.order] Order
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>}>} 
 */
async function getWatchlist({ account, quantity, start, ratings, order, fnConfig }) {
    const fnName = 'getWatchlist'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    if (order && !['desc', 'asc'].includes(order)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Wrong order value') }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'order', order)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/watchlist?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {Array<String>} [obj.category] Category
 * @param {String} [obj.query] Search pattern
 * @param {String} [obj.seasonTag] season tag
 * @param {String} [obj.sort] sort results
 * @param {String} [obj.type] type for search, example episode
 * @param {Boolean} [obj.ratings]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getBrowseAll({ account, quantity, start, category, query, seasonTag, sort, type, ratings, fnConfig }) {
    const fnName = 'getBrowseAll'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    if (category && category.length) {
        _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'categories', category.join(','))
    }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'q', query)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'seasonal_tag', seasonTag)
    if (sort && !_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].sortByValues.includes(sort)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Wrong sort value') }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'sort_by', sort)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'type', type)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/browse?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: {
            Authorization: account.token,
            'add_watchlist_status': true,
        }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.category] Category
 * @param {String} [obj.sort] sort results
 * @param {Boolean} [obj.ratings]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getBrowseIndex({ account, category, sort, ratings, fnConfig }) {
    const fnName = 'getBrowseIndex'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    if (category && category.length) {
        _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'categories', category.join(','))
    }
    if (sort && !_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].sortByValues.includes(sort)) { throw new _error_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Wrong sort value') }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'sort_by', sort)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/browse/index?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: {
            Authorization: account.token,
            'add_watchlist_status': true,
        }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getCategories({ account, contentId, fnConfig }) {
    const fnName = 'getCategories'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'guid', contentId)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/categories?${query}`
    const reqConfig = {
        method: 'get',
        headers: {
            Authorization: account.token,
            'add_watchlist_status': true,
        }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.parentCategory Offset to request
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getSubcategories({ account, parentCategory, fnConfig }) {
    const fnName = 'getSubcategories'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'parent_category', parentCategory)
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/categories/${parentCategory}/sub_categories?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getHomeFeed({ account, quantity, start, fnConfig }) {
    const fnName = 'getHomeFeed'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/home_feed?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').HomeItem>}
 */
async function getHome({ account, fnConfig }) {
    const fnName = 'getHome'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].url}/f/v1/home?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.collectionId
 * @param {Boolean} obj.ratings
 * @param {String} [obj.vendor]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').HomeItem>}
 */
async function getPersonalRecomendation({ account, collectionId, ratings, vendor, fnConfig }) {
    const fnName = 'getPersonalRecomendation'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = {
        collectionId,
        ratings,
        vendor,
        locale: account.locale,
        profileId: account.profileId,
    }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].url}/personalization/v2/personalization?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.quantity
 * @param {Boolean} obj.ratings
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getHistory({ account, quantity, ratings, fnConfig }) {
    const fnName = 'getHistory'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/history?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {Boolean} [obj.ratings]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getRecommendations({ account, quantity, start, ratings, fnConfig }) {
    const fnName = 'getRecommendations'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/recommendations?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<{id: String, localization: Object}>}>} 
 */
async function getSeasonList({ account, fnConfig }) {
    const fnName = 'getSeasonList'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/seasonal_tags?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.contentId Offset to request
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {Boolean} [obj.ratings]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>}
 */
async function getSimilar({ account, contentId, quantity, start, ratings, fnConfig }) {
    const fnName = 'getSimilar'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'ratings', ratings)
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/similar_to/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>} 
 */
async function getNext({ account, contentId, fnConfig }) {
    const fnName = 'getNext'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/up_next/${contentId}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>} 
 */
async function getPrev({ account, contentId, fnConfig }) {
    const fnName = 'getPrev'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/previous_episode/${contentId}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.query search partner
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {Array<String>} [obj.type] Can be top_results, series, movie_listing, episode
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{total: Number, data: Array<Object>, meta: Object}>} 
 */
async function search({ account, query, quantity, start, type, fnConfig }) {
    const fnName = 'search'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const types = _config_js__WEBPACK_IMPORTED_MODULE_2__["default"].contentTypes.concat(['top_results', 'music'])
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'q', query)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    if (type && type.length) {
        for (const t of type) {
            if (!types.includes(t)) {
                throw new _error_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Wrong type value.')
            }
        }
        _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'type', type.join(','))
    }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/search?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.contentId Offset to request
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function markAsWatched({ account, contentId, fnConfig }) {
    const fnName = 'markAsWatched'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/discover/${account.accountId}/mark_as_watched/${contentId}?${query}`
    const reqConfig = {
        method: 'post',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getWatchlist,
    getBrowseAll,
    getBrowseIndex,
    getCategories,
    getSubcategories,
    getHome,
    getHomeFeed,
    getPersonalRecomendation,
    getHistory,
    getRecommendations,
    getSeasonList,
    getSimilar,
    getNext,
    getPrev,
    search,
    markAsWatched,
});


/***/ }),

/***/ "./src/services/drm.js":
/*!*****************************!*\
  !*** ./src/services/drm.js ***!
  \*****************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config.js */ "./src/config.js");






/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.episodeId
 * @param {String} [obj.type] only null or music
 * @param {String} [obj.browser] browser name
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getStream({ account, episodeId, type, browser, fnConfig }) {
    const fnName = 'getStream'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    type = type ? `/${type}` : ''
    browser = browser || 'chrome'
    if (!['chrome', 'firefox', 'safari', 'explorer'].includes(browser)) {
        throw new Error('Wrong browser, ' + browser)
    }
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlDrm}/v1${type}/${episodeId}/web/${browser}/play`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.episodeId
 * @param {String} obj.token
 * @param {Number} obj.playhead
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function keepAlive({ account, token, episodeId, playhead, fnConfig }) {
    const fnName = 'keepAlive'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { playhead }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlDrm}/v1/token/${episodeId}/${token}/keepAlive?${queryStr}`
    let body = null, FormDataFn = null

    try {
        FormDataFn = window.FormData
    } catch (_e) {
        // #if process.env.NODE_COMPILING !== 'true'
//         FormDataFn = await import('form-data')
//         FormDataFn = FormDataFn.default
        // #endif
    }
    body = new FormDataFn()
    body.append('position', playhead.toString())
    const reqConfig = {
        method: 'PATCH',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
        body,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.episodeId
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function revokeToken({ account, episodeId, token, fnConfig }) {
    const fnName = 'revokeToken'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlDrm}/v1/token/${episodeId}/${token}/delete`
    const reqConfig = {
        method: 'post',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.episodeId
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function deleteToken({ account, episodeId, token, fnConfig }) {
    const fnName = 'deleteToken'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlDrm}/v1/token/${episodeId}/${token}`
    const reqConfig = {
        method: 'delete',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.assetId
 * @param {String} obj.sessionId `${new Date().getTime()}-${account.accountId}`
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{custom_data: String, token: String}>}
 */
async function getAuth({ account, assetId, sessionId, fnConfig }) {
    const fnName = 'getAuth'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `${_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].urlPl}/drm/v1/auth`
    const reqConfig = {
        method: 'post',
        headers: { Authorization: account.token },
        baseUrlIncluded: true,
        body: JSON.stringify({
            accounting_id: _config_js__WEBPACK_IMPORTED_MODULE_2__["default"].accountingId,
            asset_id: assetId,
            session_id: sessionId,
            user_id: account.accountId,
        })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getStream,
    getAuth,
    keepAlive,
    revokeToken,
    deleteToken,
});


/***/ }),

/***/ "./src/services/index.js":
/*!*******************************!*\
  !*** ./src/services/index.js ***!
  \*******************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");





/**
 * Return index data. Cms is set there
 * @param {Object} obj
 * @param {String} obj.token
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').CmsContainer>}
 */
async function getIndexConfig({ token, fnConfig }) {
    const fnName = 'getIndexConfig'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const url = `/index/v2`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getIndexConfig,
});


/***/ }),

/***/ "./src/services/music.js":
/*!*******************************!*\
  !*** ./src/services/music.js ***!
  \*******************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");





/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} [obj.quantity] Number of records in a result
 * @param {Number} [obj.start] Offset to request
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getFeed({ account, quantity, start, fnConfig }) {
    const fnName = 'getFeed'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'n', quantity, val => val > 0)
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'start', start, val => val >= 0)
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/${account.accountId}/landing_feed?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.artistIds]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getArtist({ account, artistIds, fnConfig }) {
    const fnName = 'getArtist'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/artists/${artistIds.join(',')}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.artistId]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getArtistConcerts({ account, artistId, fnConfig }) {
    const fnName = 'getArtistConcerts'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/artists/${artistId}/concerts?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.artistId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getArtistVideos({ account, artistId, fnConfig }) {
    const fnName = 'getArtistVideos'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/artists/${artistId}/music_videos?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.concertIds]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getConcerts({ account, concertIds, fnConfig }) {
    const fnName = 'getConcerts'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/concerts/${concertIds.join(',')}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Array<String>} [obj.musicIds]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getVideo({ account, musicIds, fnConfig }) {
    const fnName = 'getVideo'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const query = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/music_videos/${musicIds.join(',')}?${query}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @deprecated
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.streamUrl
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getStreamsWithURL({ account, streamUrl, fnConfig }) {
    const fnName = 'getStreamsWithURL'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `${streamUrl}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @deprecated
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getStreams({ account, contentId, fnConfig }) {
    const fnName = 'getStreams'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/${contentId}/streams?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {Number} obj.contentId Number of records in a result
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<{items: Array<Object>}>}
 */
async function getFeatured({ account, contentId, fnConfig }) {
    const fnName = 'getFeatured'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale, preferred_audio_language: account.audioLanguage }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/content/v2/music/featured/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getArtist,
    getArtistConcerts,
    getArtistVideos,
    getConcerts,
    getFeed,
    getStreams,
    getStreamsWithURL,
    getVideo,
    getFeatured,
});


/***/ }),

/***/ "./src/services/review.js":
/*!********************************!*\
  !*** ./src/services/review.js ***!
  \********************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config.js */ "./src/config.js");






/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {String} obj.rating
 * @param {String} [obj.contentType]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').RatingEpisode>}
 */
async function addEpisodeRating({ account, contentId, rating, contentType, fnConfig }) {
    const fnName = 'addEpisodeRating'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    contentType = contentType ? contentType : 'episode'
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].contentTypes.includes(contentType)) {
        throw new Error(`ContentType ${contentType} is not valid.`)
    }
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].ratingEpisodeTypes.includes(rating)) {
        throw new Error(`Rating ${rating} is not valid.`)
    }
    const url = `/content-reviews/v2/user/${account.accountId}/rating/${contentType}/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'put',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ rating: rating })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {String} obj.rating
 * @param {String} obj.contentType
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').RatingStars>}
 */
async function addRating({ account, contentId, rating, contentType, fnConfig }) {
    const fnName = 'addRating'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].contentTypes.includes(contentType)) {
        throw new Error(`ContentType ${contentType} is not valid.`)
    }
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].ratingContentTypes.includes(rating)) {
        throw new Error(`Rating ${rating} is not valid.`)
    }
    const url = `/content-reviews/v2/user/${account.accountId}/rating/${contentType}/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'put',
        headers: {
            Authorization: account.token,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ rating: rating })
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {String} obj.contentType
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function _getRatings({ account, contentId, contentType, fnConfig }) {
    const fnName = '_getRatings'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].contentTypes.includes(contentType)) {
        throw new Error(`ContentType ${contentType} is not valid.`)
    }
    const url = `/content-reviews/v2/user/${account.accountId}/rating/${contentType}/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').RatingEpisode>}
 */
async function getEpisodeRatings({ account, contentId, fnConfig }) {
    return _getRatings({ account, contentId, contentType: 'episode', fnConfig })
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {String} obj.contentType
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<import('../types').RatingStars>}
 */
async function getRatings({ account, contentId, contentType, fnConfig }) {
    return _getRatings({ account, contentId, contentType, fnConfig })
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.account
 * @param {String} obj.contentId
 * @param {String} obj.contentType
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise}
 */
async function removeRating({ account, contentId, contentType, fnConfig }) {
    const fnName = 'removeRating'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: account.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    if (!_config_js__WEBPACK_IMPORTED_MODULE_2__["default"].contentTypes.includes(contentType)) {
        throw new Error(`ContentType ${contentType} is not valid.`)
    }
    const url = `/content-reviews/v2/user/${account.accountId}/rating/${contentType}/${contentId}?${queryStr}`
    const reqConfig = {
        method: 'delete',
        headers: { Authorization: account.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    addEpisodeRating,
    addRating,
    getEpisodeRatings,
    getRatings,
    removeRating,
});


/***/ }),

/***/ "./src/services/subscription.js":
/*!**************************************!*\
  !*** ./src/services/subscription.js ***!
  \**************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./src/utils.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../logger.js */ "./src/logger.js");





/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.auth
 * @param {String} [obj.source]
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getProducts({ auth, source, fnConfig }) {
    const fnName = 'getProducts'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: auth.locale }
    _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].addParam(queryData, 'source', source ? source : 'google-play')
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/subs/v2/products?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: auth.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.auth
 * @param {String} obj.externalId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getUserBenefits({ auth, externalId, fnConfig }) {
    const fnName = 'getUserBenefits'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: auth.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/subs/v1/subscriptions/${externalId}/benefits?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: auth.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/**
 * @param {Object} obj
 * @param {import('../types').AccountAuth} obj.auth
 * @param {String} obj.externalId
 * @param {import('../types').FetchConfig} [obj.fnConfig]  util config param
 * @returns {Promise<Object>}
 */
async function getUserSubscription({ auth, externalId, fnConfig }) {
    const fnName = 'getUserSubscription'
    _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"].debug(fnName)
    const queryData = { locale: auth.locale }
    const queryStr = await _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toURLSearchParams(queryData)
    const url = `/subs/v1/subscriptions/${externalId}/products?${queryStr}`
    const reqConfig = {
        method: 'get',
        headers: { Authorization: auth.token }
    }
    // @ts-expect-error
    return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].makeRequest(fnName, url, reqConfig, fnConfig)
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    getProducts,
    getUserBenefits,
    getUserSubscription
});


/***/ }),

/***/ "./src/types.js":
/*!**********************!*\
  !*** ./src/types.js ***!
  \**********************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });

// JSON Types returned from requests
/**
 * @typedef Token
 * @type {Object}
 * @property {String} access_token
 * @property {String} refresh_token
 * @property {Number} expires_in
 * @property {String} token_type
 * @property {String} scope
 * @property {String} country
 * @property {String} account_id
 * @property {String} profile_id
 * @property {String} created_date
 */

/**
 * @typedef TokenObj
 * @type {Object}
 * @property {String} accessToken
 * @property {String} refreshToken
 * @property {Number} expiresIn
 * @property {String} tokenType
 * @property {String} token
 * @property {String} scope
 * @property {String} country
 * @property {String} accountId
 * @property {String} profileId
 * @property {String} createdDate
 */

/**
 * @typedef DeviceCode
 * @type {Object}
 * @property {String} user_code
 * @property {String} device_code
 * @property {Number} interval
 * @property {Number} expires_in
 * @property {Date} created_date
 */

/**
 * @typedef Device
 * @type {Object}
 * @property {String} id
 * @property {String} name
 * @property {String} type
 */

/**
 * @typedef Credential
 * @type {Object}
 * @property {String} username
 * @property {String} password
 */

/**
 * @typedef Account
 * @type {Object}
 * @property {String} account_id
 * @property {String} external_id
 * @property {Boolean} email_verified
 * @property {String} created
 */

/**
* @typedef AccountObj
* @type {Object}
* @property {String} accountId
* @property {String} externalId
* @property {Boolean} emailVerified
* @property {String} created
*/

/**
 * @typedef Profile
 * @type {Object}
 * @property {String} profile_id
 * @property {String} avatar
 * @property {String} profile_name
 * @property {String} [wallpaper]
 * @property {Boolean} cr_beta_opt_in
 * @property {Boolean} crleg_email_verified
 * @property {String} email
 * @property {String} maturity_rating
 * @property {{BR: String, UN: String}} extended_maturity_rating
 * @property {String} preferred_communication_language
 * @property {String} preferred_content_subtitle_language
 * @property {String} preferred_content_audio_language
 * @property {Boolean} qa_user
 * @property {String} username
 * @property {Boolean} [can_switch]
 * @property {Boolean} [is_primary]
 * @property {Boolean} [is_selected]
 * @property {Boolean} [do_not_sell]
 * @property {Boolean} [age_consent]
 */

/**
 * @typedef Cms
 * @type {Object}
 * @property {String} bucket
 * @property {String} policy
 * @property {String} signature
 * @property {String} key_pair_id
 * @property {String} expires
 */

/**
* @typedef CmsObj
* @type {Object}
* @property {String} bucket
* @property {String} policy
* @property {String} signature
* @property {String} keyPairId
* @property {String} expires
*/

/**
 * @typedef Storage
 * @type {Object}
 * @property {Credential} credential
 * @property {Device} device
 * @property {TokenObj} token
 * @property {CmsObj} cms
 * @property {AccountObj} account
 */

/**
 * @typedef CmsContainer
 * @type {Object}
 * @property {Cms} cms
 * @property {Cms} cms_beta
 * @property {Cms} cms_web
 * @property {Boolean} service_available
 * @property {Boolean} default_marketing_opt_in
 */

/**
 * @typedef RatingEpisode
 * @type {Object}
 * @property {Object} up
 * @property {String} up.displayed
 * @property {String} up.unit
 * @property {Object} down
 * @property {String} down.displayed
 * @property {String} down.unit
 * @property {Number} total
 * @property {String} rating
 */

/**
 * @typedef RatingBasic
 * @type {Object}
 * @property {String} displayed
 * @property {String} unit
 * @property {Number} percentage
 */

/**
 * @typedef RatingStars
 * @type {Object}
 * @ts-ignore
 * @property {RatingBasic} [1s]
 * @property {RatingBasic} [2s]
 * @property {RatingBasic} [3s]
 * @property {RatingBasic} [4s]
 * @property {RatingBasic} [5s] 
 * @property {String} average
 * @property {Number} total
 * @property {String} rating
 */

/**
 * @typedef AuthBase
 * @type {Object}
 * @property {String} token
 * @property {String} locale
 */

/**
 * @typedef {AuthBase & CmsObj} CmsAuth
 */

/**
 * @typedef AccountParamSub
 * @type {Object}
 * @property {String} locale
 * @property {String} audioLanguage
 * @typedef {TokenObj & AccountParamSub} AccountAuth
 */

/**
 * @typedef CustomListResponse
 * @type {Object}
 * @property {String} list_id
 * @property {Number} total
 * @property {String} modified_at
 */

/**
 * @typedef CrunchyRequestTmp
 * @type {Object}
 * @property {Boolean} [baseUrlIncluded]
 * 
 * @typedef {CrunchyRequestTmp & import('node-fetch').Request} CrunchyRequest
 */

/**
 * @typedef ProfileCreate
 * @type {Object}
 * @property {String} username
 * @property {String} avatar
 * @property {String} avatar
 * @property {String} wallpaper
 * @property {String} profile_name
 */

/**
 * @typedef AssesItem
 * @type {Object}
 * @property {String} title
 * @property {Array<{id: String, title: String}>} assets
 */

/**
 * @typedef ProfileResponse
 * @type {Object}
 * @property {Array<Profile>} profiles
 * @property {Number} tier_max_profiles
 * @property {Number} max_profiles
 */

/**
 * @typedef HomeProps
 * @type {Object}
 * @property {String} [description]
 * @property {String} [title]
 * @property {String} [analyticsId]
 * @property {String} [contentId]
 * @property {String} [tallImage]
 * @property {String} [wideImage]
 * @property {String} [logoImage]
 * @property {String} [link]
 * @property {String} [musicVideoId]
 */

/**
 * @typedef HomeItem
 * @type {Object}
 * @property {String} type
 * @property {String} id
 * @property {String} parentId
 * @property {HomeProps} props
 * @property {Array<HomeItem>} children
 */

/**
 * @typedef FetchConfig
 * @type {Object}
 * @property {Boolean} [direct] turn on return response as raw content
 * @property {Boolean} [cache] use cache
 * @property {Boolean} [sync] turn on sync mode
 */

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({});


/***/ }),

/***/ "./src/utils.js":
/*!**********************!*\
  !*** ./src/utils.js ***!
  \**********************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logger.js */ "./src/logger.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./config.js */ "./src/config.js");
/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./error.js */ "./src/error.js");






/**
 * In browsers cors make imposible make some request because of that
 * provide a custom function to make request
 * @type {Function}
 */
let fetchFunction = null

/**
 * Returning user-agent
 * @return {String}
 */
function getUserAgent() {
    return `Crunchyroll/${_config_js__WEBPACK_IMPORTED_MODULE_1__["default"].versionName} Android/${_config_js__WEBPACK_IMPORTED_MODULE_1__["default"].osReleaseVersion}`
}

/**
 * log api response
 * @param {String} fnName
 * @param {import('node-fetch').Response} res
 * @returns {Promise}
 */
async function logRes(fnName, res) {
    if (!(200 <= res.status && res.status < 300)) {
        _logger_js__WEBPACK_IMPORTED_MODULE_0__["default"].error(`Status Code: ${res.status} - ${fnName}`)
        /** @type {Object} */
        let result = null
        try {
            result = await res.json()
            _logger_js__WEBPACK_IMPORTED_MODULE_0__["default"].error(result)
        } catch (_e) {
            // ignore
        }
        if (result) {
            throw new _error_js__WEBPACK_IMPORTED_MODULE_2__["default"](result.error, result.code,
                result.context, res.status, res.statusText)
        } else {
            _logger_js__WEBPACK_IMPORTED_MODULE_0__["default"].error(res.statusText)
            throw new Error(res.statusText)
        }
    } else {
        _logger_js__WEBPACK_IMPORTED_MODULE_0__["default"].debug(`Status Code: ${res.status} - ${fnName}`)
    }
}

/**
 * Make http request and return raw response
 * @param {String} url
 * @param {import('node-fetch').Request} reqConfig
 * @param {import('./types').FetchConfig} [fnConfig]
 * @returns {Promise<import('node-fetch').Response>}
 */
async function makeRawRequest(url, reqConfig, fnConfig) {
    let fetchFn = null
    // @ts-expect-error
    if (reqConfig.baseUrlIncluded) {
        url = decodeURIComponent(`${url}`)
        // @ts-expect-error
        delete reqConfig.baseUrlIncluded
    } else {
        url = decodeURIComponent(`${_config_js__WEBPACK_IMPORTED_MODULE_1__["default"].urlBeta}${url}`)
    }
    _logger_js__WEBPACK_IMPORTED_MODULE_0__["default"].debug(`${reqConfig.method} - ${url}`)
    if (!reqConfig.headers) {
        // @ts-expect-error
        reqConfig.headers = {}
    }
    reqConfig.headers['User-Agent'] = getUserAgent()

    if (fetchFunction) {
        fetchFn = fetchFunction
    } else {
        try {
            fetchFn = window.fetch
        } catch (_e) {
            // #if process.env.NODE_COMPILING !== 'true'
//             fetchFn = await import('node-fetch')
//             fetchFn = fetchFn.default
            // #endif
        }
    }
    return fetchFn(url, reqConfig, fnConfig || {})
}


/**
 * Make http request
 * @param {String} fnName for loggin
 * @param {String} url
 * @param {import('node-fetch').Request} reqConfig
 * @param {import('./types').FetchConfig} [fnConfig]
 * @returns {Promise<Object>}
 */
async function makeRequest(fnName, url, reqConfig, fnConfig) {
    const res = await makeRawRequest(url, reqConfig, fnConfig)
    await logRes(fnName, res)
    let out = null
    try {
        out = await res.json()
    } catch (_e) {
        // nothing
    }
    return out
}


/**
 * Add key to object if not undefined
 * @param {Object} data
 * @param {String} key
 * @param {Object} value
 * @param {Function} [validator]
 */
function addParam(data, key, value, validator) {
    if (value !== undefined) {
        if (validator && !(validator(value))) {
            throw new Error(`Value ${value} for key ${key} is not valid.`)
        }
        data[key] = encodeURIComponent(value)
    }
}


/**
 * Convert snake case to camel case
 * @param {String} str
 * @returns {String}
 */
function toCamel(str) {
    return str.replace(/([-_][a-z])/ig, $1 => $1.toUpperCase().replace('_', ''))
}


/**
 * Convert camel case to snake case
 * @param {String} str
 * @returns {String}
 */
function toSnake(str) {
    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`)
}

/**
 * Return a toURLSearchParams object
 * @param {Object} data
 * @returns {Promise<import('url').URLSearchParams>}
 */
async function toURLSearchParams(data) {
    let URLSearchParamsClass = null

    try {
        URLSearchParamsClass = window.URLSearchParams
    } catch (_e) {
        // #if process.env.NODE_COMPILING !== 'true'
//         const url = await import('url')
//         if (url.URLSearchParams) {
//             URLSearchParamsClass = url.URLSearchParams
//         } else {
//             throw new Error()
//         }
        // #endif
    }
    return new URLSearchParamsClass(data)
}

/**
 * Set custom function to make request
 * @param {Function} fetchFn
 */
function setFetchFunction(fetchFn) {
    fetchFunction = fetchFn
}

/**
 * @param {String} str
 */
function camelCase(str) {
    return str.replace(/_([a-z])/g, (_m, w) => w.toUpperCase())
}

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    camelCase,
    logRes,
    makeRawRequest,
    makeRequest,
    addParam,
    toCamel,
    toSnake,
    toURLSearchParams,
    setFetchFunction,
    getUserAgent,
});


/***/ })

/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/ 
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ 	// Check if module is in cache
/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
/******/ 	if (cachedModule !== undefined) {
/******/ 		return cachedModule.exports;
/******/ 	}
/******/ 	// Create a new module (and put it into the cache)
/******/ 	var module = __webpack_module_cache__[moduleId] = {
/******/ 		// no module.id needed
/******/ 		// no module.loaded needed
/******/ 		exports: {}
/******/ 	};
/******/ 
/******/ 	// Execute the module function
/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 
/******/ 	// Return the exports of the module
/******/ 	return module.exports;
/******/ }
/******/ 
/************************************************************************/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ 	// define getter functions for harmony exports
/******/ 	__webpack_require__.d = (exports, definition) => {
/******/ 		for(var key in definition) {
/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 			}
/******/ 		}
/******/ 	};
/******/ })();
/******/ 
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/ 
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = (exports) => {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/ })();
/******/ 
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
(() => {
/*!**********************!*\
  !*** ./src/index.js ***!
  \**********************/
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CrunchyrollError: () => (/* reexport safe */ _error_js__WEBPACK_IMPORTED_MODULE_0__["default"]),
/* harmony export */   Types: () => (/* reexport module object */ _types_js__WEBPACK_IMPORTED_MODULE_16__),
/* harmony export */   api: () => (/* binding */ api),
/* harmony export */   config: () => (/* reexport safe */ _config_js__WEBPACK_IMPORTED_MODULE_3__["default"]),
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
/* harmony export */   localStore: () => (/* reexport safe */ _localStore_js__WEBPACK_IMPORTED_MODULE_2__["default"]),
/* harmony export */   logger: () => (/* reexport safe */ _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"]),
/* harmony export */   utils: () => (/* reexport safe */ _utils_js__WEBPACK_IMPORTED_MODULE_15__["default"])
/* harmony export */ });
/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./error.js */ "./src/error.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./logger.js */ "./src/logger.js");
/* harmony import */ var _localStore_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./localStore.js */ "./src/localStore.js");
/* harmony import */ var _config_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./config.js */ "./src/config.js");
/* harmony import */ var _services_account_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./services/account.js */ "./src/services/account.js");
/* harmony import */ var _services_assets_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./services/assets.js */ "./src/services/assets.js");
/* harmony import */ var _services_auth_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./services/auth.js */ "./src/services/auth.js");
/* harmony import */ var _services_content_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./services/content.js */ "./src/services/content.js");
/* harmony import */ var _services_discover_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./services/discover.js */ "./src/services/discover.js");
/* harmony import */ var _services_music_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./services/music.js */ "./src/services/music.js");
/* harmony import */ var _services_cms_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./services/cms.js */ "./src/services/cms.js");
/* harmony import */ var _services_index_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./services/index.js */ "./src/services/index.js");
/* harmony import */ var _services_review_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./services/review.js */ "./src/services/review.js");
/* harmony import */ var _services_subscription_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./services/subscription.js */ "./src/services/subscription.js");
/* harmony import */ var _services_drm_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./services/drm.js */ "./src/services/drm.js");
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
/* harmony import */ var _types_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./types.js */ "./src/types.js");



















const api = {
    account: _services_account_js__WEBPACK_IMPORTED_MODULE_4__["default"],
    assets: _services_assets_js__WEBPACK_IMPORTED_MODULE_5__["default"],
    auth: _services_auth_js__WEBPACK_IMPORTED_MODULE_6__["default"],
    cms: _services_cms_js__WEBPACK_IMPORTED_MODULE_10__["default"],
    content: _services_content_js__WEBPACK_IMPORTED_MODULE_7__["default"],
    discover: _services_discover_js__WEBPACK_IMPORTED_MODULE_8__["default"],
    drm: _services_drm_js__WEBPACK_IMPORTED_MODULE_14__["default"],
    index: _services_index_js__WEBPACK_IMPORTED_MODULE_11__["default"],
    music: _services_music_js__WEBPACK_IMPORTED_MODULE_9__["default"],
    review: _services_review_js__WEBPACK_IMPORTED_MODULE_12__["default"],
    subscription: _services_subscription_js__WEBPACK_IMPORTED_MODULE_13__["default"],
}

const CrunchyrollAPI = {
    logger: _logger_js__WEBPACK_IMPORTED_MODULE_1__["default"],
    localStore: _localStore_js__WEBPACK_IMPORTED_MODULE_2__["default"],
    CrunchyrollError: _error_js__WEBPACK_IMPORTED_MODULE_0__["default"],
    config: _config_js__WEBPACK_IMPORTED_MODULE_3__["default"],
    api,
    utils: _utils_js__WEBPACK_IMPORTED_MODULE_15__["default"],
}



/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CrunchyrollAPI);

})();

const __webpack_exports__CrunchyrollError = __webpack_exports__.CrunchyrollError;
const __webpack_exports__Types = __webpack_exports__.Types;
const __webpack_exports__api = __webpack_exports__.api;
const __webpack_exports__config = __webpack_exports__.config;
const __webpack_exports__default = __webpack_exports__["default"];
const __webpack_exports__localStore = __webpack_exports__.localStore;
const __webpack_exports__logger = __webpack_exports__.logger;
const __webpack_exports__utils = __webpack_exports__.utils;
export { __webpack_exports__CrunchyrollError as CrunchyrollError, __webpack_exports__Types as Types, __webpack_exports__api as api, __webpack_exports__config as config, __webpack_exports__default as default, __webpack_exports__localStore as localStore, __webpack_exports__logger as logger, __webpack_exports__utils as utils };

//# sourceMappingURL=crunchyroll-js-api.debug.js.map