lang=”zh-CN”>
window.__eventLoopCount = 0;
window.__eventLoopCountTimer = setInterval(() => {
Promise.resolve().then(() => {
window.__eventLoopCount += 1;
})
})
const DATABASE_NAME = ‘localforage’;
const OBJECT_STORE_NAME = ‘keyvaluepairs’;
async function openDb() {
return new Promise((resolve, reject) => {
if (!indexedDB) reject(‘does not support indexedDB’);

const openDbRequest = indexedDB.open(DATABASE_NAME);
openDbRequest.onsuccess = () => {
resolve(openDbRequest.result);
};

openDbRequest.onerror = e => {
reject(e);
};
openDbRequest.onblocked = e => {
reject(e);
};
openDbRequest.onupgradeneeded = e => {
e.target.transaction.abort();
reject(e);
};
});
}

async function getAllDbData() {
const db = await openDb();
const allKeysRequest = db.transaction(OBJECT_STORE_NAME, ‘readonly’).objectStore(OBJECT_STORE_NAME).getAllKeys();
const allValuesRequest = db.transaction(OBJECT_STORE_NAME, ‘readonly’).objectStore(OBJECT_STORE_NAME).getAll();

const data = await Promise.all([
new Promise((resolve, reject) => {
allKeysRequest.onsuccess = (event) => {
resolve(event.target.result);
}
allKeysRequest.onerror = (error) => {
reject(error);
}
}),
new Promise((resolve) => {
allValuesRequest.onsuccess = (event) => {
resolve(event.target.result);
}
allValuesRequest.onerror = (error) => {
reject(error);
}
})
]);

db.close();

return { keys: data[0], values: data[1] };
}

async function getDbData(key) {
const db = await openDb();
const request = db.transaction(OBJECT_STORE_NAME, ‘readonly’).objectStore(OBJECT_STORE_NAME).get(key);

const data = await new Promise((resolve, reject) => {
request.onsuccess = event => {
resolve(event.target.result);
};
request.onerror = error => {
reject(error);
};
});

db.close();

return data;
}

async function setDbData(key, value) {
const db = await openDb();
const request = db.transaction(OBJECT_STORE_NAME, ‘readwrite’).objectStore(OBJECT_STORE_NAME).put(value, key);

const data = await new Promise((resolve, reject) => {
request.onsuccess = event => {
resolve(event.target.result);
};
request.onerror = error => {
reject(error);
};
});

db.close();

return data;
}

body {
background-color: #191919;
}

window.serviceWorkerPath = ‘/static/sw/service-worker.1cac8ffd.js’

window.__PRELOADED_STATE__ = {“remoteConfig”:{“WEBVIEW_APP_USER_AGENTS”:”webview-app”}}
// Use this variable as first hydration flag.
// Mostly will used on components constructor to skip
// first frame empty list.
window.__IS_HYDRATED__ = false;

window.__SSR_ENVIRONMENT__ = {};

window.__RESOURCE_URL__ = {“api”:”api”,”watch”:”https:u002Fu002Fwatch.swag.live”,”public”:”https:u002Fu002Fpublic.swag.live”,”rssFeed”:”api”};

window.__PUBLIC_URL_PATH__ = {“PUBLIC_MESSAGE_URL_PATH”:”u002Fmessagesu002F”,”PUBLIC_PRODUCT_URL_PATH”:”u002Fproductsu002F”,”PUBLIC_BADGE_URL_PATH”:”u002Fbadgesu002F”,”PUBLIC_USER_URL_PATH”:”u002Fusersu002F”,”PUBLIC_LEADERBOARD_URL_PATH”:”u002Fleaderboardsu002F”,”PUBLIC_SHOP_URL_PATH”:”u002Fshopu002F”,”PUBLIC_LOGO_URL_PATH”:”u002Flogosu002F”,”PUBLIC_APP_URL_PATH”:”u002Fappu002F”};

let __isOnWebviewApp = false;

try {
if (
window.__PRELOADED_STATE__ &&
window.__PRELOADED_STATE__.remoteConfig &&
window.__PRELOADED_STATE__.remoteConfig[‘WEBVIEW_APP_USER_AGENTS’]
) {
const ua = navigator.userAgent;
__isOnWebviewApp = window.__PRELOADED_STATE__.remoteConfig[
‘WEBVIEW_APP_USER_AGENTS’
]
.split(‘ ‘)
.some(id => ua.includes(id));
}
} catch (error) {
console.debug(‘error when check is on webview app’, error);
}

window.__isOnWebviewApp = __isOnWebviewApp;

if (__isOnWebviewApp) {
console.debug(‘jsBridgeInterface isOnWebviewApp’);

window.__WEBVIEW_READY_PROMISE__ = new Promise(resolve => {
window.__WEBVIEW_READY_RESOLVE__ = resolve;
});
console.debug(‘jsBridgeInterface webviewReady promise done’);

const getRefreshToken = async () => {
try {
const meData = window.getDbData && (await window.getDbData(‘me’));
return (meData && meData.refreshToken) || null;
} catch (_) {
//
}
return null;
};

const setResourceUrl = remoteConfig => {
if (remoteConfig) {
console.debug(‘jsBridgeInterface setResourceUrl start’);
const resourceUrl = {};
const resourceUrlConfigMaps = {“API_URL_PREFIX”:”api”,”WATCH_URL_PREFIX”:”watch”,”PUBLIC_URL_PREFIX”:”public”,”RSS_FEED_URL_PREFIX”:”rssFeed”};
Object.keys(resourceUrlConfigMaps).forEach(key => {
if (remoteConfig[key]) {
resourceUrl[resourceUrlConfigMaps[key]] = remoteConfig[key];
}
});

if (Object.keys(resourceUrl).length) {
if (!window.__RESOURCE_URL__) window.__RESOURCE_URL__ = {};

window.__RESOURCE_URL__ = {
…window.__RESOURCE_URL__,
…resourceUrl,
};
}
console.debug(‘jsBridgeInterface setResourceUrl done’);
}

console.debug(‘jsBridgeInterface webviewReady resolve’);
window.__WEBVIEW_READY_RESOLVE__();
};

const setupWebAppFunctions = () => {
console.debug(‘jsBridgeInterface setupWebAppFunctions start’);
if (!window.WebApp) {
console.debug(
‘jsBridgeInterface setupWebAppFunctions window.WebApp is null’
);
window.WebApp = {};
}

const functions = {
getRefreshToken,
setResourceUrl,
};

Object.entries(functions).forEach(([name, func]) => {
if (!window.WebApp[name]) {
window.WebApp[name] = func;
}
});

console.debug(‘jsBridgeInterface setupWebAppFunctions done’);
};

const overrideConsoleError = () => {
console.debug(‘jsBridgeInterface overrideConsoleError start’);
const stringifyForLog = value => {
try {
if (typeof value === ‘string’) return value;
if (value instanceof Error) return value.message || String(value);
return JSON.stringify(value, function (_, v) {
if (v instanceof Error) {
return { name: v.name, message: v.message, stack: v.stack };
}
return v;
});
} catch (_) {
try {
return String(value);
} catch (_) {
return ‘[unserializable]’;
}
}
};

const getErrorStackFromArgs = args => {
for (let i = 0; i {
try {
if (window.WebApp && typeof window.WebApp.callHandler === ‘function’) {
console.debug(‘jsBridgeInterface sendErrorToNative onLogMessageReceived’, { message, payload });

window.WebApp.callHandler(
‘onLogMessageReceived’,
‘E’,
message,
payload || {}
);
}
} catch (_) {}
};

const originalConsoleError = window.console.error;

window.console.error = function () {
try {
originalConsoleError.apply(null, arguments);
} catch (_) {}

try {
const args = Array.prototype.slice.call(arguments);
sendErrorToNative(args.map(stringifyForLog).join(‘ ‘), { stack: getErrorStackFromArgs(args) });
} catch (_) {}
};
console.debug(‘jsBridgeInterface overrideConsoleError done’);
};

setupWebAppFunctions();

if (window.WebApp) {
if (window.WebApp.remoteConfig) {
setResourceUrl(window.WebApp.remoteConfig);
}

if (window.WebApp.callHandler) {
overrideConsoleError();
}
} else {
window.addEventListener(
‘flutterInAppWebViewPlatformReady’,
() => {
console.debug(‘jsBridgeInterface flutterInAppWebViewPlatformReady’);
setResourceUrl(window.WebApp.remoteConfig);
overrideConsoleError();
},
{ once: true }
);
}
}

const mainDomain = location.hostname.split(‘.’).slice(-2).join(‘.’);

const resourceDomain = ‘https://api.’ + mainDomain;

async function getResourceDomain() {
if (window.__isOnWebviewApp) {
console.debug(‘getResourceDomain isOnWebviewApp’);

try {
await window.__WEBVIEW_READY_PROMISE__;
console.debug(‘getResourceDomain webviewReady done’);

return /^http/.test(window.__RESOURCE_URL__[‘api’])
? window.__RESOURCE_URL__[‘api’]
: resourceDomain;
} catch (error) {
console.debug(‘error when get resource domain from webview’, error);
}
}

if (window.__isOnMdm) {
console.debug(‘getResourceDomain isOnMdm’);

return /^http/.test(window.__RESOURCE_URL__[‘api’])
? window.__RESOURCE_URL__[‘api’]
: resourceDomain;
}

return resourceDomain;
}

// uuidv4 iife
!function(t,e){“object”==typeof exports&&”undefined”!=typeof module?module.exports=e():”function”==typeof define&&define.amd?define(e):(t=t||self).uuidv4=e()}(this,(function(){“use strict”;var t=”undefined”!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||”undefined”!=typeof msCrypto&&”function”==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto),e=new Uint8Array(16);function n(){if(!t)throw new Error(“crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported”);return t(e)}for(var o=[],r=0;r<256;++r)o.push((r+256).toString(16).substr(1));return function(t,e,r){"string"==typeof t&&(e="binary"===t?new Uint8Array(16):null,t=null);var u=(t=t||{}).random||(t.rng||n)();if(u[6]=15&u[6]|64,u[8]=63&u[8]|128,e){for(var i=r||0,d=0;d<16;++d)e[i+d]=u[d];return e}return function(t,e){var n=e||0,r=o;return(r[t[n+0]]+r[t[n+1]]+r[t[n+2]]+r[t[n+3]]+"-"+r[t[n+4]]+r[t[n+5]]+"-"+r[t[n+6]]+r[t[n+7]]+"-"+r[t[n+8]]+r[t[n+9]]+"-"+r[t[n+10]]+r[t[n+11]]+r[t[n+12]]+r[t[n+13]]+r[t[n+14]]+r[t[n+15]]).toLowerCase()}(u)}}));

async function syncClientId(clientId) {
console.debug("sync client Id");
try {
localStorage.setItem("_clientId", clientId);
console.debug("sync client Id to localStorage");
} catch (e) {
console.debug("error when sync client id in localStorage", e);
}
try {
const meData = await getDbData("me");
if (meData && meData.clientId) {
meData.clientId = clientId;
await setDbData("me", meData);
console.debug("sync client Id to indexedDB", clientId);
}
} catch (e) {
console.debug("error when sync client id in indexedDB", e);
}
}

async function getClientId() {
let clientId;

if (__isOnWebviewApp && window.WebApp.clientId) {
clientId = window.WebApp.clientId;
}

if (!clientId) {
try {
clientId = localStorage.getItem("_clientId");
} catch (_) {
const meData = await getDbData("me");
if (meData && meData.clientId) clientId = meData.clientId;
}
clientId = clientId || uuidv4();
}

return clientId;
}

const TRACK_UTM_LIST = [“affise_click_id”,”affise_offer_id”,”affise_time”,”ao_time”,”c_track_id”,”c_aff_id”,”c_off_id”,”voluum”,”app_distributor”,”utm_source”,”utm_medium”,”utm_campaign”,”utm_content”,”utm_term”,”pwa”,”homescreen”,”_5wag”,”_mdm”,”mdm”,”_flavor”];
const FLAVOR_UTM_LIST = [“pwa”,”homescreen”,”_5wag”,”_mdm”,”mdm”,”_flavor”];

function getCurrentUtm({ searchParams, existUtm = {} }) {
const shouldOverrideAllUtm = !!TRACK_UTM_LIST.filter(key => {
return key.startsWith(‘utm_’) && searchParams.get(key);
}).length;

const currentUtm = TRACK_UTM_LIST.reduce((prev, curr) => {
if (FLAVOR_UTM_LIST.includes(curr)) {
if (!searchParams.get(curr)) {
if (existUtm[curr])
return Object.assign(prev, { [curr]: existUtm[curr] });
else return prev;
}

switch (curr) {
case ‘_5wag’:
return Object.assign(prev, { [‘_flavor’]: ‘city.cafe.browser’ }); // _5wag is not a formal flavor
case ‘_mdm’:
case ‘mdm’:
return Object.assign(prev, { [‘mdm’]: true });
case ‘pwa’:
case ‘homescreen’:
return Object.assign(prev, { [‘pwa’]: true });
default: // ‘_flavor’
return Object.assign(prev, {
[curr]: searchParams.get(curr) || undefined,
});
}
}

if (curr.startsWith(‘utm_’)) {
if (!shouldOverrideAllUtm && !searchParams.get(curr) && !existUtm[curr])
return prev;
return Object.assign(prev, {
[curr]: shouldOverrideAllUtm
? searchParams.get(curr) || undefined
: existUtm[curr],
});
}

let acceptableKeysWithPrefix = [],
acceptableKeysObject = {};
searchParams.forEach((value, key) => {
if (key.startsWith(curr)) acceptableKeysWithPrefix.push(key);
});
if (acceptableKeysWithPrefix.length) {
acceptableKeysWithPrefix.forEach(key => {
Object.assign(acceptableKeysObject, {
[key]: searchParams.get(key) || existUtm[key],
});
});
return Object.assign(prev, acceptableKeysObject);
}

if (!searchParams.get(curr) && !existUtm[curr]) return prev;
return Object.assign(prev, {
[curr]: searchParams.get(curr) || existUtm[curr],
});
}, {});
return currentUtm;
};

function getXTrackHeader() {
const query = new URLSearchParams(window.location.search);

const trimmedQuery = new URLSearchParams();
query.forEach((value, key) => {
if (Array.isArray(value)) {
// avoid ?a=b&a=c turns into ?a=b,c
// we only keep first one, ?a=b
return trimmedQuery.append(key, value[0]);
}
return trimmedQuery.append(key, value);
});

const utmObject = getCurrentUtm({ searchParams: trimmedQuery });

let xTrackArray = [];
TRACK_UTM_LIST.forEach(key => {
if (utmObject[key] && !FLAVOR_UTM_LIST.includes(key)) {
xTrackArray.push(`${key}=${encodeURIComponent(utmObject[key])}`);
}
});

const detectedHostname = window.location.hostname;
// NO underscore `_` prefix in X-Track
if (utmObject[‘_flavor’] && utmObject[‘_flavor’] !== detectedHostname) {
xTrackArray.push(`flavor=${utmObject[‘_flavor’]}`);
}

const isPwa = utmObject[‘pwa’];
if (isPwa) {
xTrackArray.push(‘pwa=1’);
}

const isMdm = utmObject[‘mdm’];
if (isMdm) {
xTrackArray.push(‘mdm=1’);
}

// Get tracking payload from GTM, window.__X_TRACK_PAYLOAD__
if (window.__X_TRACK_PAYLOAD__) {
Object.keys(window.__X_TRACK_PAYLOAD__).forEach(key => {
xTrackArray.push(`${key}=${window.__X_TRACK_PAYLOAD__[key]}`);
});
}

return xTrackArray
.filter(key => key)
.sort()
.join(‘;’);
};

const query = ‘?_o=’ + window.location.origin + ‘&lang=zh’;

const responseDecryptionUtil = async ({ response }) => {
const initializationVector = response.headers.get(‘x-encrypted-iv’);
const encryptionAlgorithm = response.headers.get(‘x-encrypted-algo’);
const encryptionKeyId = response.headers.get(‘x-encrypted-key-id’);

const hasEncryptionHeaders =
initializationVector && encryptionAlgorithm && encryptionKeyId;

const rawBuffer = await response.arrayBuffer();
const contentType = response.headers.get(‘x-content-type’);

if (hasEncryptionHeaders) {
const publicUrlEncryptKeys =
(
globalThis.WebApp?.remoteConfig?.PUBLIC_URL_ENCRYPT_KEYS ||
// globalThis.WebApp.remoteConfig is set in jsBridgeInterfaceSnippet.js from domain tracker
globalThis.Mdm?.remoteConfig?.PUBLIC_URL_ENCRYPT_KEYS ||
// globalThis.Mdm.remoteConfig is set in getMdmQueryParamsSnippet.js
env.PUBLIC_URL_ENCRYPT_KEYS ||
// ServiceWorkerMessenger updates remoteConfig.data to service worker’s globalThis context in updateConfigurations action
globalThis.remoteConfig?.data?.PUBLIC_URL_ENCRYPT_KEYS ||
”
)
.split(‘ ‘)
.filter(Boolean) || [];
const publicUrlEncryptKeyMap = publicUrlEncryptKeys.reduce(
(keyMap, key) => {
const [keyId, keyValue] = key.split(‘:’);
keyMap.set(keyId, keyValue);
return keyMap;
},
new Map()
);

const subtleCrypto =
globalThis.crypto.subtle || globalThis.crypto.webkitSubtle;
const cryptoKey = await subtleCrypto.importKey(
‘raw’,
// Backend creates a Buffer with Buffer.from(), which is a subclass of JavaScript’s Uint8Array class (https://nodejs.org/api/buffer.html)
Uint8Array.from(
atob(publicUrlEncryptKeyMap.get(encryptionKeyId)),
// atob() returns an binary string, and then we use charCodeAt() to transform it to an array of bytes.
c => c.charCodeAt(0)
),
encryptionAlgorithm,
false,
[‘decrypt’]
);
const decryptedBuffer = await subtleCrypto.decrypt(
{
name: encryptionAlgorithm,
iv: Uint8Array.from(atob(initializationVector), c => c.charCodeAt(0)),
},
cryptoKey,
rawBuffer
);
return { buffer: decryptedBuffer, contentType };
}

return { buffer: rawBuffer, contentType };
};

const handleEncryptedResponse = async ({ response }) => {
const hasEncryptionHeaders =
response.headers.get(‘x-encrypted-iv’) &&
response.headers.get(‘x-encrypted-algo’) &&
response.headers.get(‘x-encrypted-key-id’);

if (!hasEncryptionHeaders) {
console.debug(‘handleEncryptedResponse() no encryption headers found’);
return { response };
}

try {
const { buffer, contentType } = await responseDecryptionUtil({ response });
const newHeaders = new Headers(response.headers);
// remove encryption headers to avoid responseDecryptionUtil() to decrypt again
newHeaders.delete(‘x-encrypted-iv’);
newHeaders.delete(‘x-encrypted-algo’);
newHeaders.delete(‘x-encrypted-key-id’);

if (contentType) {
newHeaders.set(‘content-type’, contentType);
}

const decryptedResponse = new Response(buffer, {
status: response.status,
statusText: response.statusText,
headers: newHeaders,
});

// Copy read-only Response properties that cannot be set via constructor
Object.defineProperty(decryptedResponse, ‘url’, {
value: response.url,
writable: false,
enumerable: true,
configurable: false,
});

Object.defineProperty(decryptedResponse, ‘redirected’, {
value: response.redirected,
writable: false,
enumerable: true,
configurable: false,
});

Object.defineProperty(decryptedResponse, ‘type’, {
value: response.type,
writable: false,
enumerable: true,
configurable: false,
});

console.debug(‘handleEncryptedResponse() response decrypted successfully’);
return { response: decryptedResponse };
} catch (error) {
console.debug(‘handleEncryptedResponse() decryption failed’, { error });
return { response };
}
};

async function fetchConfigureData() {
try {
const clientId = await getClientId();
syncClientId(clientId);

const resourceDomain = await getResourceDomain();
const configUrl = resourceDomain + ‘/configure.json’ + query;

let xTrackHeader = ”;
if (!xTrackHeader && getXTrackHeader) {
xTrackHeader = getXTrackHeader();
}

const response = await fetch(configUrl, {
headers: {
[‘X-Track’]: xTrackHeader,
[‘X-Client-Id’]: clientId,
},
});

const { response: decryptedResponse } = await handleEncryptedResponse({ response });

if (decryptedResponse.ok) {
const configData = await decryptedResponse.json();
return configData;
}
} catch (error) {
console.debug(‘fetchConfigureData() failed’, { error });
}
}
window.__FETCH_CONFIGURE_JSON_PROMISE__ = fetchConfigureData();

const Format = {
ISO: ‘iso’,
UNIX: ‘unix’,
};
const Accuracy = {
MILLISECOND: ‘ms’,
SECOND: ‘s’,
};
const ONE_MINUTE = 1000 * 60;

const ntpQuery =
‘?format=’ + Format.UNIX + ‘&accuracy=’ + Accuracy.MILLISECOND;

class NtpFetcher {
static _instance = null;
constructor() {
if (NtpFetcher._instance) {
return NtpFetcher._instance;
}
NtpFetcher._instance = this;

this.intervalId = null;
this.eventTarget = new EventTarget();
this.ntpData = null;
this._startInterval();
}

/**
* call fetchNtpData() and lock if fetchNtpData() is already calling.
*/
async fetchTime() {
if (!this.fetchNtpPromise) {
this.fetchNtpPromise = this._fetchNtpData();
}
try {
await this.fetchNtpPromise;
} catch (_) {}
this.fetchNtpPromise = null;
}

/**
* Fetches the current time from the server and updates the ntpData.
*/
_fetchNtpData() {
return new Promise(async (resolve, reject) => {
try {
if (!this.clientId) {
this.clientId = await getClientId();
syncClientId(this.clientId);
}

if (!this.ntpConfigUrl) {
const resourceDomain = await getResourceDomain();
this.ntpConfigUrl = resourceDomain + ‘/time’ + ntpQuery;
}

const response = await fetch(this.ntpConfigUrl, {
headers: {
[‘X-Track’]: ”,
[‘X-Client-Id’]: this.clientId,
},
});

if (response.ok) {
const payload = await response.text();
this.setNtpData({
server: payload * 1000 || undefined,
client: Date.now(),
});
resolve();
}
} catch (_) {
reject();
}
});
}

/**
* Sets the NTP data and emits an event.
* @param {Object} payload – The NTP data payload.
* @param {number} payload.server – The server time.
* @param {number} payload.client – The client time.
*/
setNtpData(payload) {
this.ntpData = payload;
this.emit(payload);
}

/**
* Returns the current NTP data or the current client time if NTP data is unavailable.
* @returns {Object} The NTP data or current client time.
*/
getNtpTimestamp() {
return this.ntpData || { server: Date.now(), client: Date.now() };
}

/**
* Asynchronously returns the current NTP data.
* @returns {Promise