puppeteer-browser-agent
Version:
Puppeteer browser agent for use in AI agent systems
1,579 lines (1,574 loc) • 15.3 MB
JavaScript
import { createRequire as createRequired9b45f9e48434a56a3dca49cd83e9045 } from 'module';
import { fileURLToPath as fileURLToPathd9b45f9e48434a56a3dca49cd83e9045 } from 'url';
import { dirname as dirnamed9b45f9e48434a56a3dca49cd83e9045 } from 'path';
// using var here to allow subsequent override by authors of this
// library that would be using the same ESM trick
var require = createRequired9b45f9e48434a56a3dca49cd83e9045(import.meta.url);
var __filename = fileURLToPathd9b45f9e48434a56a3dca49cd83e9045(import.meta.url);
var __dirname = dirnamed9b45f9e48434a56a3dca49cd83e9045(__filename);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
}) : x2)(function(x2) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw Error('Dynamic require of "' + x2 + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/puppeteer-core/lib/esm/third_party/rxjs/rxjs.js
function __extends(d2, b2) {
if (typeof b2 !== "function" && b2 !== null)
throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
extendStatics(d2, b2);
function __() {
this.constructor = d2;
}
d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
}
function __awaiter(thisArg, _arguments, P2, generator) {
function adopt(value) {
return value instanceof P2 ? value : new P2(function(resolve5) {
resolve5(value);
});
}
return new (P2 || (P2 = Promise))(function(resolve5, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e2) {
reject(e2);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e2) {
reject(e2);
}
}
function step(result) {
result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _2 = { label: 0, sent: function() {
if (t2[0] & 1)
throw t2[1];
return t2[1];
}, trys: [], ops: [] }, f2, y2, t2, g2;
return g2 = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
return this;
}), g2;
function verb(n2) {
return function(v2) {
return step([n2, v2]);
};
}
function step(op) {
if (f2)
throw new TypeError("Generator is already executing.");
while (g2 && (g2 = 0, op[0] && (_2 = 0)), _2)
try {
if (f2 = 1, y2 && (t2 = op[0] & 2 ? y2["return"] : op[0] ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0) : y2.next) && !(t2 = t2.call(y2, op[1])).done)
return t2;
if (y2 = 0, t2)
op = [op[0] & 2, t2.value];
switch (op[0]) {
case 0:
case 1:
t2 = op;
break;
case 4:
_2.label++;
return { value: op[1], done: false };
case 5:
_2.label++;
y2 = op[1];
op = [0];
continue;
case 7:
op = _2.ops.pop();
_2.trys.pop();
continue;
default:
if (!(t2 = _2.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_2 = 0;
continue;
}
if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
_2.label = op[1];
break;
}
if (op[0] === 6 && _2.label < t2[1]) {
_2.label = t2[1];
t2 = op;
break;
}
if (t2 && _2.label < t2[2]) {
_2.label = t2[2];
_2.ops.push(op);
break;
}
if (t2[2])
_2.ops.pop();
_2.trys.pop();
continue;
}
op = body.call(thisArg, _2);
} catch (e2) {
op = [6, e2];
y2 = 0;
} finally {
f2 = t2 = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __values(o2) {
var s2 = typeof Symbol === "function" && Symbol.iterator, m2 = s2 && o2[s2], i2 = 0;
if (m2)
return m2.call(o2);
if (o2 && typeof o2.length === "number")
return {
next: function() {
if (o2 && i2 >= o2.length)
o2 = void 0;
return { value: o2 && o2[i2++], done: !o2 };
}
};
throw new TypeError(s2 ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o2, n2) {
var m2 = typeof Symbol === "function" && o2[Symbol.iterator];
if (!m2)
return o2;
var i2 = m2.call(o2), r2, ar2 = [], e2;
try {
while ((n2 === void 0 || n2-- > 0) && !(r2 = i2.next()).done)
ar2.push(r2.value);
} catch (error) {
e2 = { error };
} finally {
try {
if (r2 && !r2.done && (m2 = i2["return"]))
m2.call(i2);
} finally {
if (e2)
throw e2.error;
}
}
return ar2;
}
function __spreadArray(to, from2, pack) {
if (pack || arguments.length === 2)
for (var i2 = 0, l2 = from2.length, ar2; i2 < l2; i2++) {
if (ar2 || !(i2 in from2)) {
if (!ar2)
ar2 = Array.prototype.slice.call(from2, 0, i2);
ar2[i2] = from2[i2];
}
}
return to.concat(ar2 || Array.prototype.slice.call(from2));
}
function __await(v2) {
return this instanceof __await ? (this.v = v2, this) : new __await(v2);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g2 = generator.apply(thisArg, _arguments || []), i2, q2 = [];
return i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
return this;
}, i2;
function verb(n2) {
if (g2[n2])
i2[n2] = function(v2) {
return new Promise(function(a2, b2) {
q2.push([n2, v2, a2, b2]) > 1 || resume(n2, v2);
});
};
}
function resume(n2, v2) {
try {
step(g2[n2](v2));
} catch (e2) {
settle(q2[0][3], e2);
}
}
function step(r2) {
r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q2[0][2], r2);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f2, v2) {
if (f2(v2), q2.shift(), q2.length)
resume(q2[0][0], q2[0][1]);
}
}
function __asyncValues(o2) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m2 = o2[Symbol.asyncIterator], i2;
return m2 ? m2.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
return this;
}, i2);
function verb(n2) {
i2[n2] = o2[n2] && function(v2) {
return new Promise(function(resolve5, reject) {
v2 = o2[n2](v2), settle(resolve5, reject, v2.done, v2.value);
});
};
}
function settle(resolve5, reject, d2, v2) {
Promise.resolve(v2).then(function(v22) {
resolve5({ value: v22, done: d2 });
}, reject);
}
}
function isFunction(value) {
return typeof value === "function";
}
function createErrorClass(createImpl) {
var _super = function(instance) {
Error.call(instance);
instance.stack = new Error().stack;
};
var ctorFunc = createImpl(_super);
ctorFunc.prototype = Object.create(Error.prototype);
ctorFunc.prototype.constructor = ctorFunc;
return ctorFunc;
}
function arrRemove(arr, item) {
if (arr) {
var index2 = arr.indexOf(item);
0 <= index2 && arr.splice(index2, 1);
}
}
function isSubscription(value) {
return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
}
function execFinalizer(finalizer) {
if (isFunction(finalizer)) {
finalizer();
} else {
finalizer.unsubscribe();
}
}
function reportUnhandledError(err) {
timeoutProvider.setTimeout(function() {
var onUnhandledError = config.onUnhandledError;
if (onUnhandledError) {
onUnhandledError(err);
} else {
throw err;
}
});
}
function noop() {
}
function errorNotification(error) {
return createNotification("E", void 0, error);
}
function nextNotification(value) {
return createNotification("N", value, void 0);
}
function createNotification(kind2, value, error) {
return {
kind: kind2,
value,
error
};
}
function errorContext(cb) {
if (config.useDeprecatedSynchronousErrorHandling) {
var isRoot = !context;
if (isRoot) {
context = { errorThrown: false, error: null };
}
cb();
if (isRoot) {
var _a6 = context, errorThrown = _a6.errorThrown, error = _a6.error;
context = null;
if (errorThrown) {
throw error;
}
}
} else {
cb();
}
}
function captureError(err) {
if (config.useDeprecatedSynchronousErrorHandling && context) {
context.errorThrown = true;
context.error = err;
}
}
function bind(fn, thisArg) {
return _bind.call(fn, thisArg);
}
function handleUnhandledError(error) {
if (config.useDeprecatedSynchronousErrorHandling) {
captureError(error);
} else {
reportUnhandledError(error);
}
}
function defaultErrorHandler(err) {
throw err;
}
function handleStoppedNotification(notification, subscriber) {
var onStoppedNotification = config.onStoppedNotification;
onStoppedNotification && timeoutProvider.setTimeout(function() {
return onStoppedNotification(notification, subscriber);
});
}
function identity(x2) {
return x2;
}
function pipe() {
var fns = [];
for (var _i = 0; _i < arguments.length; _i++) {
fns[_i] = arguments[_i];
}
return pipeFromArray(fns);
}
function pipeFromArray(fns) {
if (fns.length === 0) {
return identity;
}
if (fns.length === 1) {
return fns[0];
}
return function piped(input) {
return fns.reduce(function(prev2, fn) {
return fn(prev2);
}, input);
};
}
function getPromiseCtor(promiseCtor) {
var _a6;
return (_a6 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a6 !== void 0 ? _a6 : Promise;
}
function isObserver(value) {
return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
}
function isSubscriber(value) {
return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
}
function hasLift(source2) {
return isFunction(source2 === null || source2 === void 0 ? void 0 : source2.lift);
}
function operate(init) {
return function(source2) {
if (hasLift(source2)) {
return source2.lift(function(liftedSource) {
try {
return init(liftedSource, this);
} catch (err) {
this.error(err);
}
});
}
throw new TypeError("Unable to lift unknown Observable type");
};
}
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
}
function isScheduler(value) {
return value && isFunction(value.schedule);
}
function last(arr) {
return arr[arr.length - 1];
}
function popResultSelector(args) {
return isFunction(last(args)) ? args.pop() : void 0;
}
function popScheduler(args) {
return isScheduler(last(args)) ? args.pop() : void 0;
}
function popNumber(args, defaultValue) {
return typeof last(args) === "number" ? args.pop() : defaultValue;
}
function isPromise(value) {
return isFunction(value === null || value === void 0 ? void 0 : value.then);
}
function isInteropObservable(input) {
return isFunction(input[observable]);
}
function isAsyncIterable(obj) {
return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
}
function createInvalidObservableTypeError(input) {
return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
}
function getSymbolIterator() {
if (typeof Symbol !== "function" || !Symbol.iterator) {
return "@@iterator";
}
return Symbol.iterator;
}
function isIterable(input) {
return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
}
function readableStreamLikeToAsyncGenerator(readableStream) {
return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
var reader, _a6, value, done;
return __generator(this, function(_b2) {
switch (_b2.label) {
case 0:
reader = readableStream.getReader();
_b2.label = 1;
case 1:
_b2.trys.push([1, , 9, 10]);
_b2.label = 2;
case 2:
if (false)
return [3, 8];
return [4, __await(reader.read())];
case 3:
_a6 = _b2.sent(), value = _a6.value, done = _a6.done;
if (!done)
return [3, 5];
return [4, __await(void 0)];
case 4:
return [2, _b2.sent()];
case 5:
return [4, __await(value)];
case 6:
return [4, _b2.sent()];
case 7:
_b2.sent();
return [3, 2];
case 8:
return [3, 10];
case 9:
reader.releaseLock();
return [7];
case 10:
return [2];
}
});
});
}
function isReadableStreamLike(obj) {
return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
}
function innerFrom(input) {
if (input instanceof Observable) {
return input;
}
if (input != null) {
if (isInteropObservable(input)) {
return fromInteropObservable(input);
}
if (isArrayLike(input)) {
return fromArrayLike(input);
}
if (isPromise(input)) {
return fromPromise(input);
}
if (isAsyncIterable(input)) {
return fromAsyncIterable(input);
}
if (isIterable(input)) {
return fromIterable(input);
}
if (isReadableStreamLike(input)) {
return fromReadableStreamLike(input);
}
}
throw createInvalidObservableTypeError(input);
}
function fromInteropObservable(obj) {
return new Observable(function(subscriber) {
var obs = obj[observable]();
if (isFunction(obs.subscribe)) {
return obs.subscribe(subscriber);
}
throw new TypeError("Provided object does not correctly implement Symbol.observable");
});
}
function fromArrayLike(array) {
return new Observable(function(subscriber) {
for (var i2 = 0; i2 < array.length && !subscriber.closed; i2++) {
subscriber.next(array[i2]);
}
subscriber.complete();
});
}
function fromPromise(promise) {
return new Observable(function(subscriber) {
promise.then(function(value) {
if (!subscriber.closed) {
subscriber.next(value);
subscriber.complete();
}
}, function(err) {
return subscriber.error(err);
}).then(null, reportUnhandledError);
});
}
function fromIterable(iterable) {
return new Observable(function(subscriber) {
var e_1, _a6;
try {
for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
var value = iterable_1_1.value;
subscriber.next(value);
if (subscriber.closed) {
return;
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (iterable_1_1 && !iterable_1_1.done && (_a6 = iterable_1.return))
_a6.call(iterable_1);
} finally {
if (e_1)
throw e_1.error;
}
}
subscriber.complete();
});
}
function fromAsyncIterable(asyncIterable) {
return new Observable(function(subscriber) {
process2(asyncIterable, subscriber).catch(function(err) {
return subscriber.error(err);
});
});
}
function fromReadableStreamLike(readableStream) {
return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
}
function process2(asyncIterable, subscriber) {
var asyncIterable_1, asyncIterable_1_1;
var e_2, _a6;
return __awaiter(this, void 0, void 0, function() {
var value, e_2_1;
return __generator(this, function(_b2) {
switch (_b2.label) {
case 0:
_b2.trys.push([0, 5, 6, 11]);
asyncIterable_1 = __asyncValues(asyncIterable);
_b2.label = 1;
case 1:
return [4, asyncIterable_1.next()];
case 2:
if (!(asyncIterable_1_1 = _b2.sent(), !asyncIterable_1_1.done))
return [3, 4];
value = asyncIterable_1_1.value;
subscriber.next(value);
if (subscriber.closed) {
return [2];
}
_b2.label = 3;
case 3:
return [3, 1];
case 4:
return [3, 11];
case 5:
e_2_1 = _b2.sent();
e_2 = { error: e_2_1 };
return [3, 11];
case 6:
_b2.trys.push([6, , 9, 10]);
if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a6 = asyncIterable_1.return)))
return [3, 8];
return [4, _a6.call(asyncIterable_1)];
case 7:
_b2.sent();
_b2.label = 8;
case 8:
return [3, 10];
case 9:
if (e_2)
throw e_2.error;
return [7];
case 10:
return [7];
case 11:
subscriber.complete();
return [2];
}
});
});
}
function executeSchedule(parentSubscription, scheduler, work, delay2, repeat) {
if (delay2 === void 0) {
delay2 = 0;
}
if (repeat === void 0) {
repeat = false;
}
var scheduleSubscription = scheduler.schedule(function() {
work();
if (repeat) {
parentSubscription.add(this.schedule(null, delay2));
} else {
this.unsubscribe();
}
}, delay2);
parentSubscription.add(scheduleSubscription);
if (!repeat) {
return scheduleSubscription;
}
}
function observeOn(scheduler, delay2) {
if (delay2 === void 0) {
delay2 = 0;
}
return operate(function(source2, subscriber) {
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
return executeSchedule(subscriber, scheduler, function() {
return subscriber.next(value);
}, delay2);
}, function() {
return executeSchedule(subscriber, scheduler, function() {
return subscriber.complete();
}, delay2);
}, function(err) {
return executeSchedule(subscriber, scheduler, function() {
return subscriber.error(err);
}, delay2);
}));
});
}
function subscribeOn(scheduler, delay2) {
if (delay2 === void 0) {
delay2 = 0;
}
return operate(function(source2, subscriber) {
subscriber.add(scheduler.schedule(function() {
return source2.subscribe(subscriber);
}, delay2));
});
}
function scheduleObservable(input, scheduler) {
return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
function schedulePromise(input, scheduler) {
return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
function scheduleArray(input, scheduler) {
return new Observable(function(subscriber) {
var i2 = 0;
return scheduler.schedule(function() {
if (i2 === input.length) {
subscriber.complete();
} else {
subscriber.next(input[i2++]);
if (!subscriber.closed) {
this.schedule();
}
}
});
});
}
function scheduleIterable(input, scheduler) {
return new Observable(function(subscriber) {
var iterator2;
executeSchedule(subscriber, scheduler, function() {
iterator2 = input[iterator]();
executeSchedule(subscriber, scheduler, function() {
var _a6;
var value;
var done;
try {
_a6 = iterator2.next(), value = _a6.value, done = _a6.done;
} catch (err) {
subscriber.error(err);
return;
}
if (done) {
subscriber.complete();
} else {
subscriber.next(value);
}
}, 0, true);
});
return function() {
return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
};
});
}
function scheduleAsyncIterable(input, scheduler) {
if (!input) {
throw new Error("Iterable cannot be null");
}
return new Observable(function(subscriber) {
executeSchedule(subscriber, scheduler, function() {
var iterator2 = input[Symbol.asyncIterator]();
executeSchedule(subscriber, scheduler, function() {
iterator2.next().then(function(result) {
if (result.done) {
subscriber.complete();
} else {
subscriber.next(result.value);
}
});
}, 0, true);
});
});
}
function scheduleReadableStreamLike(input, scheduler) {
return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
}
function scheduled(input, scheduler) {
if (input != null) {
if (isInteropObservable(input)) {
return scheduleObservable(input, scheduler);
}
if (isArrayLike(input)) {
return scheduleArray(input, scheduler);
}
if (isPromise(input)) {
return schedulePromise(input, scheduler);
}
if (isAsyncIterable(input)) {
return scheduleAsyncIterable(input, scheduler);
}
if (isIterable(input)) {
return scheduleIterable(input, scheduler);
}
if (isReadableStreamLike(input)) {
return scheduleReadableStreamLike(input, scheduler);
}
}
throw createInvalidObservableTypeError(input);
}
function from(input, scheduler) {
return scheduler ? scheduled(input, scheduler) : innerFrom(input);
}
function of() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var scheduler = popScheduler(args);
return from(args, scheduler);
}
function lastValueFrom(source2, config2) {
var hasConfig = typeof config2 === "object";
return new Promise(function(resolve5, reject) {
var _hasValue = false;
var _value;
source2.subscribe({
next: function(value) {
_value = value;
_hasValue = true;
},
error: reject,
complete: function() {
if (_hasValue) {
resolve5(_value);
} else if (hasConfig) {
resolve5(config2.defaultValue);
} else {
reject(new EmptyError());
}
}
});
});
}
function firstValueFrom(source2, config2) {
var hasConfig = typeof config2 === "object";
return new Promise(function(resolve5, reject) {
var subscriber = new SafeSubscriber({
next: function(value) {
resolve5(value);
subscriber.unsubscribe();
},
error: reject,
complete: function() {
if (hasConfig) {
resolve5(config2.defaultValue);
} else {
reject(new EmptyError());
}
}
});
source2.subscribe(subscriber);
});
}
function isValidDate(value) {
return value instanceof Date && !isNaN(value);
}
function map(project, thisArg) {
return operate(function(source2, subscriber) {
var index2 = 0;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
subscriber.next(project.call(thisArg, value, index2++));
}));
});
}
function callOrApply(fn, args) {
return isArray(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
}
function mapOneOrManyArgs(fn) {
return map(function(args) {
return callOrApply(fn, args);
});
}
function argsArgArrayOrObject(args) {
if (args.length === 1) {
var first_1 = args[0];
if (isArray2(first_1)) {
return { args: first_1, keys: null };
}
if (isPOJO(first_1)) {
var keys = getKeys(first_1);
return {
args: keys.map(function(key) {
return first_1[key];
}),
keys
};
}
}
return { args, keys: null };
}
function isPOJO(obj) {
return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
}
function createObject(keys, values) {
return keys.reduce(function(result, key, i2) {
return result[key] = values[i2], result;
}, {});
}
function combineLatest() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var scheduler = popScheduler(args);
var resultSelector = popResultSelector(args);
var _a6 = argsArgArrayOrObject(args), observables = _a6.args, keys = _a6.keys;
if (observables.length === 0) {
return from([], scheduler);
}
var result = new Observable(combineLatestInit(observables, scheduler, keys ? function(values) {
return createObject(keys, values);
} : identity));
return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
}
function combineLatestInit(observables, scheduler, valueTransform) {
if (valueTransform === void 0) {
valueTransform = identity;
}
return function(subscriber) {
maybeSchedule(scheduler, function() {
var length = observables.length;
var values = new Array(length);
var active = length;
var remainingFirstValues = length;
var _loop_1 = function(i22) {
maybeSchedule(scheduler, function() {
var source2 = from(observables[i22], scheduler);
var hasFirstValue = false;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
values[i22] = value;
if (!hasFirstValue) {
hasFirstValue = true;
remainingFirstValues--;
}
if (!remainingFirstValues) {
subscriber.next(valueTransform(values.slice()));
}
}, function() {
if (!--active) {
subscriber.complete();
}
}));
}, subscriber);
};
for (var i2 = 0; i2 < length; i2++) {
_loop_1(i2);
}
}, subscriber);
};
}
function maybeSchedule(scheduler, execute, subscription) {
if (scheduler) {
executeSchedule(subscription, scheduler, execute);
} else {
execute();
}
}
function mergeInternals(source2, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
var buffer = [];
var active = 0;
var index2 = 0;
var isComplete = false;
var checkComplete = function() {
if (isComplete && !buffer.length && !active) {
subscriber.complete();
}
};
var outerNext = function(value) {
return active < concurrent ? doInnerSub(value) : buffer.push(value);
};
var doInnerSub = function(value) {
expand && subscriber.next(value);
active++;
var innerComplete = false;
innerFrom(project(value, index2++)).subscribe(createOperatorSubscriber(subscriber, function(innerValue) {
onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
if (expand) {
outerNext(innerValue);
} else {
subscriber.next(innerValue);
}
}, function() {
innerComplete = true;
}, void 0, function() {
if (innerComplete) {
try {
active--;
var _loop_1 = function() {
var bufferedValue = buffer.shift();
if (innerSubScheduler) {
executeSchedule(subscriber, innerSubScheduler, function() {
return doInnerSub(bufferedValue);
});
} else {
doInnerSub(bufferedValue);
}
};
while (buffer.length && active < concurrent) {
_loop_1();
}
checkComplete();
} catch (err) {
subscriber.error(err);
}
}
}));
};
source2.subscribe(createOperatorSubscriber(subscriber, outerNext, function() {
isComplete = true;
checkComplete();
}));
return function() {
additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
};
}
function mergeMap(project, resultSelector, concurrent) {
if (concurrent === void 0) {
concurrent = Infinity;
}
if (isFunction(resultSelector)) {
return mergeMap(function(a2, i2) {
return map(function(b2, ii) {
return resultSelector(a2, b2, i2, ii);
})(innerFrom(project(a2, i2)));
}, concurrent);
} else if (typeof resultSelector === "number") {
concurrent = resultSelector;
}
return operate(function(source2, subscriber) {
return mergeInternals(source2, subscriber, project, concurrent);
});
}
function mergeAll(concurrent) {
if (concurrent === void 0) {
concurrent = Infinity;
}
return mergeMap(identity, concurrent);
}
function concatAll() {
return mergeAll(1);
}
function concat() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return concatAll()(from(args, popScheduler(args)));
}
function defer(observableFactory) {
return new Observable(function(subscriber) {
innerFrom(observableFactory()).subscribe(subscriber);
});
}
function fromEvent(target, eventName, options, resultSelector) {
if (isFunction(options)) {
resultSelector = options;
options = void 0;
}
if (resultSelector) {
return fromEvent(target, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
}
var _a6 = __read(isEventTarget(target) ? eventTargetMethods.map(function(methodName) {
return function(handler) {
return target[methodName](eventName, handler, options);
};
}) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add2 = _a6[0], remove2 = _a6[1];
if (!add2) {
if (isArrayLike(target)) {
return mergeMap(function(subTarget) {
return fromEvent(subTarget, eventName, options);
})(innerFrom(target));
}
}
if (!add2) {
throw new TypeError("Invalid event target");
}
return new Observable(function(subscriber) {
var handler = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return subscriber.next(1 < args.length ? args : args[0]);
};
add2(handler);
return function() {
return remove2(handler);
};
});
}
function toCommonHandlerRegistry(target, eventName) {
return function(methodName) {
return function(handler) {
return target[methodName](eventName, handler);
};
};
}
function isNodeStyleEventEmitter(target) {
return isFunction(target.addListener) && isFunction(target.removeListener);
}
function isJQueryStyleEventEmitter(target) {
return isFunction(target.on) && isFunction(target.off);
}
function isEventTarget(target) {
return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
}
function timer(dueTime, intervalOrScheduler, scheduler) {
if (dueTime === void 0) {
dueTime = 0;
}
if (scheduler === void 0) {
scheduler = async;
}
var intervalDuration = -1;
if (intervalOrScheduler != null) {
if (isScheduler(intervalOrScheduler)) {
scheduler = intervalOrScheduler;
} else {
intervalDuration = intervalOrScheduler;
}
}
return new Observable(function(subscriber) {
var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
if (due < 0) {
due = 0;
}
var n2 = 0;
return scheduler.schedule(function() {
if (!subscriber.closed) {
subscriber.next(n2++);
if (0 <= intervalDuration) {
this.schedule(void 0, intervalDuration);
} else {
subscriber.complete();
}
}
}, due);
});
}
function merge() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var scheduler = popScheduler(args);
var concurrent = popNumber(args, Infinity);
var sources = args;
return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler));
}
function argsOrArgArray(args) {
return args.length === 1 && isArray3(args[0]) ? args[0] : args;
}
function filter(predicate, thisArg) {
return operate(function(source2, subscriber) {
var index2 = 0;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
return predicate.call(thisArg, value, index2++) && subscriber.next(value);
}));
});
}
function race() {
var sources = [];
for (var _i = 0; _i < arguments.length; _i++) {
sources[_i] = arguments[_i];
}
sources = argsOrArgArray(sources);
return sources.length === 1 ? innerFrom(sources[0]) : new Observable(raceInit(sources));
}
function raceInit(sources) {
return function(subscriber) {
var subscriptions = [];
var _loop_1 = function(i22) {
subscriptions.push(innerFrom(sources[i22]).subscribe(createOperatorSubscriber(subscriber, function(value) {
if (subscriptions) {
for (var s2 = 0; s2 < subscriptions.length; s2++) {
s2 !== i22 && subscriptions[s2].unsubscribe();
}
subscriptions = null;
}
subscriber.next(value);
})));
};
for (var i2 = 0; subscriptions && !subscriber.closed && i2 < sources.length; i2++) {
_loop_1(i2);
}
};
}
function bufferCount(bufferSize, startBufferEvery) {
if (startBufferEvery === void 0) {
startBufferEvery = null;
}
startBufferEvery = startBufferEvery !== null && startBufferEvery !== void 0 ? startBufferEvery : bufferSize;
return operate(function(source2, subscriber) {
var buffers = [];
var count = 0;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
var e_1, _a6, e_2, _b2;
var toEmit = null;
if (count++ % startBufferEvery === 0) {
buffers.push([]);
}
try {
for (var buffers_1 = __values(buffers), buffers_1_1 = buffers_1.next(); !buffers_1_1.done; buffers_1_1 = buffers_1.next()) {
var buffer = buffers_1_1.value;
buffer.push(value);
if (bufferSize <= buffer.length) {
toEmit = toEmit !== null && toEmit !== void 0 ? toEmit : [];
toEmit.push(buffer);
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (buffers_1_1 && !buffers_1_1.done && (_a6 = buffers_1.return))
_a6.call(buffers_1);
} finally {
if (e_1)
throw e_1.error;
}
}
if (toEmit) {
try {
for (var toEmit_1 = __values(toEmit), toEmit_1_1 = toEmit_1.next(); !toEmit_1_1.done; toEmit_1_1 = toEmit_1.next()) {
var buffer = toEmit_1_1.value;
arrRemove(buffers, buffer);
subscriber.next(buffer);
}
} catch (e_2_1) {
e_2 = { error: e_2_1 };
} finally {
try {
if (toEmit_1_1 && !toEmit_1_1.done && (_b2 = toEmit_1.return))
_b2.call(toEmit_1);
} finally {
if (e_2)
throw e_2.error;
}
}
}
}, function() {
var e_3, _a6;
try {
for (var buffers_2 = __values(buffers), buffers_2_1 = buffers_2.next(); !buffers_2_1.done; buffers_2_1 = buffers_2.next()) {
var buffer = buffers_2_1.value;
subscriber.next(buffer);
}
} catch (e_3_1) {
e_3 = { error: e_3_1 };
} finally {
try {
if (buffers_2_1 && !buffers_2_1.done && (_a6 = buffers_2.return))
_a6.call(buffers_2);
} finally {
if (e_3)
throw e_3.error;
}
}
subscriber.complete();
}, void 0, function() {
buffers = null;
}));
});
}
function catchError(selector) {
return operate(function(source2, subscriber) {
var innerSub = null;
var syncUnsub = false;
var handledResult;
innerSub = source2.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
handledResult = innerFrom(selector(err, catchError(selector)(source2)));
if (innerSub) {
innerSub.unsubscribe();
innerSub = null;
handledResult.subscribe(subscriber);
} else {
syncUnsub = true;
}
}));
if (syncUnsub) {
innerSub.unsubscribe();
innerSub = null;
handledResult.subscribe(subscriber);
}
});
}
function concatMap(project, resultSelector) {
return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
}
function defaultIfEmpty(defaultValue) {
return operate(function(source2, subscriber) {
var hasValue = false;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
hasValue = true;
subscriber.next(value);
}, function() {
if (!hasValue) {
subscriber.next(defaultValue);
}
subscriber.complete();
}));
});
}
function take(count) {
return count <= 0 ? function() {
return EMPTY;
} : operate(function(source2, subscriber) {
var seen = 0;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
if (++seen <= count) {
subscriber.next(value);
if (count <= seen) {
subscriber.complete();
}
}
}));
});
}
function ignoreElements() {
return operate(function(source2, subscriber) {
source2.subscribe(createOperatorSubscriber(subscriber, noop));
});
}
function mapTo(value) {
return map(function() {
return value;
});
}
function delayWhen(delayDurationSelector, subscriptionDelay) {
if (subscriptionDelay) {
return function(source2) {
return concat(subscriptionDelay.pipe(take(1), ignoreElements()), source2.pipe(delayWhen(delayDurationSelector)));
};
}
return mergeMap(function(value, index2) {
return innerFrom(delayDurationSelector(value, index2)).pipe(take(1), mapTo(value));
});
}
function throwIfEmpty(errorFactory) {
if (errorFactory === void 0) {
errorFactory = defaultErrorFactory;
}
return operate(function(source2, subscriber) {
var hasValue = false;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
hasValue = true;
subscriber.next(value);
}, function() {
return hasValue ? subscriber.complete() : subscriber.error(errorFactory());
}));
});
}
function defaultErrorFactory() {
return new EmptyError();
}
function first(predicate, defaultValue) {
var hasDefaultValue = arguments.length >= 2;
return function(source2) {
return source2.pipe(predicate ? filter(function(v2, i2) {
return predicate(v2, i2, source2);
}) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
return new EmptyError();
}));
};
}
function mergeScan(accumulator, seed, concurrent) {
if (concurrent === void 0) {
concurrent = Infinity;
}
return operate(function(source2, subscriber) {
var state = seed;
return mergeInternals(source2, subscriber, function(value, index2) {
return accumulator(state, value, index2);
}, concurrent, function(value) {
state = value;
}, false, void 0, function() {
return state = null;
});
});
}
function raceWith() {
var otherSources = [];
for (var _i = 0; _i < arguments.length; _i++) {
otherSources[_i] = arguments[_i];
}
return !otherSources.length ? identity : operate(function(source2, subscriber) {
raceInit(__spreadArray([source2], __read(otherSources)))(subscriber);
});
}
function retry(configOrCount) {
if (configOrCount === void 0) {
configOrCount = Infinity;
}
var config2;
if (configOrCount && typeof configOrCount === "object") {
config2 = configOrCount;
} else {
config2 = {
count: configOrCount
};
}
var _a6 = config2.count, count = _a6 === void 0 ? Infinity : _a6, delay2 = config2.delay, _b2 = config2.resetOnSuccess, resetOnSuccess = _b2 === void 0 ? false : _b2;
return count <= 0 ? identity : operate(function(source2, subscriber) {
var soFar = 0;
var innerSub;
var subscribeForRetry = function() {
var syncUnsub = false;
innerSub = source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
if (resetOnSuccess) {
soFar = 0;
}
subscriber.next(value);
}, void 0, function(err) {
if (soFar++ < count) {
var resub_1 = function() {
if (innerSub) {
innerSub.unsubscribe();
innerSub = null;
subscribeForRetry();
} else {
syncUnsub = true;
}
};
if (delay2 != null) {
var notifier = typeof delay2 === "number" ? timer(delay2) : innerFrom(delay2(err, soFar));
var notifierSubscriber_1 = createOperatorSubscriber(subscriber, function() {
notifierSubscriber_1.unsubscribe();
resub_1();
}, function() {
subscriber.complete();
});
notifier.subscribe(notifierSubscriber_1);
} else {
resub_1();
}
} else {
subscriber.error(err);
}
}));
if (syncUnsub) {
innerSub.unsubscribe();
innerSub = null;
subscribeForRetry();
}
};
subscribeForRetry();
});
}
function startWith() {
var values = [];
for (var _i = 0; _i < arguments.length; _i++) {
values[_i] = arguments[_i];
}
var scheduler = popScheduler(values);
return operate(function(source2, subscriber) {
(scheduler ? concat(values, source2, scheduler) : concat(values, source2)).subscribe(subscriber);
});
}
function switchMap(project, resultSelector) {
return operate(function(source2, subscriber) {
var innerSubscriber = null;
var index2 = 0;
var isComplete = false;
var checkComplete = function() {
return isComplete && !innerSubscriber && subscriber.complete();
};
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
var innerIndex = 0;
var outerIndex = index2++;
innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, function(innerValue) {
return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue);
}, function() {
innerSubscriber = null;
checkComplete();
}));
}, function() {
isComplete = true;
checkComplete();
}));
});
}
function takeUntil(notifier) {
return operate(function(source2, subscriber) {
innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
return subscriber.complete();
}, noop));
!subscriber.closed && source2.subscribe(subscriber);
});
}
function tap(observerOrNext, error, complete) {
var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
return tapObserver ? operate(function(source2, subscriber) {
var _a6;
(_a6 = tapObserver.subscribe) === null || _a6 === void 0 ? void 0 : _a6.call(tapObserver);
var isUnsub = true;
source2.subscribe(createOperatorSubscriber(subscriber, function(value) {
var _a22;
(_a22 = tapObserver.next) === null || _a22 === void 0 ? void 0 : _a22.call(tapObserver, value);
subscriber.next(value);
}, function() {
var _a22;
isUnsub = false;
(_a22 = tapObserver.complete) === null || _a22 === void 0 ? void 0 : _a22.call(tapObserver);
subscriber.complete();
}, function(err) {
var _a22;
isUnsub = false;
(_a22 = tapObserver.error) === null || _a22 === void 0 ? void 0 : _a22.call(tapObserver, err);
subscriber.error(err);
}, function() {
var _a22, _b2;
if (isUnsub) {
(_a22 = tapObserver.unsubscribe) === null || _a22 === void 0 ? void 0 : _a22.call(tapObserver);
}
(_b2 = tapObserver.finalize) === null || _b2 === void 0 ? void 0 : _b2.call(tapObserver);
}));
}) : identity;
}
var extendStatics, UnsubscriptionError, Subscription, EMPTY_SUBSCRIPTION, config, timeoutProvider, COMPLETE_NOTIFICATION, context, Subscriber, _bind, ConsumerObserver, SafeSubscriber, EMPTY_OBSERVER, observable, Observable, OperatorSubscriber, ObjectUnsubscribedError, Subject, AnonymousSubject, dateTimestampProvider, ReplaySubject, Action, intervalProvider, AsyncAction, Scheduler, AsyncScheduler, asyncScheduler, async, EMPTY, isArrayLike, iterator, EmptyError, isArray, isArray2, getPrototypeOf, objectProto, getKeys, nodeEventEmitterMethods, eventTargetMethods, jqueryMethods, NEVER, isArray3;
var init_rxjs = __esm({
"node_modules/puppeteer-core/lib/esm/third_party/rxjs/rxjs.js"() {
extendStatics = function(d2, b2) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d22, b22) {
d22.__proto__ = b22;
} || function(d22, b22) {
for (var p2 in b22)
if (Object.prototype.hasOwnProperty.call(b22, p2))
d22[p2] = b22[p2];
};
return extendStatics(d2, b2);
};
UnsubscriptionError = createErrorClass(function(_super) {
return function UnsubscriptionErrorImpl(errors) {
_super(this);
this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i2) {
return i2 + 1 + ") " + err.toString();
}).join("\n ") : "";
this.name = "UnsubscriptionError";
this.errors = errors;
};
});
Subscription = function() {
function Subscription2(initialTeardown) {
this.initialTeardown = initialTeardown;
this.closed = false;
this._parentage = null;
this._finalizers = null;
}
Subscription2.prototype.unsubscribe = function() {
var e_1, _a6, e_2, _b2;
var errors;
if (!this.closed) {
this.closed = true;
var _parentage = this._parentage;
if (_parentage) {
this._parentage = null;
if (Array.isArray(_parentage)) {
try {
for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
var parent_1 = _parentage_1_1.value;
parent_1.remove(this);
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (_parentage_1_1 && !_parentage_1_1.done && (_a6 = _parentage_1.return))
_a6.call(_parentage_1);
} finally {
if (e_1)
throw e_1.error;
}
}
} else {
_parentage.remove(this);
}
}
var initialFinalizer = this.initialTeardown;
if (isFunction(initialFinalizer)) {
try {
initialFinalizer();
} catch (e2) {
errors = e2 instanceof UnsubscriptionError ? e2.errors : [e2];
}
}
var _finalizers = this._finalizers;
if (_finalizers) {
this._finalizers = null;
try {
for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
var finalizer = _finalizers_1_1.value;